- Fixed some specific cases where there was 2 points in the lambda term

parser.py

@@ -60,6 +60,12 @@ def findClosingParanthesesIndex(terme, openParentheseIndex):
 def getTermFromParantheses(terme,i):
     return terme[i+1:findClosingParanthesesIndex(terme,i)]
 
+def getTermsFromParantheses(terme):
+    terms = []
+    for i in (open_parantheses_counter(terme)[1]):
+        terms.append(getTermFromParantheses(terme,i))
+    return terms
+
 #fonction qui enleve les espaces successifs et laisse un seul espace
 def remove_multiple_spaces(terme):
     new_term=''
@@ -74,10 +80,14 @@ def remove_multiple_spaces(terme):
     return new_term
 
 def checkType(terme):
-    if  terme[0] == '(':
-        return checkType(getTermFromParantheses(terme,0))
-    elif "#" == terme[0]:
+    if "#" == terme[0]:
         return ABS
+    elif  terme[0] == '(':
+        l = getTermsFromParantheses(terme)
+        if len(l) == 1:
+            return checkType(getTermFromParantheses(terme,0))
+        else:
+            return APP
     elif not(any(charac in (terme) for charac in ['(',')',' ','#','.'])):
         return VAR
     else:
@@ -104,13 +114,13 @@ def parseInputFromAbs(terme):
     return input
 # on prend l output en chaine de caractères
 def parseOutputFromAbs(terme):
-    output = ''
+    index_of_point = terme.find('.')
     if checkType(terme) == ABS:
-        output += (terme.split("."))[1]
-    return output
+        return terme[index_of_point+1:]
 
 def buildVar(terme):
     assert (checkType(terme) == VAR)
+    # print(terme)
     if terme[0]!='(':
         return new_var(terme)
     else :
@@ -120,6 +130,7 @@ def buildAbs(terme):
     assert (checkType(terme) == ABS)
     input = parseInputFromAbs(terme)
     output = parseOutputFromAbs(terme)
+    # print(terme,"INPUT:", input,'OUTPUT:', output)
     if terme [0]!= '(':
         return new_abs((buildTerm(input)),buildTerm(output))
     else:
@@ -129,10 +140,11 @@ def buildApp(terme):
     assert (checkType(terme) == APP)
     if terme[0]!='(':
         liste_de_termes = terme.split(' ')
-        print(liste_de_termes)
+        # print(terme)
+        # print(liste_de_termes)
         n = len(liste_de_termes)
         if n == 0:
-            raise Exception('Empty List of Terms')
+            return None
         else:
             t = buildTerm(liste_de_termes[0])
         for k in range(1, n):
@@ -141,27 +153,23 @@ def buildApp(terme):
             t = new_app(t, buildTerm(liste_de_termes[k]))
         return t
     else:
-        return buildTerm(getTermFromParantheses(terme,0))
+        liste_de_termes = getTermsFromParantheses(terme)
+        t = buildTerm(liste_de_termes[0])
+        for k in range(1, len(liste_de_termes)):
+            if liste_de_termes[k] == '':
+                return t
+            t = new_app(t, buildTerm(liste_de_termes[k]))
+        return t
     
 def buildTerm(terme):
     if isVariable(terme): return buildVar(terme)
     elif isAbstraction(terme): return buildAbs(terme)
     elif isApplication(terme): return buildApp(terme)
 
-# print(getTermsFromParantheses("(AAAAAA)(BBBBBBBBB)(CCCCCCCCC)"))
-# print(buildTerm(A))
-# print(remove_first_and_last_spaces('ll'))
-# print(isAbstraction(A))
-# print(isApplication("(x)(y)(z)"))
-# print(checkType("(#x.x)"))
-# print(buildTerm('(#x.x)(#y.y)'))
-# print(remove_inutile_parentheses('(#x.x)(#y.y)'))
-# print(open_parantheses_counter('((((((((((('))
-# print(close_parantheses_counter('((((((((((()'))
-# print(buildAbs("#x.ABC"))
-# print(checkType("(#x.xx)(fds)"))
-# print(findClosingParanthesesIndex('()',0))
-#print(remove_multiple_spaces("x       y    z (#x.z   g)"))
-#print(buildTerm("x "))
-print(balancedParantheses('x '))
-print(buildTerm("(((((x    )))))"))
+def parse(terme):
+    return (buildTerm(remove_multiple_spaces(terme)))
+
+# print(checkType('(#x.x) (#y.y)'))
+# print(parse('(#x.x) (#y.y) (#z.z)'))
+
+print(parse(input('ENTRER UN TERME: ')))
\ No newline at end of file