Update app.py

app.py

@@ -1,8 +1,8 @@
 import streamlit as st
-import copy
-
-# Helper functions
+import numpy as np
+import pandas as pd
 
+# Function to remove left recursion
 def removeLeftRecursion(rulesDiction):
     store = {}
     for lhs in rulesDiction:
@@ -29,20 +29,22 @@ def removeLeftRecursion(rulesDiction):
         rulesDiction[left] = store[left]
     return rulesDiction
 
+# Function for Left Factoring
 def LeftFactoring(rulesDiction):
     newDict = {}
     for lhs in rulesDiction:
         allrhs = rulesDiction[lhs]
-        temp = {}
+        temp = dict()
         for subrhs in allrhs:
-            if subrhs[0] not in temp:
+            if subrhs[0] not in temp.keys():
                 temp[subrhs[0]] = [subrhs]
             else:
                 temp[subrhs[0]].append(subrhs)
         new_rule = []
         tempo_dict = {}
         for term_key in temp:
-            if len(temp[term_key]) > 1:
+            allStartingWithTermKey = temp[term_key]
+            if len(allStartingWithTermKey) > 1:
                 lhs_ = lhs + "'"
                 while (lhs_ in rulesDiction.keys()) or (lhs_ in tempo_dict.keys()):
                     lhs_ += "'"
@@ -52,132 +54,154 @@ def LeftFactoring(rulesDiction):
                     ex_rules.append(g[1:])
                 tempo_dict[lhs_] = ex_rules
             else:
-                new_rule.append(temp[term_key][0])
+                new_rule.append(allStartingWithTermKey[0])
         newDict[lhs] = new_rule
         for key in tempo_dict:
             newDict[key] = tempo_dict[key]
     return newDict
 
-def first(rule, diction, term_userdef):
-    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 type(indivRes) is list:
-                fres.extend(indivRes)
+# Function to compute the FIRST set
+def first(symbol, grammar, first_sets):
+    if symbol in first_sets:
+        return first_sets[symbol]
+    first_set = set()
+    if symbol not in grammar:
+        first_set.add(symbol)
+    else:
+        for rule in grammar[symbol]:
+            if rule == ['#']:
+                first_set.add('#')
             else:
-                fres.append(indivRes)
-        if '#' not in fres:
-            return fres
+                for s in rule:
+                    first_set |= first(s, grammar, first_sets)
+                    if '#' not in first(s, grammar, first_sets):
+                        break
+    first_sets[symbol] = first_set
+    return first_set
+
+# Function to compute the FOLLOW set
+def follow(symbol, grammar, start_symbol, follow_sets, first_sets):
+    if symbol in follow_sets:
+        return follow_sets[symbol]
+    follow_set = set()
+    if symbol == start_symbol:
+        follow_set.add('$')
+    for lhs in grammar:
+        for rule in grammar[lhs]:
+            for i, s in enumerate(rule):
+                if s == symbol:
+                    if i + 1 < len(rule):
+                        follow_set |= first(rule[i + 1], grammar, first_sets) - {'#'}
+                    if i + 1 == len(rule) or '#' in first(rule[i + 1], grammar, first_sets):
+                        follow_set |= follow(lhs, grammar, start_symbol, follow_sets, first_sets)
+    follow_sets[symbol] = follow_set
+    return follow_set
+
+# Function to compute all FIRST sets
+def computeAllFirsts(grammar):
+    first_sets = {}
+    for symbol in grammar:
+        first(symbol, grammar, first_sets)
+    return first_sets
+
+# Function to compute all FOLLOW sets
+def computeAllFollows(grammar, start_symbol, first_sets):
+    follow_sets = {}
+    for symbol in grammar:
+        follow(symbol, grammar, start_symbol, follow_sets, first_sets)
+    return follow_sets
+
+# Function to create the LL(1) parsing table
+def createParseTable(grammar, first_sets, follow_sets, terminals):
+    parse_table = {}
+    for lhs in grammar:
+        for rule in grammar[lhs]:
+            first_set = first(rule[0], grammar, first_sets)
+            for terminal in first_set - {'#'}:
+                if lhs not in parse_table:
+                    parse_table[lhs] = {}
+                parse_table[lhs][terminal] = rule
+            if '#' in first_set:
+                for terminal in follow_sets[lhs]:
+                    if lhs not in parse_table:
+                        parse_table[lhs] = {}
+                    parse_table[lhs][terminal] = rule
+    return parse_table
+
+# Function to validate a string using the LL(1) parsing table
+def validateStringUsingStackBuffer(parse_table, grammar_is_LL, terminals, input_string, term_userdef, start_symbol):
+    stack = [start_symbol]
+    input_string = input_string + ['$']
+    idx = 0
+    while stack:
+        top = stack[-1]
+        if top == input_string[idx]:
+            stack.pop()
+            idx += 1
+        elif top in parse_table and input_string[idx] in parse_table[top]:
+            rule = parse_table[top][input_string[idx]]
+            stack.pop()
+            if rule != ['#']:
+                stack.extend(reversed(rule))
         else:
