Update app.py

app.py

@@ -1,21 +1,14 @@
-
-import copy
 import streamlit as st
-
-stateMap = {}
-diction = {}
-start_symbol = "" 
-rules = []
-statesDict={}
-stateCount = 0
-separatedRulesList = []
+import copy
 
 def grammarAugmentation(rules, nonterm_userdef, start_symbol):
     newRules = []
     newChar = start_symbol + "'"
     while (newChar in nonterm_userdef):
         newChar += "'"
+    
     newRules.append([newChar, ['.', start_symbol]])
+    
     for rule in rules:
         k = rule.split("->")
         lhs = k[0].strip()
@@ -27,22 +20,19 @@ def grammarAugmentation(rules, nonterm_userdef, start_symbol):
             newRules.append([lhs, rhs1])
     return newRules
 
-def findClosure(input_state, dotSymbol):
-    global separatedRulesList
-
+def findClosure(input_state, dotSymbol, separatedRulesList, start_symbol):
     closureSet = []
-
-    if isinstance(input_state, int):
+    
+    if dotSymbol == start_symbol:
         for rule in separatedRulesList:
             if rule[0] == dotSymbol:
                 closureSet.append(rule)
     else:
         closureSet = input_state
-
+    
     prevLen = -1
     while prevLen != len(closureSet):
         prevLen = len(closureSet)
-
         tempClosureSet = []
         for rule in closureSet:
             indexOfDot = rule[1].index('.')
@@ -51,14 +41,13 @@ def findClosure(input_state, dotSymbol):
                 for in_rule in separatedRulesList:
                     if dotPointsHere == in_rule[0] and in_rule not in tempClosureSet:
                         tempClosureSet.append(in_rule)
-
+        
         for rule in tempClosureSet:
             if rule not in closureSet:
                 closureSet.append(rule)
     return closureSet
 
-def compute_GOTO(state):
-    global statesDict, stateCount
+def compute_GOTO(state, statesDict, separatedRulesList, stateMap, stateCount):
     generateStatesFor = []
     for rule in statesDict[state]:
         if rule[1][-1] != '.':
@@ -66,13 +55,13 @@ def compute_GOTO(state):
             dotPointsHere = rule[1][indexOfDot + 1]
             if dotPointsHere not in generateStatesFor:
                 generateStatesFor.append(dotPointsHere)
+    
     if len(generateStatesFor) != 0:
         for symbol in generateStatesFor:
-            GOTO(state, symbol)
-    return
+            stateCount = GOTO(state, symbol, statesDict, separatedRulesList, stateMap, stateCount)
+    return stateCount
 
-def GOTO(state, charNextToDot):
-    global statesDict, stateCount, stateMap
+def GOTO(state, charNextToDot, statesDict, separatedRulesList, stateMap, stateCount):
     newState = []
     for rule in statesDict[state]:
         indexOfDot = rule[1].index('.')
@@ -82,204 +71,265 @@ def GOTO(state, charNextToDot):
                 shiftedRule[1][indexOfDot] = shiftedRule[1][indexOfDot + 1]
                 shiftedRule[1][indexOfDot + 1] = '.'
                 newState.append(shiftedRule)
-
+    
     addClosureRules = []
     for rule in newState:
         indexDot = rule[1].index('.')
         if rule[1][-1] != '.':
-            closureRes = findClosure(newState, rule[1][indexDot + 1])
+            closureRes = findClosure(newState, rule[1][indexDot + 1], separatedRulesList, start_symbol)
             for rule in closureRes:
                 if rule not in addClosureRules and rule not in newState:
                     addClosureRules.append(rule)
-
+    
     for rule in addClosureRules:
         newState.append(rule)
-
+    
     stateExists = -1
     for state_num in statesDict:
         if statesDict[state_num] == newState:
             stateExists = state_num
             break
-
+    
     if stateExists == -1:
         stateCount += 1
         statesDict[stateCount] = newState
         stateMap[(state, charNextToDot)] = stateCount
     else:
         stateMap[(state, charNextToDot)] = stateExists
-    return
+    return stateCount
 
-def generateStates(I0):
-    global statesDict, stateCount
-
-    statesDict[0] = I0
-    stateCount = 0
+def generateStates(statesDict, separatedRulesList, stateMap, stateCount):
     prev_len = -1
     called_GOTO_on = []
