From 31e8ebb553a0744bade8a8d91e17dcc0659ff424 Mon Sep 17 00:00:00 2001
From: Lafrite <lafrite@poneyworld.net>
Date: Sat, 2 Nov 2013 16:36:08 +0100
Subject: [PATCH] works but still empty yield

---
 expression.py | 56 +++++++++++++++++++++++++--------------------------
 1 file changed, 28 insertions(+), 28 deletions(-)

diff --git a/expression.py b/expression.py
index 214b344..079d626 100644
--- a/expression.py
+++ b/expression.py
@@ -4,18 +4,6 @@
 from generic import Stack, flatten_list, expand_list
 from fraction import Fraction
 
-def trace(f):
-    """ Permet de visualiser des appels récursifs à la fonction décorée """
-    f.indent = 0
-    def g(x):
-        print('|  ' * f.indent + '|--', f.__name__, x)
-        f.indent += 1
-        value = f(x)
-        print( '|  ' * f.indent + '|--', 'return', repr(value))
-        f.indent -= 1
-        return value
-    return g
-
 class Expression(object):
     """A calculus expression. Today it can andle only expression with numbers later it will be able to manipulate unknown"""
 
@@ -42,16 +30,18 @@ class Expression(object):
         @param render: function which render the list of token (postfix form now)
         """
         if not self.can_go_further():
-            yield render(self.postfix_tokens) # self.postfix_tokens devra être une propriété pour vérifier que quand on y accède, on a bien la forme voulu et si non, la calculer.
+            yield render(self.postfix_tokens) 
         else:
-            self.compute_exp() # crée self.children et éventuellement les étapes intermédiaires pour y arriver. /!\ les étapes sont sous la forme de listes de tokens en postfix
+            self.compute_exp() 
             for s in self.steps:
+                print(repr(self) + " steps")
                 yield render(s)
-            for s in self.children.simplify(render = render):
+            for s in self.child.simplify(render = render):
+                print(repr(self) + " child")
                 yield render(s)
 
     def can_go_further(self):
-        """Check whether it's a last step or not. If not create self.children the next expression.
+        """Check whether it's a last step or not. If not create self.child the next expression.
         :returns: 1 if it's not the last step, 0 otherwise
         """
         if len(self.tokens) == 1:
@@ -60,7 +50,7 @@ class Expression(object):
             return 1
 
     def compute_exp(self):
-        """ Create self.children with self.steps to go up to it """
+        """ Create self.child with self.steps to go up to it """
         self.steps = [self.postfix_tokens]
 
         tokenList = self.postfix_tokens.copy()
@@ -68,14 +58,14 @@ class Expression(object):
 
         while len(tokenList) > 2: 
             # on va chercher les motifs du genre A B + pour les calculer
-            if isNumber(tokenList[0]) and isNumber(tokenList[1]) and self.isOperator(tokenList[2]):
+            if self.isNumber(tokenList[0]) and self.isNumber(tokenList[1]) and self.isOperator(tokenList[2]):
                 
                 # S'il y a une opération à faire
                 op1 = tokenList[0]
                 op2 = tokenList[1]
                 token = tokenList[2]
 
-                res = doMath(token, op1, op2)
+                res = self.doMath(token, op1, op2)
 
                 tmpTokenList.append(res)
 
@@ -87,11 +77,10 @@ class Expression(object):
                 del tokenList[0]
         tmpTokenList += tokenList
 
-        steps += expand_list(tmpTokenList)
+        steps = expand_list(tmpTokenList)
 
         self.steps += [steps[:-1]]
-        self.children = Expression(steps[-1])
-
+        self.child = Expression(steps[-1])
 
     ## ---------------------
     ## String parsing
@@ -104,7 +93,15 @@ class Expression(object):
         :returns: list of token
 
         """
-        return exp.split(" ")
+        tokens = exp.split(" ")
+
+        for (i,t) in enumerate(tokens):
+            try:
+                tokens[i] = int(t)
+            except ValueError:
+                pass
+
+        return tokens
 
     # ---------------------
     # "fix" recognition
@@ -130,7 +127,10 @@ class Expression(object):
 
     def find_fix(self):
         """ Recognize the fix of self.tokens and stock tokens in self.[fix]_tokens """
-        fix = self.get_fix(self.tokens)
+        if len(self.tokens) > 1:
+            fix = self.get_fix(self.tokens)
+        else:
+            fix = "postfix" # Completement arbitraire mais on s'en fiche!
 
         setattr(self, fix+"_tokens", self.tokens)
 
@@ -147,7 +147,7 @@ class Expression(object):
             return self._infix_tokens
 
         elif hasattr(self, "_postfix_tokens"):
-            self.infix_tokens = self.post2in_fix()
+            self.post2in_fix()
             return self._infix_tokens
 
         else:
@@ -167,7 +167,7 @@ class Expression(object):
             return self._postfix_tokens
 
         elif hasattr(self,"_infix_tokens"):
-            self.postfix_tokens = self.in2post_fix()
+            self.in2post_fix()
             return self._postfix_tokens
 
         else:
@@ -241,9 +241,9 @@ class Expression(object):
         :returns: bollean
         """
 
-        if isNumber(operande) and operande < 0:
+        if self.isNumber(operande) and operande < 0:
             return 1
-        elif not isNumber(operande):
+        elif not self.isNumber(operande):
             # Si c'est une grande expression ou un chiffre négatif
             stand_alone = self.get_main_op(operande)
             # Si la priorité de l'operande est plus faible que celle de l'opérateur