ajout du rapport TP1 et TP2

Pystan/config/constant_propagation.py

@@ -82,26 +82,77 @@ def eval_bexp(env: abstract_env, e: BoolExpr) -> abstract_value[bool] | None:
 
 class Constant_propagation(Transfer[state]):
     variables: frozenset[str]
-    def __init__(self,instr):
+
+    def __init__(self, instr):
         self.variables = variables_of_instr(instr)
+
     def bottom(self) -> state:
-        ...
+        return None
+
     def init_state(self) -> state:
-        ...
-    def join(self,s1:state,s2:state) -> state:
-        ...
+        return {v: abstract_value(None) for v in self.variables}
+
+    def join(self, s1: state, s2: state) -> state:
+        if s1 is None:
+            return s2
+        if s2 is None:
+            return s1
+        result = {}
+        for var in self.variables:
+            v1 = s1.get(var, abstract_value(None))
+            v2 = s2.get(var, abstract_value(None))
+            if v1.value == v2.value:
+                result[var] = v1
+            else:
+                result[var] = abstract_value(None)
+        return result
 
-    def included(self,s1: state,s2: state) -> bool:
-        ...
+    def included(self, s1: state, s2: state) -> bool:
+        if s1 is None:
+            return True  
+        if s2 is None:
+            return False
+        for var in self.variables:
+            v1 = s1.get(var, abstract_value(None))
+            v2 = s2.get(var, abstract_value(None))
+            if v1.value != v2.value and v2.value is not None:
+                return False
+        return True
 
-    def tr_skip(self,s: state) -> state:
-        ...
+    def tr_skip(self, s: state) -> state:
+        return s
 
-    def tr_set(self,s: state,v: str,e: ArithExpr) -> state:
-        ...
+    def tr_set(self, s: state, v: str, e: ArithExpr) -> state:
+        if s is None:
+            return None
+        new_env = s.copy()
+        result = eval_aexp(s, e)
+        if result is None:
+            return None
+        new_env[v] = result
+        return new_env
 
-    def tr_test(self,s: state,c: BoolExpr) -> state:
-        ...
+    def tr_test(self, s: state, c: BoolExpr) -> state:
+        if s is None:
+            return None
+        result = eval_bexp(s, c)
+        if result is None:
+            return None
+        if result.value is False:
+            return None  
+        elif result.value is True:
+            return s     
+        else:
+            match c:
+                case BEEq(AEVar(x), AECst(cst)) if x in s:
+                    env = s.copy()
+                    env[x] = abstract_value(cst)
+                    return env
+                case BEEq(AECst(cst), AEVar(x)) if x in s:
+                    env = s.copy()
+                    env[x] = abstract_value(cst)
+                    return env
+            return s  
 
-    def tr_err(self,s: state,e: Expr) -> state:
-        ...
+    def tr_err(self, s: state, e: Expr) -> state:
+        return None  
\ No newline at end of file

Pystan/config/iteration.py

