diff --git a/AST/AST.java b/AST/AST.java
index f30471767ef46d5ffe5a3c806085c21d51fe8166..badfadc9ff74a213aa478a5f81c8a9133f01eab1 100644
--- a/AST/AST.java
+++ b/AST/AST.java
@@ -1,3 +1,4 @@
+
package AST;
import java.util.Deque;
import java.util.ArrayDeque;
diff --git a/AST/Assignment.java b/AST/Assignment.java
new file mode 100644
index 0000000000000000000000000000000000000000..85482ba80db9c5eaf059db4278893e6e694dc0e8
--- /dev/null
+++ b/AST/Assignment.java
@@ -0,0 +1,24 @@
+package AST;
+
+// Classe pour représenter une affectation de variable
+public class Assignment extends ExpressionA {
+ private String varName;
+ private ExpressionA expression;
+
+ public Assignment(String varName, ExpressionA expr) {
+ this.varName = varName;
+ this.expression = expr;
+ }
+
+ @Override
+ public String toAssembly() {
+ return expression.toAssembly() + "SetVar " + varName + "\n";
+ }
+
+
+ public Object evaluate() {
+ Object value = expression.evaluate();
+ SymbolTable.assignVariable(varName, value);
+ return value;
+ }
+}
diff --git a/AST/Bool.java b/AST/Bool.java
index 27652641fcb9e8f9cd7a1fc34951adede4dffee4..2272a4994eae24baf63158c50d66a448c66fab42 100644
--- a/AST/Bool.java
+++ b/AST/Bool.java
@@ -13,4 +13,9 @@ public class Bool extends ExpressionA {
public String toAssembly() {
return "CsteBo " + num+"\n";
}
+
+ @Override
+ public Object evaluate() {
+ return num;
+ }
}
diff --git a/AST/Commande.java b/AST/Commande.java
index 6c6ea437c6e153b80f55132c31b03a363d38b4f9..48a8a7656261c621ea8138e4c4c7234157a4133a 100644
--- a/AST/Commande.java
+++ b/AST/Commande.java
@@ -1,4 +1,6 @@
package AST;
public abstract class Commande extends AST{
public abstract String toAssembly();
-}
\ No newline at end of file
+}
+
+
diff --git a/AST/Div.java b/AST/Div.java
index 5aa829622d633efd542ecfb54df08a22842cd85b..e9306b577190004d32c783f70c75c17df727f1d3 100644
--- a/AST/Div.java
+++ b/AST/Div.java
@@ -12,4 +12,23 @@ public class Div extends ExpressionA_Binaire {
public String toAssembly() {
return gauche.toAssembly() + droite.toAssembly() + "DivNb\n";
}
+
+ @Override
+ public Object evaluate() {
+ Object leftValue = gauche.evaluate();
+ Object rightValue = droite.evaluate();
+
+ if (leftValue instanceof Integer && rightValue instanceof Integer) {
+ return (Integer) leftValue / (Integer) rightValue;
+ } else if (leftValue instanceof Float && rightValue instanceof Float) {
+ return (Float) leftValue / (Float) rightValue;
+ } else if (leftValue instanceof Integer && rightValue instanceof Float) {
+ return (Integer) leftValue / (Float) rightValue;
+ } else if (leftValue instanceof Float && rightValue instanceof Integer) {
+ return (Float) leftValue / (Integer) rightValue;
+ } else {
+ throw new RuntimeException("Unsupported types for Div operation: "
+ + leftValue.getClass().getName() + " and " + rightValue.getClass().getName());
+ }
+ }
}
diff --git a/AST/DoWhileCommand.java b/AST/DoWhileCommand.java
new file mode 100644
index 0000000000000000000000000000000000000000..c3e7629f1f7bfcf3f4e18bbe7ebb1e9309cfac91
--- /dev/null
+++ b/AST/DoWhileCommand.java
@@ -0,0 +1,18 @@
+package AST;
+
+// Classe pour représenter une variable
+public class DoWhileCommand extends Commande {
+ private ExpressionA cond;
+ private Commande cmd;
+
+ public DoWhileCommand(Commande cmd, ExpressionA expr) {
+ this.cmd=cmd;
+ this.cond=expr;
+ }
+ @Override
+ public String toAssembly() {
+ String s = (this.cmd).toAssembly();
+ String c = (this.cond).toAssembly();
+ return s + c + "ConJmp -" + (Tools.countNewLines(s) + Tools.countNewLines(c)-1) + "\n";
+ }
+}
diff --git a/AST/Egal.java b/AST/Egal.java
index 4a61e077a231a3496b8ba643340674e487e1a645..2d6f6d87c7858c839036ce9083c9f530956338ac 100644
--- a/AST/Egal.java
+++ b/AST/Egal.java
@@ -12,4 +12,21 @@ public class Egal extends ExpressionA_Binaire {
public String toAssembly() {
return gauche.toAssembly() + droite.toAssembly() + "Equals\n";
}
+
+ @Override
+ public Object evaluate() {
+ Object leftValue = gauche.evaluate();
+ Object rightValue = droite.evaluate();
+
+ if (leftValue == null || rightValue == null) {
+ return leftValue == rightValue;
+ }
+
+ if (!leftValue.getClass().equals(rightValue.getClass())) {
+ throw new RuntimeException("Cannot compare values of different types: "
+ + leftValue.getClass().getName() + " and " + rightValue.getClass().getName());
+ }
+
+ return leftValue.equals(rightValue);
+ }
}
diff --git a/AST/EmptyCommand.java b/AST/EmptyCommand.java
new file mode 100644
index 0000000000000000000000000000000000000000..909bd311cd6e8572097b7c688c84601a7d97b8a0
--- /dev/null
+++ b/AST/EmptyCommand.java
@@ -0,0 +1,10 @@
+package AST;
+
+public class EmptyCommand extends Commande{
+ public EmptyCommand(){}
+
+ @Override
+ public String toAssembly(){
+ return "";
+ }
+}
\ No newline at end of file
diff --git a/AST/Et.java b/AST/Et.java
index f0ff6e286338510a7c9a4e30536358eb286e2818..81d3b60cd769dfe83728b9c4fade631d6d9aa241 100644
--- a/AST/Et.java
+++ b/AST/Et.java
@@ -12,4 +12,17 @@ public class Et extends ExpressionA_Binaire {
public String toAssembly() {
return gauche.toAssembly() +"ConJmp "+Tools.countNewLines(droite.toAssembly())+"\n"+ droite.toAssembly() + "Jump 2\n"+"CstBo False\n";
}
+
+ @Override
+ public Object evaluate() {
+ Object leftValue = gauche.evaluate();
+ Object rightValue = droite.evaluate();
+
+ if (leftValue instanceof Boolean && rightValue instanceof Boolean) {
+ return (Boolean) leftValue && (Boolean) rightValue;
+ } else {
+ throw new RuntimeException("Unsupported types for Et operation: "
+ + leftValue.getClass().getName() + " and " + rightValue.getClass().getName());
+ }
+ }
}
diff --git a/AST/ExpressionA.java b/AST/ExpressionA.java
index f453d8084c6b6275cb1efa29adee1cb2a79f737e..10f91a237b6a46c92ac9d07b8233bc87b3d2f658 100644
--- a/AST/ExpressionA.java
+++ b/AST/ExpressionA.java
@@ -1,6 +1,5 @@
package AST;
public abstract class ExpressionA extends Commande {
- // un jour il y aura d'autres choses ici
- //public abstract String toAssembly();
+ public abstract Object evaluate();
}
diff --git a/AST/ExpressionA_Binaire.java b/AST/ExpressionA_Binaire.java
index 2fb339e132d482ffbe795925308ba7d003ff21c3..c270213aff7788452350d5509c42171fb6b846fc 100644
--- a/AST/ExpressionA_Binaire.java
+++ b/AST/ExpressionA_Binaire.java
@@ -16,4 +16,6 @@ abstract class ExpressionA_Binaire extends ExpressionA {
public String toString() {
return String.format("%1$s(%2$s,%3$s)", symbole(), gauche.toString(), droite.toString());
}
+
+ public abstract Object evaluate();
}
diff --git a/AST/FloatT.java b/AST/FloatT.java
index ae7215bd75ccf218a0a036cbac32e597d2e60e4a..c3eb2964a16dfe4ffd6fbb11d9243f53b81ddf78 100644
--- a/AST/FloatT.java
+++ b/AST/FloatT.java
@@ -19,4 +19,9 @@ public class FloatT extends ExpressionA {
public String toAssembly() {
return "CsteNb " + this.arg + "\n";
}
+
+ @Override
+ public Object evaluate() {
+ return this.arg;
+ }
}
diff --git a/AST/GrEgNb.java b/AST/GrEgNb.java
index 03c2aab41852088fb0ee091131cb72cdf6f280db..955f1ea8390ce547310c9348f267ab406bd3067c 100644
--- a/AST/GrEgNb.java
+++ b/AST/GrEgNb.java
@@ -12,4 +12,23 @@ public class GrEgNb extends ExpressionA_Binaire {
public String toAssembly() {
return gauche.toAssembly() + droite.toAssembly() + "GrEqNb\n";
}
+
+ @Override
+ public Object evaluate() {
+ Object leftValue = gauche.evaluate();
+ Object rightValue = droite.evaluate();
+
+ if (leftValue instanceof Integer && rightValue instanceof Integer) {
+ return (Integer) leftValue >= (Integer) rightValue;
+ } else if (leftValue instanceof Float && rightValue instanceof Float) {
+ return (Float) leftValue >= (Float) rightValue;
+ } else if (leftValue instanceof Integer && rightValue instanceof Float) {
+ return (Integer) leftValue >= (Float) rightValue;
+ } else if (leftValue instanceof Float && rightValue instanceof Integer) {
+ return (Float) leftValue >= (Integer) rightValue;
+ } else {
+ throw new RuntimeException("Unsupported types for GrEqNb operation: "
+ + leftValue.getClass().getName() + " and " + rightValue.getClass().getName());
+ }
+ }
}
diff --git a/AST/GrStNb.java b/AST/GrStNb.java
index 4db76e1b9428f07fab22b899a3b90dc0a540e6f4..8f6458d0253446154a6e0b665e409afe927ac908 100644
--- a/AST/GrStNb.java
+++ b/AST/GrStNb.java
@@ -12,4 +12,23 @@ public class GrStNb extends ExpressionA_Binaire {
public String toAssembly() {
return gauche.toAssembly() + droite.toAssembly() + "GrStNb\n";
}
+
+ @Override
+ public Object evaluate() {
+ Object leftValue = gauche.evaluate();
+ Object rightValue = droite.evaluate();
+
+ if (leftValue instanceof Integer && rightValue instanceof Integer) {
+ return (Integer) leftValue > (Integer) rightValue;
+ } else if (leftValue instanceof Float && rightValue instanceof Float) {
+ return (Float) leftValue > (Float) rightValue;
+ } else if (leftValue instanceof Integer && rightValue instanceof Float) {
+ return (Integer) leftValue > (Float) rightValue;
+ } else if (leftValue instanceof Float && rightValue instanceof Integer) {
+ return (Float) leftValue > (Integer) rightValue;
+ } else {
+ throw new RuntimeException("Unsupported types for GrStNb operation: "
+ + leftValue.getClass().getName() + " and " + rightValue.getClass().getName());
+ }
+ }
}
diff --git a/AST/Ident.java b/AST/Ident.java
index 204efa21bfbc766cd21aa5a5a887cc97169158a5..264cf28efe594c6f924963498a81f5dee355fc16 100644
--- a/AST/Ident.java
+++ b/AST/Ident.java
@@ -9,6 +9,10 @@ public class Ident extends ExpressionA{
}
public String toAssembly() {
- return "" ;
+ return "GetVar " + this.arg + "\n";
+ }
+ @Override
+ public Object evaluate() {
+ return SymbolTable.getVariable(arg);
}
}
\ No newline at end of file
diff --git a/AST/IfElseCommand.java b/AST/IfElseCommand.java
new file mode 100644
index 0000000000000000000000000000000000000000..042def16b18ce4b4353dbab33cd96dbf5a7f2173
--- /dev/null
+++ b/AST/IfElseCommand.java
@@ -0,0 +1,26 @@
+package AST;
+
+// Classe pour représenter une commande if-then-else
+public class IfElseCommand extends Commande {
+ private ExpressionA condition;
+ private Commande trueBranch;
+ private Commande falseBranch;
+
+ public IfElseCommand(ExpressionA condition, Commande trueBranch, Commande falseBranch) {
+ this.condition = condition;
+ this.trueBranch = trueBranch;
+ this.falseBranch = falseBranch;
+ }
+
+ @Override
+ public String toAssembly() {
+
+ String t = trueBranch.toAssembly();
+ String f = falseBranch.toAssembly();
+ String e = this.condition.toAssembly();
+
+
+
+ return e + "Conjmp "+ Tools.countNewLines(t) +"\n"+ t + "Jump "+ Tools.countNewLines(f) + "\n" + t ;
+ }
+}
diff --git a/AST/LoEqNb.java b/AST/LoEqNb.java
index fd6a521a0f13da6554de3c4de888a8e8e6ba6664..2cb6794e427ffcbb2960451b137fd74aa8e36bff 100644
--- a/AST/LoEqNb.java
+++ b/AST/LoEqNb.java
@@ -12,4 +12,22 @@ public class LoEqNb extends ExpressionA_Binaire {
public String toAssembly() {
return gauche.toAssembly() + droite.toAssembly() + "LoEqNb\n";
}
+ @Override
+ public Object evaluate() {
+ Object leftValue = gauche.evaluate();
+ Object rightValue = droite.evaluate();
+
+ if (leftValue instanceof Integer && rightValue instanceof Integer) {
+ return (Integer) leftValue <= (Integer) rightValue;
+ } else if (leftValue instanceof Float && rightValue instanceof Float) {
+ return (Float) leftValue <= (Float) rightValue;
+ } else if (leftValue instanceof Integer && rightValue instanceof Float) {
+ return (Integer) leftValue <= (Float) rightValue;
+ } else if (leftValue instanceof Float && rightValue instanceof Integer) {
+ return (Float) leftValue <= (Integer) rightValue;
+ } else {
+ throw new RuntimeException("Unsupported types for LoEqNb operation: "
+ + leftValue.getClass().getName() + " and " + rightValue.getClass().getName());
+ }
+ }
}
diff --git a/AST/LoStNb.java b/AST/LoStNb.java
index 953f9624d946c854bc166e9cc9ba787dd42eb740..c2bce2bd5b6d4406a31c872507e10c1b9d5cc3bf 100644
--- a/AST/LoStNb.java
+++ b/AST/LoStNb.java
@@ -12,4 +12,24 @@ public class LoStNb extends ExpressionA_Binaire {
public String toAssembly() {
return gauche.toAssembly() + droite.toAssembly() + "LoStNb\n";
}
+
+
+ @Override
+ public Object evaluate() {
+ Object leftValue = gauche.evaluate();
+ Object rightValue = droite.evaluate();
+
+ if (leftValue instanceof Integer && rightValue instanceof Integer) {
+ return (Integer) leftValue < (Integer) rightValue;
+ } else if (leftValue instanceof Float && rightValue instanceof Float) {
+ return (Float) leftValue < (Float) rightValue;
+ } else if (leftValue instanceof Integer && rightValue instanceof Float) {
+ return (Integer) leftValue < (Float) rightValue;
+ } else if (leftValue instanceof Float && rightValue instanceof Integer) {
+ return (Float) leftValue < (Integer) rightValue;
+ } else {
+ throw new RuntimeException("Unsupported types for LoStNb operation: "
+ + leftValue.getClass().getName() + " and " + rightValue.getClass().getName());
+ }
+ }
}
diff --git a/AST/Modulo.java b/AST/Modulo.java
index b02615f3782638f78ebcd67c4f2b9c116a1c3ad1..506f5e8452ce1ac3bc2ed83369c106d71a27bed4 100644
--- a/AST/Modulo.java
+++ b/AST/Modulo.java
@@ -8,4 +8,23 @@ public class Modulo extends ExpressionA_Binaire {
public String toAssembly() {
return gauche.toAssembly() + droite.toAssembly() + "ModuNb\n";
}
+
+ @Override
+ public Object evaluate() {
+ Object leftValue = gauche.evaluate();
+ Object rightValue = droite.evaluate();
+
+ if (leftValue instanceof Integer && rightValue instanceof Integer) {
+ return (Integer) leftValue % (Integer) rightValue;
+ } else if (leftValue instanceof Float && rightValue instanceof Float) {
+ return (Float) leftValue % (Float) rightValue;
+ } else if (leftValue instanceof Integer && rightValue instanceof Float) {
+ return (Integer) leftValue % (Float) rightValue;
+ } else if (leftValue instanceof Float && rightValue instanceof Integer) {
+ return (Float) leftValue % (Integer) rightValue;
+ } else {
+ throw new RuntimeException("Unsupported types for Modulo operation: "
+ + leftValue.getClass().getName() + " and " + rightValue.getClass().getName());
+ }
+ }
}
diff --git a/AST/Moins.java b/AST/Moins.java
index 76182ca95966da15cfdfccec3d9fbbb161fb5e16..025f82d49a2edc05febefd2153e43bcefd8b2958 100644
--- a/AST/Moins.java
+++ b/AST/Moins.java
@@ -8,4 +8,23 @@ public String symbole() {return "moins";};
public String toAssembly() {
return gauche.toAssembly() + droite.toAssembly() + "SubiNb\n";
}
+
+@Override
+ public Object evaluate() {
+ Object leftValue = gauche.evaluate();
+ Object rightValue = droite.evaluate();
+
+ if (leftValue instanceof Integer && rightValue instanceof Integer) {
+ return (Integer) leftValue - (Integer) rightValue;
+ } else if (leftValue instanceof Float && rightValue instanceof Float) {
+ return (Float) leftValue - (Float) rightValue;
+ } else if (leftValue instanceof Integer && rightValue instanceof Float) {
+ return (Integer) leftValue - (Float) rightValue;
+ } else if (leftValue instanceof Float && rightValue instanceof Integer) {
+ return (Float) leftValue - (Integer) rightValue;
+ } else {
+ throw new RuntimeException("Unsupported types for Moins operation: "
+ + leftValue.getClass().getName() + " and " + rightValue.getClass().getName());
+ }
+ }
}
diff --git a/AST/Mult.java b/AST/Mult.java
index 5c5c8044114d8200d50583ac4736e173b120aa81..02a76f549be9d6f3ca7c7614bdcd2d25efc0d707 100644
--- a/AST/Mult.java
+++ b/AST/Mult.java
@@ -8,4 +8,23 @@ public String symbole() {return "fois";};
public String toAssembly() {
return gauche.toAssembly() + droite.toAssembly() + "MultNb\n";
}
+
+@Override
+ public Object evaluate() {
+ Object leftValue = gauche.evaluate();
+ Object rightValue = droite.evaluate();
+
+ if (leftValue instanceof Integer && rightValue instanceof Integer) {
+ return (Integer) leftValue * (Integer) rightValue;
+ } else if (leftValue instanceof Float && rightValue instanceof Float) {
+ return (Float) leftValue * (Float) rightValue;
+ } else if (leftValue instanceof Integer && rightValue instanceof Float) {
+ return (Integer) leftValue * (Float) rightValue;
+ } else if (leftValue instanceof Float && rightValue instanceof Integer) {
+ return (Float) leftValue * (Integer) rightValue;
+ } else {
+ throw new RuntimeException("Unsupported types for Mult operation: "
+ + leftValue.getClass().getName() + " and " + rightValue.getClass().getName());
+ }
+ }
}
diff --git a/AST/Neg.java b/AST/Neg.java
index d3bf1aa30d5a8d08e6519230ccd135daa85acf1b..dd2218d3a693344757eba6c0609f546eefda2588 100644
--- a/AST/Neg.java
+++ b/AST/Neg.java
@@ -14,4 +14,16 @@ public String toString() {
public String toAssembly() {
return (arg.toAssembly())+"NegaNb\n";
}
+ @Override
+ public Object evaluate() {
+ Object value = arg.evaluate();
+
+ if (value instanceof Integer) {
+ return -(Integer) value;
+ } else if (value instanceof Float) {
+ return -(Float) value;
+ } else {
+ throw new RuntimeException("Unsupported type for Neg operation: " + value.getClass().getName());
+ }
+ }
}
diff --git a/AST/Not.java b/AST/Not.java
index 8cdde2e820e275752a3de321017d3efc2eabec9c..b7a085a2d7f9efb4e5f97b01157d3b455ec822e8 100644
--- a/AST/Not.java
+++ b/AST/Not.java
@@ -14,4 +14,14 @@ public class Not extends ExpressionA {
public String toAssembly() {
return (arg.toAssembly())+"Not\n";
}
+
+ @Override
+ public Object evaluate() {
+ Object value = arg.evaluate();
+ if (value instanceof Boolean) {
+ return !(Boolean) value;
+ } else {
+ throw new RuntimeException("Invalid type for Not operation: " + value.getClass().getName());
+ }
+ }
}
diff --git a/AST/NotEql.java b/AST/NotEql.java
index 33e5304dc634e2fa93d2faa7ba1b7ce158dde9eb..fd9c350965987b92a7147883f2175b0a19a6fec6 100644
--- a/AST/NotEql.java
+++ b/AST/NotEql.java
@@ -12,4 +12,28 @@ public class NotEql extends ExpressionA_Binaire {
public String toAssembly() {
return gauche.toAssembly() + droite.toAssembly() + "NotEql\n";
}
+
+ @Override
+ public Object evaluate() {
+ Object leftValue = gauche.evaluate();
+ Object rightValue = droite.evaluate();
+
+ if (leftValue == null || rightValue == null) {
+ return leftValue != rightValue;
+ }
+
+ if (!leftValue.getClass().equals(rightValue.getClass())) {
+ throw new RuntimeException("Cannot compare values of different types: " + leftValue.getClass().getName() + " and " + rightValue.getClass().getName());
+ }
+
+ if (leftValue instanceof Integer) {
+ return !leftValue.equals(rightValue);
+ } else if (leftValue instanceof Boolean) {
+ return !leftValue.equals(rightValue);
+ } else if (leftValue instanceof Float) {
+ return !leftValue.equals(rightValue);
+ } else {
+ throw new RuntimeException("Unsupported types for NotEqual operation: " + leftValue.getClass().getName());
+ }
+ }
}
diff --git a/AST/Num.java b/AST/Num.java
index 461a153e1ac95cc581d1db8cd2fa8806d2918025..1024fe05c524da69ce2e1cd20564feeb559a4d7b 100644
--- a/AST/Num.java
+++ b/AST/Num.java
@@ -13,4 +13,9 @@ public class Num extends ExpressionA {
public String toAssembly() {
return "CsteNb " + num+"\n";
}
+
+ @Override
+ public Object evaluate() {
+ return num;
+ }
}
diff --git a/AST/Plus.java b/AST/Plus.java
index 17d4083196c2d344f634f7491fd2bb0c9efdb44e..41b6682515bf9e26e00432f1a38be2e85bceb1eb 100644
--- a/AST/Plus.java
+++ b/AST/Plus.java
@@ -8,4 +8,10 @@ public String symbole() {return "plus";};
public String toAssembly() {
return gauche.toAssembly() + droite.toAssembly() + "AddiNb\n";
}
+
+
+@Override
+ public Object evaluate() {
+ return (Integer) gauche.evaluate() + (Integer) droite.evaluate();
+ }
}
diff --git a/AST/Programme.java b/AST/Programme.java
index d75d30a8c6a0bc1263667448286b200a28b6ffe7..75f2d5dbf9bce4362a0358f348d562d5f8e7e3b8 100644
--- a/AST/Programme.java
+++ b/AST/Programme.java
@@ -15,7 +15,10 @@ public class Programme extends AST {
public String toAssembly() {
String assembly = "";
for (Commande commande : commandes) {
- assembly = assembly+commande.toAssembly()+"Drop\n";
+ assembly = assembly+commande.toAssembly();
+ if(commande instanceof ExpressionA){
+ assembly+="Drop"+"\n";
+ }
}
return assembly;
diff --git a/AST/SymbolTable.java b/AST/SymbolTable.java
new file mode 100644
index 0000000000000000000000000000000000000000..6cc23c304e4108e8dabe1f2409b5dff101fc8964
--- /dev/null
+++ b/AST/SymbolTable.java
@@ -0,0 +1,27 @@
+package AST;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class SymbolTable {
+ private static Map<String, Object> table = new HashMap<>();
+
+ // Assign a variable with a value
+ public static void assignVariable(String name, Object value) {
+ table.put(name, value);
+ }
+
+ // Retrieve a variable's value
+ public static Object getVariable(String name) {
+ if (table.containsKey(name)) {
+ return table.get(name);
+ }
+ throw new RuntimeException("Variable " + name + " not defined.");
+ }
+
+ // Check if a variable is already defined
+ public static boolean isVariableDefined(String name) {
+ return table.containsKey(name);
+ }
+}
+
diff --git a/AST/VariableExpr.java b/AST/VariableExpr.java
new file mode 100644
index 0000000000000000000000000000000000000000..f7be3e5da456c8616b6afbc02d5b8b50ad038f24
--- /dev/null
+++ b/AST/VariableExpr.java
@@ -0,0 +1,20 @@
+package AST;
+
+// Classe pour représenter une variable
+public class VariableExpr extends ExpressionA {
+ private String name;
+
+ public VariableExpr(String name) {
+ this.name = name;
+ }
+
+ @Override
+ public String toAssembly() {
+ return "GetVar " + name + "\n";
+ }
+
+ @Override
+ public Object evaluate() {
+ return SymbolTable.getVariable(name);
+ }
+}
diff --git a/Compilateur$JJCalls.class b/Compilateur$JJCalls.class
new file mode 100644
index 0000000000000000000000000000000000000000..3d0aa7fce1b2f43f24b9be3321d8f0397f1108c1
Binary files /dev/null and b/Compilateur$JJCalls.class differ
diff --git a/Compilateur$LookaheadSuccess.class b/Compilateur$LookaheadSuccess.class
new file mode 100644
index 0000000000000000000000000000000000000000..bd052506d726cd77265dab73e2ae256b1d557a5b
Binary files /dev/null and b/Compilateur$LookaheadSuccess.class differ
diff --git a/Compilateur.jj b/Compilateur.jj
index 5bed1612e55c4ecdbee2a6b1c1eb9e9936454761..ad7c78c74e3b0ac8a1b9cd32d10f9328851b5e9a 100644
--- a/Compilateur.jj
+++ b/Compilateur.jj
@@ -9,128 +9,130 @@ import java.io.InputStream;
public class Compilateur {
public static void main(String args[]) {
try {
- //System.out.print("Tapez une Expression : ");
+ // Ouvre le fichier "test.js" pour lecture
FileInputStream fis = new FileInputStream("test.js");
+ // Crée une instance du parseur
Compilateur parseur = new Compilateur(fis);
- Programme programme = parseur.mainNT(); // Changer pour Programme
- System.out.println("Assembly code : \n" + programme.toAssembly()+"Halt"); // Modifier pour générer l'assembleur
+ // Parse le fichier et obtient le programme
+ Programme programme = parseur.mainNT();
+ // Affiche le code assembleur généré
+ System.out.println("Assembly code : \n" + programme.toAssembly() + "Halt");
System.out.println("C'est bien une expression arithmétique !!");
- }catch (FileNotFoundException e) {
+ } catch (FileNotFoundException e) {
System.out.println("Le fichier spécifié n'a pas été trouvé.");
- }catch (TokenMgrError e) {
- System.out.println("Ceci n'est pas une expression arithm\u00e9tique :"+e.toString());
- }catch (ParseException e){
- System.out.println("Ceci n'est pas une expression arithm\u00e9tique :"+e);
- } }
+ } catch (TokenMgrError e) {
+ System.out.println("Ceci n'est pas une expression arithmétique : " + e.toString());
+ } catch (ParseException e) {
+ System.out.println("Ceci n'est pas une expression arithmétique : " + e);
+ }
+ }
}
PARSER_END(Compilateur)
-
TOKEN :
{
< FLOAT: (("0" | ["1"-"9"] (["0"-"9"])* )? "." (["0"-"9"])+ (("E" | "e") ("+" | "-")? (["0"-"9"])+)? ) | (["0"-"9"])+ (("E" | "e") ("+" | "-")? (["0"-"9"])+)>
| < NOMBRE: (["1"-"9"] (["0"-"9"])* | "0") (("E" | "e") ("+" | "-")? (["0"-"9"])+)?>
| < BOOLEAN: "True" | "False">
- | < EOL: ";\n" | ";" >
| < NAN: "NaN">
| < IMPORT: "import">
- | < IDENT : (["a"-"z", "A"-"Z", "0"-"9", "/"])+ >
+ | < IF: "if" >
+ | < ELSE: "else" >
+ | < DO: "do" >
+ | < WHILE: "while" >
+ | < EOL: ";\n" | ";" >
+ | < SEMICOLON: ";" >
+ | < ASSIGN: "=" >
+ | < PLUS: "+" >
+ | < MINUS: "-" >
+ | < MULTIPLY: "*" >
+ | < DIVIDE: "/" >
+ | < LPAREN: "(" >
+ | < RPAREN: ")" >
+ | < LBRACE: "{" >
+ | < RBRACE: "}" >
+ | < IDENT: (["a"-"z"])+ (["a"-"z", "A"-"Z", "0"-"9", "_"])* >
}
+
SKIP :
{ " " | "\t" | "\n" | < "//" (~["\n", "\r"])* ("\n" | "\r" | "\r\n") > | < "/*" (~["*"])* "*" (~["/", "*"] (~["*"])* "*" )* "/" >}
-
-Programme mainNT () :
-{
- Programme prg;
+Programme mainNT() : {
+ Programme programme;
+} {
+ programme=programme() <EOF> { return programme; }
}
-{
- prg=programme() <EOF> { return prg; }
-
-}
-Programme programme() :
-{
- List<Commande> programme = new ArrayList<>();
+Programme programme() : {
+ List<Commande> programme = new ArrayList<Commande>();
Commande commande;
-}
-{
+} {
(
- commande=commande() {
-
- programme.add(commande);
-
- }
- )*
- {
- return new Programme(programme);}
-
-}
-Commande commande() :
-{
- Commande expr;
- Programme prg;
+ commande=commande() { programme.add(commande); }
+ )* {
+ return new Programme(programme);
+ }
}
-{
- expr=expression() <EOL> { return expr; }
- | <IMPORT> expr=facteur() <EOL> { return new Import(expr); }
- | "{" prg=programme() "}" {return new Bloc(prg);}
+Commande commande() : {
+ Token id;
+ ExpressionA expr;
+ Commande cmd1, cmd2;
+ Programme prg;
+} {
+ LOOKAHEAD(2) id=<IDENT> "=" expr=expression() <EOL> { return new Assignment(id.image, expr); }
+ | expr=expression() <EOL> { return expr; }
+ | <IMPORT> expr=facteur() <EOL> { return new Import(expr); }
+ | <LBRACE> prg=programme() <RBRACE> { return new Bloc(prg); }
+ | <EOL> {return new EmptyCommand();}
+ | <IF> <LPAREN> expr=expression() <RPAREN> cmd1=commande() <ELSE> cmd2=commande() { return new IfElseCommand(expr, cmd1, cmd2); }
+ | <DO> cmd1=commande() <WHILE> <LPAREN> expr=expression() <RPAREN> <EOL> { return new DoWhileCommand(cmd1, expr); }
}
-
-
-ExpressionA expression() :
-{
+ExpressionA expression() : {
ExpressionA gauche, droite;
-}
-{
+} {
gauche=comp() (
- "==" droite=comp() { gauche = new Egal(gauche, droite); }
- | ">=" droite=comp() { gauche = new GrEgNb(gauche, droite); }
- | ">" droite=comp() { gauche = new GrStNb(gauche, droite);}
- | "<" droite=comp() { gauche = new LoStNb(gauche, droite);}
- | "<=" droite=comp() { gauche = new LoEqNb(gauche, droite); }
- | "!=" droite=comp() { gauche = new NotEql(gauche, droite); }
- | "&&" droite=comp() { gauche = new Et(gauche, droite); }
- )*
- { return gauche; }
-}
-
-ExpressionA comp() :
-{
+ "==" droite=comp() { gauche = new Egal(gauche, droite); }
+ | ">=" droite=comp() { gauche = new GrEgNb(gauche, droite); }
+ | ">" droite=comp() { gauche = new GrStNb(gauche, droite); }
+ | "<" droite=comp() { gauche = new LoStNb(gauche, droite); }
+ | "<=" droite=comp() { gauche = new LoEqNb(gauche, droite); }
+ | "!=" droite=comp() { gauche = new NotEql(gauche, droite); }
+ | "&&" droite=comp() { gauche = new Et(gauche, droite); }
+ )* {
+ return gauche;
+ }
+}
+
+ExpressionA comp() : {
ExpressionA gauche, droite;
-}
-{
+} {
gauche=terme() (
- "+" droite=terme() { gauche = new Plus(gauche, droite); }
+ "+" droite=terme() { gauche = new Plus(gauche, droite); }
| "-" droite=terme() { gauche = new Moins(gauche, droite); }
- )*
- { return gauche; }
+ )* {
+ return gauche;
+ }
}
-ExpressionA terme () :
-{
+
+ExpressionA terme() : {
ExpressionA gauche, droite;
-}
-{
+} {
gauche=facteur() (
"*" droite=facteur() { gauche = new Mult(gauche, droite); }
- | "/" droite=facteur() { gauche = new Div(gauche, droite);}
+ | "/" droite=facteur() { gauche = new Div(gauche, droite); }
| "%" droite=facteur() { gauche = new Modulo(gauche, droite); }
- )*
- { return gauche; }
+ )* {
+ return gauche;
+ }
}
-ExpressionA facteur() :
-{
+ExpressionA facteur() : {
ExpressionA expr;
-}
-{
- "(" expr=expression() ")" { return expr; }
- | "-" expr=facteur() { return new Neg(expr); }
- | "!" expr=facteur() { return new Not(expr); }
- | <NOMBRE> { return new Num(Integer.parseInt(token.image));}
- | <FLOAT> { return new FloatT(Float.parseFloat(token.image));}
- | <BOOLEAN> { return new Bool(Boolean.parseBoolean(token.image));}// Construit un nœud Num
- | <IDENT> { return new Ident(token.image);}// Construit un nœud Num
+} {
+ <NOMBRE> { return new Num(Integer.parseInt(token.image)); }
+ | <FLOAT> { return new FloatT(Float.parseFloat(token.image)); }
+ | <BOOLEAN> { return new Bool(Boolean.parseBoolean(token.image)); }
+ | <IDENT> { return new Ident(token.image); }
}
diff --git a/test.js b/test.js
index dcf8e1c655cf00bb97acd230fe302236803784c6..4d638576a3ca393334a409d2ce6ba8448a57659f 100644
--- a/test.js
+++ b/test.js
@@ -1,9 +1,21 @@
-import malib;
-/// True + False
-/* cgvhjbkn +1 */
-{
- 9-1;
+// to test the if else
+if (x<10){
x+1;
+}else{
+ y=10;
+}
+// to test the do while
+do {
+ y=y+1;
+}while(y<10);
+// to test the compressed sequence of commands
+
+{
+ e+1;
+ a-10;
+ 3+1;
}
-5*5;
+// to test the EmptyCommand
+;
+
\ No newline at end of file