+    
     while (len(statesDict) != prev_len):
         prev_len = len(statesDict)
         keys = list(statesDict.keys())
+        
         for key in keys:
             if key not in called_GOTO_on:
                 called_GOTO_on.append(key)
-                compute_GOTO(key)
-    return
-
-def first(rule):
-    global rules, term_userdef, diction, firsts
-    if len(rule) != 0 and rule[0] in term_userdef:
-        return [rule[0]]
-    if len(rule) != 0 and rule[0] == '#':
-        return ['#']
+                stateCount = compute_GOTO(key, statesDict, separatedRulesList, stateMap, stateCount)
+    return stateCount
+
+def first(rule, diction, term_userdef):
+    if len(rule) != 0 and (rule is not None):
+        if rule[0] in term_userdef:
+            return rule[0]
+        elif rule[0] == '#':
+            return '#'
+    
     if len(rule) != 0:
-        fres = []
-        rhs_rules = diction[rule[0]]
-        for itr in rhs_rules:
-            indivRes = first(itr)
-            if '#' in indivRes:
-                indivRes.remove('#')
-                if len(rule) > 1:
-                    indivRes += first(rule[1:])
+        if rule[0] in list(diction.keys()):
+            fres = []
+            rhs_rules = diction[rule[0]]
+            
+            for itr in rhs_rules:
+                indivRes = first(itr, diction, term_userdef)
+                if type(indivRes) is list:
+                    for i in indivRes:
+                        fres.append(i)
                 else:
-                    indivRes.append('#')
-            fres.extend(indivRes)
-        return list(set(fres))
-    return []
+                    fres.append(indivRes)
+            
+            if '#' not in fres:
+                return fres
+            else:
+                newList = []
+                fres.remove('#')
+                if len(rule) > 1:
+                    ansNew = first(rule[1:], diction, term_userdef)
+                    if ansNew != None:
+                        if type(ansNew) is list:
+                            newList = fres + ansNew
+                        else:
+                            newList = fres + [ansNew]
+                    else:
+                        newList = fres
+                    return newList
+                fres.append('#')
+                return fres
 
-def follow(nt):
-    global start_symbol, diction, firsts, follows
+def follow(nt, start_symbol, rules, diction):
     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 subrule:
-                        res = first(subrule)
+                    
+                    if len(subrule) != 0:
+                        res = first(subrule, diction, term_userdef)
                         if '#' in res:
+                            newList = []
                             res.remove('#')
-                            solset.update(res)
-                            solset.update(follow(curNT))
-                        else:
-                            solset.update(res)
+                            ansNew = follow(curNT, start_symbol, rules, diction)
+                            if ansNew != None:
+                                if type(ansNew) is list:
+                                    newList = res + ansNew
+                                else:
+                                    newList = res + [ansNew]
+                            else:
+                                newList = res
+                            res = newList
                     else:
                         if nt != curNT:
-                            solset.update(follow(curNT))
+                            res = follow(curNT, start_symbol, rules, diction)
+                    
+                    if res is not None:
+                        if type(res) is list:
+                            for g in res:
+                                solset.add(g)
+                        else:
+                            solset.add(res)
     return list(solset)
 
+def createParseTable(statesDict, stateMap, T, NT, separatedRulesList, rules, diction):
+    rows = list(statesDict.keys())
+    cols = T + ['$'] + NT
     
-def createParseTable(statesDict, stateMap, T, NT):
-    global separatedRulesList, diction
-
-    parse_table = {i: {} for i in range(len(statesDict))}
-
-    for (state, symbol) in stateMap:
-        if symbol in T:
-            parse_table[state][symbol] = f'S{stateMap[(state, symbol)]}'
-        elif symbol in NT:
-            parse_table[state][symbol] = str(stateMap[(state, symbol)])
-
-    for state in statesDict:
-        for item in statesDict[state]:
-            if item[1][-1] == '.':  
-                prod = f"{item[0]} -> {' '.join(item[1][:-1])}"
-           
-                if prod == f"{separatedRulesList[0][0]} -> {separatedRulesList[0][1][1]}":
-                    parse_table[state]['$'] = 'ACC'
-                else:
-                    rule_index = next(
-                        (i for i, rule in enumerate(separatedRulesList) if rule == item),
-                        None  
-                    )
-
-                    if rule_index is None:
-                        print(f"Warning: Rule for item {item} not found in separatedRulesList.")
-                        continue  
-
-                    for symbol in T + ['$']:
-                        if symbol not in parse_table[state]:
-                            parse_table[state][symbol] = f'R{rule_index}'
-
-    return parse_table
-
-
-def main():
-    st.title("SLR(1) Parser Generator")
-
-    st.header("Grammar Input")
-    rules = st.text_area("Enter the grammar rules (one per line):", 
-                         "E -> E + T | T\nT -> T * F | F\nF -> ( E ) | id")
-    rules = rules.split('\n')
+    Table = []
+    tempRow = []
+    for y in range(len(cols)):
+        tempRow.append('')
+    for x in range(len(rows)):
+        Table.append(copy.deepcopy(tempRow))
     
