Update app.py

app.py

@@ -1,15 +1,8 @@
 import streamlit as st
+import copy
 
-# Initial setup for grammar input
-rules = []
-nonterm_userdef = []
-term_userdef = []
-diction = {}
-firsts = {}
-follows = {}
-start_symbol = None
+# Helper functions
 
-# Function to remove left recursion
 def removeLeftRecursion(rulesDiction):
     store = {}
     for lhs in rulesDiction:
@@ -23,7 +16,7 @@ def removeLeftRecursion(rulesDiction):
                 betaRules.append(subrhs)
         if len(alphaRules) != 0:
             lhs_ = lhs + "'"
-            while lhs_ in rulesDiction.keys() or lhs_ in store.keys():
+            while (lhs_ in rulesDiction.keys()) or (lhs_ in store.keys()):
                 lhs_ += "'"
             for b in range(len(betaRules)):
                 betaRules[b].append(lhs_)
@@ -36,24 +29,22 @@ def removeLeftRecursion(rulesDiction):
         rulesDiction[left] = store[left]
     return rulesDiction
 
-# Function to perform left factoring
 def LeftFactoring(rulesDiction):
     newDict = {}
     for lhs in rulesDiction:
         allrhs = rulesDiction[lhs]
-        temp = dict()
+        temp = {}
         for subrhs in allrhs:
-            if subrhs[0] not in list(temp.keys()):
+            if subrhs[0] not in temp:
                 temp[subrhs[0]] = [subrhs]
             else:
                 temp[subrhs[0]].append(subrhs)
         new_rule = []
         tempo_dict = {}
         for term_key in temp:
-            allStartingWithTermKey = temp[term_key]
-            if len(allStartingWithTermKey) > 1:
+            if len(temp[term_key]) > 1:
                 lhs_ = lhs + "'"
-                while lhs_ in rulesDiction.keys() or lhs_ in tempo_dict.keys():
+                while (lhs_ in rulesDiction.keys()) or (lhs_ in tempo_dict.keys()):
                     lhs_ += "'"
                 new_rule.append([term_key, lhs_])
                 ex_rules = []
@@ -61,44 +52,44 @@ def LeftFactoring(rulesDiction):
                     ex_rules.append(g[1:])
                 tempo_dict[lhs_] = ex_rules
             else:
-                new_rule.append(allStartingWithTermKey[0])
+                new_rule.append(temp[term_key][0])
         newDict[lhs] = new_rule
         for key in tempo_dict:
             newDict[key] = tempo_dict[key]
     return newDict
 
-# Function to calculate FIRST set
 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] == '#':
-        return '#'
+    if len(rule) != 0:
+        if rule[0] in term_userdef:
+            return rule[0]
+        elif rule[0] == '#':
+            return '#'
     if len(rule) != 0 and rule[0] in diction:
         fres = []
         rhs_rules = diction[rule[0]]
         for itr in rhs_rules:
             indivRes = first(itr, diction, term_userdef)
-            if isinstance(indivRes, list):
+            if type(indivRes) is list:
                 fres.extend(indivRes)
             else:
                 fres.append(indivRes)
         if '#' not in fres:
             return fres
         else:
-            newList = fres
             fres.remove('#')
             if len(rule) > 1:
                 ansNew = first(rule[1:], diction, term_userdef)
                 if ansNew is not None:
-                    if isinstance(ansNew, list):
-                        newList = fres + ansNew
+                    if type(ansNew) is list:
+                        fres.extend(ansNew)
                     else:
-                        newList = fres + [ansNew]
+                        fres.append(ansNew)
+                return fres
             fres.append('#')
             return fres
+    return []
 
-# Function to calculate FOLLOW set
-def follow(nt, diction, start_symbol):
+def follow(nt, start_symbol, diction, firsts, follows):
     solset = set()
     if nt == start_symbol:
         solset.add('$')
@@ -111,120 +102,82 @@ def follow(nt, diction, start_symbol):
                     subrule = subrule[index_nt + 1:]
                     if len(subrule) != 0:
                         res = first(subrule, diction, term_userdef)
-                        if res is not None:
-                            if '#' in res:
-                                res.remove('#')
-                                follow_res = follow(curNT, diction, start_symbol)
-                                if follow_res:
-                                    res += follow_res
-                        else:
-                            res = []
+                        if '#' in res:
+                            newList = []
+                            res.remove('#')
+                            ansNew = follow(curNT, start_symbol, diction, firsts, follows)
+                            if ansNew:
+                                newList.extend(ansNew)
+                            res.extend(newList)
                     else:
                         if nt != curNT:
-                            res = follow(curNT, diction, start_symbol)
-                            if res is None:
-                                res = []
-                    solset.update(res if isinstance(res, list) else [res])
+                            res = follow(curNT, start_symbol, diction, firsts, follows)
+                    if res is not None:
+                        solset.update(res)
     return list(solset)
 
