Delete cc.py

cc.py

@@ -1,312 +0,0 @@
-import copy
-import streamlit as st
-
-stateMap = {}
-diction = {}
-start_symbol = "" 
-rules = []
-statesDict={}
-stateCount = 0
-separatedRulesList = []
-
-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()
-        rhs = k[1].strip()
-        multirhs = rhs.split('|')
-        for rhs1 in multirhs:
-            rhs1 = rhs1.strip().split()
-            rhs1.insert(0, '.')
-            newRules.append([lhs, rhs1])
-    return newRules
-
-def findClosure(input_state, dotSymbol):
-    global separatedRulesList
-
-    closureSet = []
-
-    if isinstance(input_state, int):
-        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('.')
-            if rule[1][-1] != '.':
-                dotPointsHere = rule[1][indexOfDot + 1]
-                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
-    generateStatesFor = []
-    for rule in statesDict[state]:
-        if rule[1][-1] != '.':
-            indexOfDot = rule[1].index('.')
-            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
-
-def GOTO(state, charNextToDot):
-    global statesDict, stateCount, stateMap
-    newState = []
-    for rule in statesDict[state]:
-        indexOfDot = rule[1].index('.')
-        if rule[1][-1] != '.':
-            if rule[1][indexOfDot + 1] == charNextToDot:
-                shiftedRule = copy.deepcopy(rule)
-                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])
-            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
-
-def generateStates(I0):
-    global statesDict, stateCount
-
-    statesDict[0] = I0
-    stateCount = 0
-    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 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:
-        if rule[0] in list(diction.keys()):
-            fres = []
-            rhs_rules = diction[rule[0]]
-            for itr in rhs_rules:
-                indivRes = first(itr)
-                if type(indivRes) is list:
-                    for i in indivRes:
-                        fres.append(i)
-                else:
-                    fres.append(indivRes)
-
-            if '#' not in fres:
-                return fres
-            else:
-                newList = []
-                fres.remove('#')
-                if len(rule) > 1:
-                    ansNew = first(rule[1:])
-                    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
-    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 '#' in res:
-                            newList = []
-                            res.remove('#')
-                            ansNew = follow(curNT)
-                            if ansNew != None:
-                                if type(ansNew) is list:
-                                    newList = res + ansNew
-                                else:
-                                    newList = res + [ansNew]
-                            else:
-                                newList = res
-                            res = newList
-                    else:
-                        if nt != curNT:
-                            res = follow(curNT)
-
-                    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):
-    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')
-    
-    nonterm_userdef = st.text_input("Enter the non-terminal symbols (separated by space):", "E T F")
-    nonterm_userdef = nonterm_userdef.split()
-    
-    term_userdef = st.text_input("Enter the terminal symbols (separated by space):", "id + * ( )")
-    term_userdef = term_userdef.split()
-    
-    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])}")
-
-        generateStates(I0)
-
-        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("")
-
-        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)
-
-        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()