let rec _Traitement_expr expr variable type_ass _CONST =
  let ajout = 
    if type_ass = "next" 
    then
      "EX."
    else
      ""
  in
  match expr with
    Binaire (exprL, binOp, exprR) -> 
      let gauche = (_Traitement_expr exprL variable type_ass _CONST) in
      let droite = (_Traitement_expr exprR variable type_ass _CONST) in   
      (match binOp with 
        Declaration.AND -> "("^gauche^" && "^droite^")"
      | Declaration.OR -> "("^gauche^" || "^droite^")"
      | Declaration.EQDEF -> raise Cas_impossible
      | Declaration.PLUS -> "("^gauche^" + "^droite^")"
      | Declaration.MINUS ->"("^gauche^" - "^droite^")"
      | Declaration.DIVIDE -> "("^gauche^" / "^droite^")"
      | Declaration.TIMES -> "("^gauche^" * "^droite^")"
      | Declaration.EQUAL -> "("^gauche^" == "^droite^")"
      | Declaration.NOTEQUAL -> "("^gauche^" != "^droite^")"
      | Declaration.LE ->  "("^gauche^" <= "^droite^")"
      | Declaration.GE ->  "("^gauche^" >= "^droite^")"
      | Declaration.LT ->  "("^gauche^" < "^droite^")"
      | Declaration.GT ->  "("^gauche^" > "^droite^")"
      | Declaration.MOD -> "("^gauche^" % "^droite^")")
  | Varia (id, sonT) ->
      (match sonT with
        Enum([Chaine(s)]) -> 
          if s = "" 
          then 
            id 
          else 
            "\""^id^"\""
      | Defini(sonExpr) -> 
          "("^(_Traitement_expr sonExpr variable type_ass _CONST)^")" 
      | _ ->
          (try
            (String.sub 
               id 
               0 
               ((String.rindex id '.')+1))
            ^ajout
            ^(String.sub 
                id 
                ((String.rindex id '.')+1) 
                ((String.length id) - (String.rindex id '.') - 1))
          with _ ->
            ajout^id))
  | Construct(_) -> 
      raise Cas_impossible
  | Unaire (unOp, exprR) -> 
      let droite = (_Traitement_expr exprR variable type_ass _CONST) in
      (match unOp with
        Declaration.NOT -> "!("^droite^")")
  | Case([]) -> ""
  | Case ((condition, exprR)::liste_case) -> 
      let reste = (_Traitement_expr (Case(liste_case)) variable type_ass _CONST) in
      let gauche = (_Traitement_expr condition variable type_ass _CONST) in
      let droite = (_Traitement_expr exprR variable type_ass _CONST) in
      (match exprR with
        Case([(Num 1), _]) -> 
          droite
      | Case(_) -> "\t\tif ("^gauche^") \n\t\t{\n\t\t\t"
          ^droite
          ^";\n\t\t}\n\t\telse\n\t\t{\n"
          ^reste
          ^"\n\t\t}\n"
      |-> "\t\tif ("^gauche^") { \n\t\t\t"
          ^variable^" = "^droite
          ^";\n\t\t}\n\t\telse\n\t\t{\n"
          ^reste^"\n\t\t}\n")
  | Num (i) -> 
      if i = 0 
      then
        "false"
      else
        "true"
  | Chaine(s) -> "\""^s^"\""
  | NotDet(arguments) -> 
      if not (type_ass = "constr")
      then 
        "\t\tVector ¤vector"
        ^(Nativeint.to_string (Nativeint.of_int _CONST))
        ^" = new Vector();\n"
        ^(_Traitement_NotDet arguments variable ("¤vector"
                                                 ^(Nativeint.to_string (Nativeint.of_int _CONST))))
      else
        raise Cas_impossible
  | Ensemble(_) -> raise Cas_impossible