-    nonterm_userdef = st.text_input("Enter the non-terminal symbols (separated by space):", "E T F")
-    nonterm_userdef = nonterm_userdef.split()
+    for entry in stateMap:
+        state = entry[0]
+        symbol = entry[1]
+        a = rows.index(state)
+        b = cols.index(symbol)
+        if symbol in NT:
+            Table[a][b] = Table[a][b] + f"{stateMap[entry]} "
+        elif symbol in T:
+            Table[a][b] = Table[a][b] + f"S{stateMap[entry]} "
     
-    term_userdef = st.text_input("Enter the terminal symbols (separated by space):", "id + * ( )")
-    term_userdef = term_userdef.split()
+    numbered = {}
+    key_count = 0
+    for rule in separatedRulesList:
+        tempRule = copy.deepcopy(rule)
+        tempRule[1].remove('.')
+        numbered[key_count] = tempRule
+        key_count += 1
     
-    start_symbol = st.text_input("Enter the start symbol:", "E")
-
-    if st.button("Generate SLR(1) Parser"):
-        st.subheader("Original Grammar Input:")
-        for rule in rules:
-            st.write(rule)
-
-        st.subheader("Grammar after Augmentation:")
-        global separatedRulesList
-        separatedRulesList = grammarAugmentation(rules, nonterm_userdef, start_symbol)
-        for rule in separatedRulesList:
-            st.write(f"{rule[0]} -> {' '.join(rule[1])}")
-
-        start_symbol = separatedRulesList[0][0]
-        st.subheader("Calculated Closure: I0")
-        I0 = findClosure(0, start_symbol)
-
-        st.write("I0:")
-        for rule in I0:
-            st.write(f"{rule[0]} -> {' '.join(rule[1])}")
+    for stateno in statesDict:
+        for rule in statesDict[stateno]:
+            if rule[1][-1] == '.':
+                temp2 = copy.deepcopy(rule)
+                temp2[1].remove('.')
+                for key in numbered:
+                    if numbered[key] == temp2:
+                        follow_result = follow(rule[0], start_symbol, rules, diction)
+                        for col in follow_result:
+                            index = cols.index(col)
+                            if key == 0:
+                                Table[stateno][index] = "Accept"
+                            else:
+                                Table[stateno][index] = Table[stateno][index] + f"R{key} "
+    
+    return Table, cols, rows
 
-        generateStates(I0)
+# Streamlit app
+st.title("SLR(1) Parser Generator")
 
-        st.subheader("Generated States:")
-        for state, rules in statesDict.items():
-            st.write(f"I{state}:")
-            for rule in rules:
-                st.write(f"  {rule[0]} -> {' '.join(rule[1])}")
-            st.write("")
+# Input section
+st.header("Grammar Input")
+st.write("Enter grammar rules in the format: A -> B | C")
 
-        st.subheader("SLR(1) Parsing Table")
-        table = createParseTable(statesDict, stateMap, term_userdef, nonterm_userdef)
-  
-        cols = ['State'] + term_userdef + ['$'] + nonterm_userdef
-        table_data = []
-        for state in range(len(statesDict)):
-            row = [f'I{state}']
-            for symbol in term_userdef + ['$'] + nonterm_userdef:
-                row.append(table[state].get(symbol, ''))
-            table_data.append(row)
-        
-        st.table([cols] + table_data)
+# Initialize session state for rules
+if 'rules' not in st.session_state:
+    st.session_state.rules = ["E -> E + T | T", "T -> T * F | F", "F -> ( E ) | id"]
 
