Update app.py

app.py

@@ -68,7 +68,7 @@ def LeftFactoring(rulesDiction):
     return newDict
 
 # Function to calculate FIRST set
-def first(rule):
+def first(rule, diction, term_userdef):
     if len(rule) != 0 and rule[0] in term_userdef:
         return rule[0]
     elif len(rule) != 0 and rule[0] == '#':
@@ -77,8 +77,8 @@ def first(rule):
         fres = []
         rhs_rules = diction[rule[0]]
         for itr in rhs_rules:
-            indivRes = first(itr)
-            if type(indivRes) is list:
+            indivRes = first(itr, diction, term_userdef)
+            if isinstance(indivRes, list):
                 fres.extend(indivRes)
             else:
                 fres.append(indivRes)
@@ -88,9 +88,9 @@ def first(rule):
             newList = fres
             fres.remove('#')
             if len(rule) > 1:
-                ansNew = first(rule[1:])
+                ansNew = first(rule[1:], diction, term_userdef)
                 if ansNew is not None:
-                    if type(ansNew) is list:
+                    if isinstance(ansNew, list):
                         newList = fres + ansNew
                     else:
                         newList = fres + [ansNew]
@@ -98,7 +98,7 @@ def first(rule):
             return fres
 
 # Function to calculate FOLLOW set
-def follow(nt):
+def follow(nt, diction, start_symbol):
     solset = set()
     if nt == start_symbol:
         solset.add('$')
@@ -110,82 +110,67 @@ def follow(nt):
                     index_nt = subrule.index(nt)
                     subrule = subrule[index_nt + 1:]
                     if len(subrule) != 0:
-                        res = first(subrule)
+                        res = first(subrule, diction, term_userdef)
                         if res is not None:
                             if '#' in res:
                                 res.remove('#')
-                                follow_res = follow(curNT)
+                                follow_res = follow(curNT, diction, start_symbol)
                                 if follow_res:
                                     res += follow_res
                         else:
                             res = []
                     else:
                         if nt != curNT:
-                            res = follow(curNT)
+                            res = follow(curNT, diction, start_symbol)
                             if res is None:
                                 res = []
-                    solset.update(res if type(res) is list else [res])
+                    solset.update(res if isinstance(res, list) else [res])
     return list(solset)
 
 # Compute FIRST for all non-terminals
-def computeAllFirsts():
-    global firsts
+def computeAllFirsts(diction, term_userdef):
+    firsts = {}
     for y in diction.keys():
         firsts[y] = set()
         for sub in diction[y]:
-            result = first(sub)
+            result = first(sub, diction, term_userdef)
             if result is not None:
-                firsts[y].update(result if type(result) is list else [result])
+                firsts[y].update(result if isinstance(result, list) else [result])
+    return firsts
 
 # Compute FOLLOW for all non-terminals
-def computeAllFollows():
-    global follows
+def computeAllFollows(diction, start_symbol):
+    follows = {}
     for NT in diction.keys():
-        follows[NT] = set(follow(NT))
+        follows[NT] = set(follow(NT, diction, start_symbol))
+    return follows
 
 # Parse table creation function
-def createParseTable():
-    global term_userdef, firsts, follows
+def createParseTable(diction, term_userdef, firsts, follows):
     table = {}
     grammar_is_LL = True
     for lhs in diction.keys():
         table[lhs] = {}
-        for term in term_userdef + ['$']:
-            table[lhs][term] = ""
+        for term in term_userdef + ['$']:  # Include end of input symbol
+            table[lhs][term] = ""  # Set default empty entries
+
+    # Populate the parse table
     for lhs in diction:
         for rule in diction[lhs]:
-            first_res = first(rule)
-            if '#' in first_res:
+            first_res = first(rule, diction, term_userdef)
+            if '#' in first_res:  # Epsilon handling
                 first_res.remove('#')
-                follow_res = follows[lhs]
+                follow_res = follows.get(lhs, [])
                 first_res.update(follow_res)
+
             for term in first_res:
                 if table[lhs][term] == "":
                     table[lhs][term] = f"{lhs} -> {' '.join(rule)}"
                 else:
                     grammar_is_LL = False
-    return table, grammar_is_LL
+                    st.error(f"Conflict detected in parse table at [{lhs}, {term}]")
 
-# Validate input string function
-def validateStringUsingStackBuffer(parse_table, input_string):
-    stack = [start_symbol, '$']
-    buffer = ['$'] + input_string.split()[::-1]
-    while stack:
-        top_stack = stack.pop(0)
-        top_buffer = buffer.pop()
-        if top_stack in term_userdef:
-            if top_stack != top_buffer:
-                return "Invalid String"
-        elif top_stack == top_buffer:
-            continue
-        else:
-            rule = parse_table.get(top_stack, {}).get(top_buffer, None)
-            if rule:
-                rule_rhs = rule.split('->')[1].strip().split()
-                stack = rule_rhs + stack
-            else:
-                return "Invalid String"
-    return "Valid String"
+    return table, grammar_is_LL
 
 # Streamlit Interface
 st.title("LL(1) Grammar Analyzer")
@@ -221,15 +206,15 @@ if st.button("Analyze Grammar"):
     diction = LeftFactoring(diction)
     st.write(diction)
 
-    computeAllFirsts()
+    firsts = computeAllFirsts(diction, term_userdef)
     st.subheader("FIRST Sets")
     st.write(firsts)
 
-    computeAllFollows()
+    follows = computeAllFollows(diction, start_symbol)
     st.subheader("FOLLOW Sets")
     st.write(follows)
 
-    parse_table, grammar_is_LL = createParseTable()
+    parse_table, grammar_is_LL = createParseTable(diction, term_userdef, firsts, follows)
     st.subheader("Parse Table")
     st.write(parse_table)