Update app.py

app.py

@@ -1,8 +1,13 @@
 import streamlit as st
-import numpy as np
-import pandas as pd
 
-# Function to remove left recursion
+rules = []
+nonterm_userdef = []
+term_userdef = []
+diction = {}
+firsts = {}
+follows = {}
+start_symbol = None
+
 def removeLeftRecursion(rulesDiction):
     store = {}
     for lhs in rulesDiction:
@@ -16,7 +21,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_)
@@ -29,14 +34,13 @@ 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 = dict()
         for subrhs in allrhs:
-            if subrhs[0] not in temp.keys():
+            if subrhs[0] not in list(temp.keys()):
                 temp[subrhs[0]] = [subrhs]
             else:
                 temp[subrhs[0]].append(subrhs)
@@ -46,7 +50,7 @@ def LeftFactoring(rulesDiction):
             allStartingWithTermKey = temp[term_key]
             if len(allStartingWithTermKey) > 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 = []
@@ -60,148 +64,175 @@ def LeftFactoring(rulesDiction):
             newDict[key] = tempo_dict[key]
     return newDict
 
-# 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('#')
+def first(rule):
+    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 and rule[0] in diction:
+        fres = []
+        rhs_rules = diction[rule[0]]
+        for itr in rhs_rules:
+            indivRes = first(itr)
+            if type(indivRes) is list:
+                fres.extend(indivRes)
             else:
-                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
+                fres.append(indivRes)
+        if '#' not in fres:
+            return fres
+        else:
+            newList = fres
+            fres.remove('#')
+            if len(rule) > 1:
+                ansNew = first(rule[1:])
+                if ansNew is not None:
+                    if type(ansNew) is list:
+                        newList = fres + ansNew
+                    else:
+                        newList = fres + [ansNew]
+            fres.append('#')
+            return fres
+
+def follow(nt):
+    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)
+                        if res is not None:
+                            if '#' in res:
+                                res.remove('#')
+                                follow_res = follow(curNT)
+                                if follow_res:
+                                    res += follow_res
+                        else:
+                            res = []
+                    else:
+                        if nt != curNT:
+                            res = follow(curNT)
+                            if res is None:
+                                res = []
+                    solset.update(res if type(res) is list else [res])
+    return list(solset)
+
+def computeAllFirsts():
+    global firsts
+    for y in diction.keys():
+        firsts[y] = set()
+        for sub in diction[y]:
+            result = first(sub)
+            if result is not None:
+                firsts[y].update(result if type(result) is list else [result])
+
+def computeAllFollows():
+    global follows
+    for NT in diction.keys():
+        follows[NT] = set(follow(NT))
+
+def createParseTable():
+    global 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 lhs in diction:
+        for rule in diction[lhs]:
+            first_res = first(rule)
+            if '#' in first_res:
+                first_res.remove('#')
+                follow_res = follows[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
+
+def validateStringUsingStackBuffer(parse_table, input_string):
+    stack = [start_symbol, '$']
+    buffer = ['$'] + input_string.split()[::-1]
     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))
+        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:
-            return "String is not valid."
-    if idx == len(input_string):
-        return "String is valid."
-    return "String is not valid."
+            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"
+
 
 # Main Streamlit App
-def main():
-    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(",")]
-        
-        # 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]
-
-        # Remove left recursion
-        grammar_dict = removeLeftRecursion(grammar_dict)
-
-        # Apply left factoring
-        grammar_dict = LeftFactoring(grammar_dict)
-
-        # Compute FIRST and FOLLOW sets
-        first_sets = computeAllFirsts(grammar_dict)
-        follow_sets = computeAllFollows(grammar_dict, start_symbol, first_sets)
-
-        # 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)
-
-        # 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)
-
-if __name__ == "__main__":
-    main()
+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)
+
+    computeAllFirsts()
+    st.subheader("FIRST Sets")
+    st.write(firsts)
+
+    computeAllFollows()
+    st.subheader("FOLLOW Sets")
+    st.write(follows)
+
+    parse_table, grammar_is_LL = createParseTable()
+    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)