-        compact_table = "State`" + '`'.join(term_userdef + ['$'] + nonterm_userdef) + '`'
-        for state in range(len(statesDict)):
-            compact_table += f"I{state}"
-            for symbol in term_userdef + ['$'] + nonterm_userdef:
-                compact_table += table[state].get(symbol, '')
-        st.subheader("Follow Sets")
-        follow_sets = {}
-        for nt in nonterm_userdef:
-            follow_set = follow(nt)
-            follow_sets[nt] = follow_set
-            st.write(f"Follow({nt}): {{ {' , '.join(follow_set)} }}")
-        compact_follow = "Non-Terminal`Follow Set\n"
-        for nt, follow_set in follow_sets.items():
-            compact_follow += f"{nt}`{{ {' , '.join(follow_set)} }}\n"
-        
-        st.text_area("Compact Follow Sets Representation:", value=compact_follow, height=300)
-
-if __name__ == "__main__":
-    main()
+# Display rules input
+rules = []
+for i in range(len(st.session_state.rules)):
+    rule = st.text_input(f"Rule {i+1}", value=st.session_state.rules[i], key=f"rule_{i}")
+    rules.append(rule)
+
+# # Add/remove rule buttons
+# col1, col2 = st.columns(2)
+
+# with col1:
+#     if st.button("Add Rule"):
+#         st.session_state.rules.append("")  # Add a new empty rule
+#         # Trigger the rerun by changing the rules list
+#         # st.experimental_rerun()  
+# with col2:
+#     if st.button("Remove Rule") and len(st.session_state.rules) > 1:
+#         st.session_state.rules.pop()  # Remove last rule
+#         # Trigger the rerun by changing the rules list
+#         # st.experimental_rerun() 
+
+# Other inputs
+nonterm_userdef = st.text_input("Non-terminal symbols (separated by space)", "E T F").split()
+term_userdef = st.text_input("Terminal symbols (separated by space)", "id + * ( )").split()
+start_symbol = st.text_input("Start symbol", "E")
+
+if st.button("Generate Parser"):
+    st.header("Results")
+    
+    # Display original grammar
+    st.subheader("Original Grammar")
+    for rule in rules:
+        st.write(rule)
+    
+    # Grammar augmentation
+    separatedRulesList = grammarAugmentation(rules, nonterm_userdef, start_symbol)
+    
+    st.subheader("Augmented Grammar")
+    for rule in separatedRulesList:
+        st.write(f"{rule[0]} -> {' '.join(rule[1])}")
+    
+    # Initialize variables
+    statesDict = {}
+    stateMap = {}
+    stateCount = 0
+    diction = {}
+    
+    # Calculate closure
+    I0 = findClosure(0, start_symbol, separatedRulesList, start_symbol)
+    statesDict[0] = I0
+    
+    st.subheader("Initial Closure (I0)")
+    for rule in I0:
+        st.write(f"{rule[0]} -> {' '.join(rule[1])}")
+    
+    # Generate states
+    stateCount = generateStates(statesDict, separatedRulesList, stateMap, stateCount)
+    # Display generated states
+    with st.expander("🔍 View Generated States"):
+        for state_num, state_rules in statesDict.items():
+            st.markdown(f"**I{state_num}:**")
+            for rule in state_rules:
+                st.write(f"{rule[0]} -> {' '.join(rule[1])}")
+
+
+    # Create parsing table
+    rules.insert(0, f"{separatedRulesList[0][0]} -> {separatedRulesList[0][1][1]}")
+    for rule in rules:
+        k = rule.split("->")
+        k[0] = k[0].strip()
+        k[1] = k[1].strip()
+        rhs = k[1]
+        multirhs = rhs.split('|')
+        for i in range(len(multirhs)):
+            multirhs[i] = multirhs[i].strip()
+            multirhs[i] = multirhs[i].split()
+        diction[k[0]] = multirhs
+    
+    Table, cols, rows = createParseTable(statesDict, stateMap, term_userdef, nonterm_userdef, separatedRulesList, rules, diction)
+    
+    # Display parsing table
+    st.subheader("SLR(1) Parsing Table")
+    
+    # Create DataFrame for better display
+    import pandas as pd
+    df = pd.DataFrame(Table, columns=cols, index=[f"I{i}" for i in rows])
+    st.dataframe(df)