Update app.py

app.py

@@ -138,57 +138,92 @@ def computeAllFollows():
 def createParseTable():
     global diction, term_userdef, firsts, follows
     
-    # Initialize parse table with empty strings
     parse_table = {}
     for non_term in diction:
         parse_table[non_term] = {}
         for term in term_userdef + ['$']:
             parse_table[non_term][term] = ""
     
-    # Fill parse table
     grammar_is_LL = True
     
     for non_term in diction:
         for production in diction[non_term]:
             first_set = first(production)
             
-            # If epsilon is in FIRST set, add FOLLOW set
             if '#' in first_set:
                 first_set.remove('#')
-                first_set.extend(follows[non_term])
+                follow_set = follows[non_term]
+                first_set.extend(follow_set)
             
             for terminal in first_set:
-                if parse_table[non_term].get(terminal, "") == "":
-                    parse_table[non_term][terminal] = f"{non_term} -> {' '.join(production)}"
-                else:
-                    grammar_is_LL = False
+                if terminal in term_userdef + ['$']:
+                    if parse_table[non_term][terminal] == "":
+                        parse_table[non_term][terminal] = production
+                    else:
+                        grammar_is_LL = False
     
     return parse_table, grammar_is_LL
 
-def validateStringUsingStackBuffer(parse_table, input_string):
-    stack = [start_symbol, '$']
-    buffer = list(input_string.split()) + ['$']
+def validateStringUsingStackBuffer(parse_table, input_string, start_sym):
+    print("Validating:", input_string)  # Debug print
+    
+    # Initialize stack and input buffer
+    stack = [start_sym, '$']
+    input_tokens = input_string.split()
+    input_tokens.append('$')
+    buffer = input_tokens
+    
+    print("Initial stack:", stack)  # Debug print
+    print("Initial buffer:", buffer)  # Debug print
     
+    parsing_steps = []
+    parsing_steps.append(f"Stack: {stack}, Input: {buffer}")
+
+    # Processing loop
     while stack and buffer:
+        print(f"\nCurrent stack: {stack}")  # Debug print
+        print(f"Current buffer: {buffer}")  # Debug print
+        
+        # Get top of stack and current input
         top_stack = stack[0]
         current_input = buffer[0]
         
+        parsing_steps.append(f"Top of stack: {top_stack}, Current input: {current_input}")
+        
+        # Case 1: Match found
         if top_stack == current_input:
             stack.pop(0)
             buffer.pop(0)
-        elif top_stack in term_userdef:
-            return "Invalid String: Terminal mismatch"
-        elif parse_table[top_stack][current_input]:
-            production = parse_table[top_stack][current_input].split('->')[1].strip().split()
-            stack.pop(0)
-            if production != ['#']:
-                stack = production + stack
+            parsing_steps.append("Matched and consumed")
+            continue
+            
+        # Case 2: Non-terminal on top
+        if top_stack in parse_table:
+            if current_input in parse_table[top_stack]:
+                production = parse_table[top_stack][current_input]
+                
+                if production:
+                    # Pop the non-terminal
+                    stack.pop(0)
+                    # Push the production in reverse (if it's not epsilon)
+                    if production != ['#']:
+                        stack = production + stack
+                    parsing_steps.append(f"Applied rule: {top_stack} -> {' '.join(production) if production else '#'}")
+                else:
+                    return False, f"No production for {top_stack} with input {current_input}", parsing_steps
+            else:
+                return False, f"Input symbol {current_input} not in parse table for {top_stack}", parsing_steps
         else:
-            return "Invalid String: No production rule found"
+            # If top of stack is not in parse table and doesn't match input
+            return False, f"Unexpected symbol {top_stack} on stack", parsing_steps
+            
+        print(f"Updated stack: {stack}")  # Debug print
     
-    if not stack and not buffer:
-        return "Valid String"
-    return "Invalid String: Stack or buffer not empty"
+    # Check if both stack and buffer are empty (except for $)
+    if len(stack) <= 1 and len(buffer) <= 1:
+        return True, "String accepted", parsing_steps
+    else:
+        return False, "String rejected - incomplete parse", parsing_steps
 
 # Streamlit UI
 st.title("LL(1) Grammar Analyzer")
@@ -198,15 +233,15 @@ st.header("Grammar Input")
 start_symbol = st.text_input("Enter Start Symbol:", "S")
 
 with st.expander("Enter Grammar Rules"):
-    num_rules = st.number_input("Number of Rules:", min_value=1, value=3)
+    num_rules = st.number_input("Number of Rules:", min_value=1, value=4)
     rules = []
     for i in range(num_rules):
         rule = st.text_input(f"Rule {i+1} (format: A -> B c | d)", key=f"rule_{i}")
         if rule:
             rules.append(rule)
 
-nonterm_input = st.text_input("Enter Non-terminals (comma-separated):", "S,A,B")
-term_input = st.text_input("Enter Terminals (comma-separated):", "a,b,c")
+nonterm_input = st.text_input("Enter Non-terminals (comma-separated):", "S,A,B,C")
+term_input = st.text_input("Enter Terminals (comma-separated):", "a,b,c,d,k,r,O")
 
 if nonterm_input.strip():
     nonterm_userdef = [x.strip() for x in nonterm_input.split(',') if x.strip()]
@@ -255,7 +290,11 @@ if st.button("Analyze Grammar"):
     for non_term in parse_table:
         row = [non_term]  # First column is non-terminal
         for term in terminals:
-            row.append(parse_table[non_term].get(term, ""))
+            production = parse_table[non_term].get(term, "")
+            if production:
+                row.append(' '.join(production))
+            else:
+                row.append("")
         df_data.append(row)
     
     df = pd.DataFrame(df_data, columns=['Non-Terminal'] + terminals)
@@ -268,10 +307,17 @@ if st.button("Analyze Grammar"):
     
     # String validation section
     st.subheader("String Validation")
-    input_string = st.text_input("Enter string to validate (space-separated):", "")
+    input_string = st.text_input("Enter string to validate (space-separated):", "a r k O")
     if input_string:
-        result = validateStringUsingStackBuffer(parse_table, input_string)
-        if "Valid" in result:
-            st.success(result)
+        is_valid, message, steps = validateStringUsingStackBuffer(parse_table, input_string, start_symbol)
+        
+        # Display the result
+        if is_valid:
+            st.success(message)
         else:
-            st.error(result)
+            st.error(message)
+            
+        # Display parsing steps
+        st.subheader("Parsing Steps")
+        for i, step in enumerate(steps):
+            st.text(f"Step {i+1}: {step}")