@@ -43,4 +43,35 @@ def fixpoint_iteration[T](transfer: Transfer[T], cfg: Cfg) -> dict[Node,T]:
  
    output maps each node to the computed state
     """
-    raise NotImplementedError
+    states: dict[Node, T] = {node: transfer.bottom() for node in cfg.g.nodes}
+    states[cfg.init_node] = transfer.init_state()
+    worklist: list[tuple[Node, Node, Label]] = []
+    
+    for dest, label in cfg.init_node.succs:
+        worklist.append((cfg.init_node, dest, label))
+        
+    while worklist:
+        src, dst, label = worklist.pop(0)
+        s_src = states[src]
+        if isinstance(label, LSkip):
+            s_new = transfer.tr_skip(s_src)
+        elif isinstance(label, LSet):
+            s_new = transfer.tr_set(s_src, label.var, label.expr)
+        elif isinstance(label, LTest):
+            s_new = transfer.tr_test(s_src, label.cond)
+        elif isinstance(label, LErr):
+            s_new = transfer.tr_err(s_src, label.err)
+        else:
+            raise ValueError(f"Étiquette inconnue: {label}")
+
+        s_dst_old = states[dst]
+        
+        if not transfer.included(s_new, s_dst_old):
+            states[dst] = transfer.join(s_dst_old, s_new)
+
+            for dest2, label2 in dst.succs:
+                worklist.append((dst, dest2, label2))
+
+    return states
+
+"""Les noeuds non atteignables sont les noeuds que le code ne peut jamais visité ici ils sont les cas ou les tests ne sont pas vérifés ce qui est impossible à visiter parce que les tests ont la condition 1"""
\ No newline at end of file

Pystan/config/opsem.py

@@ -9,42 +9,66 @@ These functions return None when an error occur somewhere (Big step semantics)
 from syntax import *
 
 def eval_aexp(env: dict[str,int], exp: ArithExpr) -> int | None:
-    """evaluates an arithmetic expression"""
+    """evaluates an arithmetic expression safely"""
     match exp:
         case AECst(value):
-            raise NotImplementedError
+            return value
         case AEVar(var):
-            raise NotImplementedError
-        case AEUop(uop,expr):
-            raise NotImplementedError
-        case AEBop(bop,left_expr,right_expr):
-            raise NotImplementedError
-        case _: assert False
+            return env.get(var, None)
+        case AEUop(uop, expr):
+            val = eval_aexp(env, expr)
+            if val is None:
+                return None
+            if uop == Uop.OPP:
+                return -val
+            return None
+        case AEBop(bop, left_expr, right_expr):
+            v1 = eval_aexp(env, left_expr)
+            v2 = eval_aexp(env, right_expr)
+            if v1 is None or v2 is None:
+                return None
+            if bop == Bop.ADD:
+                return v1 + v2
+            elif bop == Bop.MUL:
+                return v1 * v2
+            elif bop == Bop.DIV:
+                if v2 == 0:
+                    return None
+                return v1 // v2
+        case _:
+            return None
 
 def eval_bexp(env: dict[str,int], exp:BoolExpr) -> bool | None:
     """evaluates a boolean expression"""
     match exp:
         case BEPlain(aexpr):
-            raise NotImplementedError
+            return eval_aexp(env,aexpr) != 0
         case BEEq(left_expr,right_expr):
-            raise NotImplementedError
+            return eval_aexp(env,left_expr) == eval_aexp(env,right_expr)
         case BELeq(left_expr,right_expr):
-            raise NotImplementedError
+            return eval_aexp(env,left_expr) <= eval_aexp(env,right_expr)
         case BENeg(expr):
-            raise NotImplementedError
+            return not eval_bexp(env,expr)
         case _: assert False
 
 def eval_instr(env: dict[str,int], instr: Instr) -> dict[str,int] | None:
     """evaluates an instruction"""
     match instr:
         case ISkip():
-            raise NotImplementedError
+            return env
         case ISet(var,expr):
-            raise NotImplementedError
+            new_env = env.copy()
+            new_env[var] = eval_aexp(new_env,expr)
+            return new_env
         case ISeq(first,second):
-            raise NotImplementedError
+            return eval_instr(eval_instr(env,first),second)
         case ICond(cond,true_branch,false_branch):
-            raise NotImplementedError
+            if eval_bexp(env,cond):
+                return eval_instr(env,true_branch)
+            else:
+                return eval_instr(env,false_branch)
         case ILoop(cond,body):
-            raise NotImplementedError
+            while eval_bexp(env,cond):
+                env = eval_instr(env,body)
+            return env
         case _: assert False

Pystan/config/syntax.py

@@ -67,7 +67,14 @@ class AEBop(ArithExpr):
     right_expr: ArithExpr
     def __str__(self):
         #TODO: only put parentheses if necessary
-        return f"({self.left_expr}) {self.bop} ({self.right_expr})"
+        if isinstance(self.left_expr, AEBop) and isinstance(self.right_expr, AEBop):
+            return f"({self.left_expr}) {self.bop} ({self.right_expr})"
+        if isinstance(self.left_expr, AEBop):
+            return f"({self.left_expr}) {self.bop} {self.right_expr}"
+        if isinstance(self.right_expr, AEBop):
+            return f"{self.left_expr} {self.bop} ({self.right})"
+        else:
+            return f"{self.left_expr} {self.bop} {self.right_expr}"
 
 @dataclass
 class BoolExpr(Expr):