-# Compute FIRST for all non-terminals
-def computeAllFirsts(diction, term_userdef):
-    firsts = {}
-    for y in diction.keys():
-        firsts[y] = set()
-        for sub in diction[y]:
-            result = first(sub, diction, term_userdef)
-            if result is not None:
-                firsts[y].update(result if isinstance(result, list) else [result])
-    return firsts
-
-# Compute FOLLOW for all non-terminals
-def computeAllFollows(diction, start_symbol):
-    follows = {}
-    for NT in diction.keys():
-        follows[NT] = set(follow(NT, diction, start_symbol))
-    return follows
-
-# Parse table creation function
-def createParseTable(diction, term_userdef, firsts, follows):
-    table = {}
-    grammar_is_LL = True
-    for lhs in diction.keys():
-        table[lhs] = {}
-        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, diction, term_userdef)
-            if '#' in first_res:  # Epsilon handling
-                first_res.remove('#')
-                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
-                    st.error(f"Conflict detected in parse table at [{lhs}, {term}]")
-
-    return table, grammar_is_LL
-
-# Streamlit Interface
-st.title("LL(1) Grammar Analyzer")
-
-st.subheader("Grammar Rules Input")
-start_symbol = st.text_input("Enter Start Symbol (Non-terminal)")
-num_rules = st.number_input("Number of Grammar Rules", min_value=1, step=1)
-rules = []
-for i in range(num_rules):
-    rule = st.text_input(f"Rule {i+1}")
-    if rule:
-        rules.append(rule)
-
-nonterm_userdef = st.text_input("Enter Non-Terminals (comma-separated)").split(',')
-term_userdef = st.text_input("Enter Terminals (comma-separated)").split(',')
-
-if st.button("Analyze Grammar"):
-    diction.clear()
-    firsts.clear()
-    follows.clear()
-
-    for rule in rules:
-        lhs, rhs = rule.split("->")
-        lhs = lhs.strip()
-        rhs_list = [x.strip().split() for x in rhs.split("|")]
-        diction[lhs] = rhs_list
-
-    st.subheader("Grammar After Removing Left Recursion")
-    diction = removeLeftRecursion(diction)
-    st.write(diction)
-
-    st.subheader("Grammar After Left Factoring")
-    diction = LeftFactoring(diction)
-    st.write(diction)
-
-    firsts = computeAllFirsts(diction, term_userdef)
-    st.subheader("FIRST Sets")
-    st.write(firsts)
-
-    follows = computeAllFollows(diction, start_symbol)
-    st.subheader("FOLLOW Sets")
-    st.write(follows)
-
-    parse_table, grammar_is_LL = createParseTable(diction, term_userdef, firsts, follows)
-    st.subheader("Parse Table")
-    st.write(parse_table)
-
-    if grammar_is_LL:
-        st.success("The grammar is LL(1)")
-    else:
-        st.error("The grammar is not LL(1)")
-
-    input_string = st.text_input("Enter String to Validate (space-separated)")
-    if input_string:
-        result = validateStringUsingStackBuffer(parse_table, input_string)
-        st.subheader("Validation Result")
-        st.write(result)
+# Main Streamlit App Code
+
+def main():
+    # Streamlit UI Elements
+    st.title("LL(1) Grammar Analyzer")
+
+    # Input for Grammar
+    st.subheader("Enter Grammar Rules")
+    grammar_input = st.text_area("Grammar (one rule per line, format: LHS -> RHS)")
+
+    # Parse Grammar
+    if grammar_input:
+        rules = grammar_input.split("\n")
+        diction = {}
+        for rule in rules:
+            k = rule.split("->")
+            k[0] = k[0].strip()
+            rhs = k[1].strip()
+            multirhs = rhs.split('|')
+            for i in range(len(multirhs)):
+                multirhs[i] = multirhs[i].split()
+            diction[k[0]] = multirhs
+
+        # Process Grammar (Eliminate Left Recursion and Apply Left Factoring)
+        diction = removeLeftRecursion(diction)
+        diction = LeftFactoring(diction)
+
+        st.write("Processed Grammar After Left Recursion and Left Factoring:")
+        for y in diction:
+            st.write(f"{y} -> {diction[y]}")
+
+        # Compute First and Follow sets
+        firsts = {}
+        follows = {}
+        start_symbol = list(diction.keys())[0]
+        
+        for y in list(diction.keys()):
+            firsts[y] = set(first(rule, diction, ["a", "b"]))  # Adjust terminal symbols as needed
+            follows[y] = follow(y, start_symbol, diction, firsts, follows)
+
+        st.subheader("First Sets")
+        for nonterminal, first_set in firsts.items():
+            st.write(f"First({nonterminal}) -> {first_set}")
+
+        st.subheader("Follow Sets")
+        for nonterminal, follow_set in follows.items():
+            st.write(f"Follow({nonterminal}) -> {follow_set}")
+
+        # Example for parsing table
+        st.subheader("Parse Table:")
+        parse_table, grammar_is_LL, terminals = createParseTable(diction, firsts, follows)
+
+        if grammar_is_LL:
+            st.write("Grammar is LL(1)")
+        else:
+            st.write("Grammar is not LL(1)")
+
+        # Display parsing table
+        st.write("Parse Table:")
+        for row in parse_table:
+            st.write(row)
+
+# Run the app
+if __name__ == '__main__':
+    main()