-            fres.remove('#')
-            if len(rule) > 1:
-                ansNew = first(rule[1:], diction, term_userdef)
-                if ansNew is not None:
-                    if type(ansNew) is list:
-                        fres.extend(ansNew)
-                    else:
-                        fres.append(ansNew)
-                return fres
-            fres.append('#')
-            return fres
-    return []
-
-def follow(nt, start_symbol, diction, firsts, follows):
-    solset = set()
-    if nt == start_symbol:
-        solset.add('$')
-    for curNT in diction:
-        rhs = diction[curNT]
-        for subrule in rhs:
-            if nt in subrule:
-                while nt in subrule:
-                    index_nt = subrule.index(nt)
-                    subrule = subrule[index_nt + 1:]
-                    if len(subrule) != 0:
-                        res = first(subrule, diction, term_userdef)
-                        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, start_symbol, diction, firsts, follows)
-                    if res is not None:
-                        solset.update(res)
-    return list(solset)
-
-# Main Streamlit App Code
+            return "String is not valid."
+    if idx == len(input_string):
+        return "String is valid."
+    return "String is not valid."
 
+# Main Streamlit App
 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]
+    st.title("Grammar Analyzer")
+    st.markdown("This app performs grammar analysis, including left recursion removal, left factoring, FIRST/FOLLOW set calculations, and LL(1) parsing.")
+
+    # Input Section
+    st.sidebar.header("Input Parameters")
+    start_symbol = st.text_input("Start Symbol (Non-terminal):", "S")
+    num_rules = st.number_input("Number of Grammar Rules:", min_value=1, value=4)
+    
+    # Input rules dynamically based on the number of rules
+    grammar_rules = []
+    for i in range(num_rules):
+        rule = st.text_input(f"Rule {i + 1}:", f"S -> A k O")
+        grammar_rules.append(rule)
+    
+    non_terminals = st.text_input("Non-Terminals (comma-separated):", "S, A, B, C")
+    terminals = st.text_input("Terminals (comma-separated):", "a, b, c, d, k, r, O")
+
+    # Process the inputs
+    if st.button("Analyze"):
+        # Parse the non-terminals and terminals
+        non_terminals_list = [nt.strip() for nt in non_terminals.split(",")]
+        terminals_list = [t.strip() for t in terminals.split(",")]
         
-        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)
+        # Parse the grammar rules
+        grammar_dict = {}
+        for rule in grammar_rules:
+            lhs, rhs = rule.split("->")
+            rhs_options = rhs.split("|")
+            grammar_dict[lhs.strip()] = [option.strip().split() for option in rhs_options]
 
-        st.subheader("First Sets")
-        for nonterminal, first_set in firsts.items():
-            st.write(f"First({nonterminal}) -> {first_set}")
+        # Remove left recursion
+        grammar_dict = removeLeftRecursion(grammar_dict)
 
-        st.subheader("Follow Sets")
-        for nonterminal, follow_set in follows.items():
-            st.write(f"Follow({nonterminal}) -> {follow_set}")
+        # Apply left factoring
+        grammar_dict = LeftFactoring(grammar_dict)
 
-        # Example for parsing table
-        st.subheader("Parse Table:")
-        parse_table, grammar_is_LL, terminals = createParseTable(diction, firsts, follows)
+        # Compute FIRST and FOLLOW sets
+        first_sets = computeAllFirsts(grammar_dict)
+        follow_sets = computeAllFollows(grammar_dict, start_symbol, first_sets)
 
-        if grammar_is_LL:
-            st.write("Grammar is LL(1)")
-        else:
-            st.write("Grammar is not LL(1)")
+        # Generate parsing table
+        parse_table = createParseTable(grammar_dict, first_sets, follow_sets, terminals_list)
+
+        # Display the parsing table
+        st.subheader("Parsing Table")
+        st.write(parse_table)
 
-        # Display parsing table
-        st.write("Parse Table:")
-        for row in parse_table:
-            st.write(row)
+        # Validate the input string using the parsing table
+        input_string = st.text_input("Enter string to validate:", "a c")
+        validation_result = validateStringUsingStackBuffer(parse_table, True, terminals_list, input_string.split(), terminals_list, start_symbol)
+        st.write(validation_result)
 
-# Run the app
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()