HyperDbg/hyperdbg/script-engine/python/ll1_parser.py

"""
 * @file ll1_parse_table_generator.py
 * @author M.H. Gholamrezei (mh@hyperdbg.org)
 * @author Sina Karvandi (sina@hyperdbg.org)
 * @brief Script engine LL(1) Parse table generator 
 * @details This program reads grammar from Greammar.txt file 
 *          placed in the same directory of the program 
 *          and creates parse_table.h and parse_table.c which is 
 *          used by the parser of script engine. 
 * @version 0.1
 * @date 2020-10-24
 *
 * @copyright This project is released under the GNU Public License v3.
 
 """

from util import *
from lalr1_parser import *

class LL1Parser:
    def __init__(self, SourceFile, HeaderFile, CommonHeaderFile, CommonHeaderFileScala):
        # The file which contains the grammar of the language 
        self.GrammarFile = open("Grammar.txt", "r")

        # The file which is used by parser for parsing the input 
        self.SourceFile = SourceFile
        self.HeaderFile = HeaderFile
        self.CommonHeaderFile = CommonHeaderFile 
        self.CommonHeaderFileScala = CommonHeaderFileScala 
        

        # Lists which used for storing the rules:
        # Right Hand Side(Rhs)
        self.RhsList = []

        # Left Hand Side(Lhs)
        self.LhsList = []

        # Set of all terminals and noneterminals
        self.TerminalSet = set()
        self.NonTerminalSet = set()

        # Start variable 
        self.Start = ""


        # maximum of "Right Hand Side(Rhs)" length
        self.MAXIMUM_RHS_LEN = 0


        self.SPECIAL_TOKENS = ['%', '+', '~', '!', '++', '-', '--', '->', '.', "*", "/", "=", "==", "!=", ",", ";", "(", ")", "{", "}", "|", "||", ">>", ">=", "<<", "<=", "&", "&&", "^",
                              "+=", "-=", "*=", "/=", "%=", "<<=", ">>=", "&=", "^=", "|=" , "[", "]"]

        # INVALID rule indicator
        self.INVALID = 0x80000000

        self.FunctionsDict = dict()
        self.OperatorsTwoOperand = []
        self.OperatorsOneOperand = []
        self.RegistersList = []
        self.PseudoRegistersList = []
        self.VariableTypeList = []
        self.keywordList = []
        self.SemantiRulesList = []
        self.AssignmentOperator = []


        # Dictionaries used for storing first and follow sets 
        self.FirstDict = dict()
        self.FollowDict = dict()



    def Run(self):
        # Read grammar from input file and initialize grammar related variables 
        self.ReadGrammar()

        # Calculate "First Set" for all nonterminals and print it
        self.FindAllFirsts()
        # print("Firsts:")
        # self.PrintFirsts()
        # print("________________________________________________________________________________")

        # Calculate "Follow Set" for all nonterminals and print it
        self.FindAllFollows()
        # print("Follows:")
        # self.PrintFollows()
        # print("________________________________________________________________________________")
        
        # Calculate "Prdicted Set" for each rule and print it
        self.FindAllPredicts()
        # print("Predicts:")
        # self.print_predicts()
        # print("________________________________________________________________________________")

        # Fills "Parse Table" according to calculated "Predicted Set" and print "Parse Table"
        self.FillParseTable()
        # print("Parse Table:")
        # self.PrintParseTable()
        # print()
        
        # Prints variables that are needed for parser for parsing into the output file 
        self.HeaderFile.write("#pragma once\n")

        self.HeaderFile.write("#ifndef PARSE_TABLE_H\n")
        self.HeaderFile.write("#define PARSE_TABLE_H\n")
        
        self.HeaderFile.write("#define RULES_COUNT " + str(len(self.LhsList)) + "\n")
        self.HeaderFile.write("#define TERMINAL_COUNT " + str(len(list(self.TerminalSet))) + "\n")
        self.HeaderFile.write("#define NONETERMINAL_COUNT " + str(len(list(self.NonTerminalList))) + "\n")
        self.HeaderFile.write("#define START_VARIABLE " + "\"" + self.Start +"\"\n")
        self.HeaderFile.write("#define MAX_RHS_LEN "  + str(self.MAXIMUM_RHS_LEN) +"\n")
        self.HeaderFile.write("#define KEYWORD_LIST_LENGTH "  + str(len(self.keywordList)) +"\n")
        self.HeaderFile.write("#define OPERATORS_ONE_OPERAND_LIST_LENGTH " + str(len(self.OperatorsOneOperand)) + "\n")
        self.HeaderFile.write("#define OPERATORS_TWO_OPERAND_LIST_LENGTH " + str(len(self.OperatorsTwoOperand)) + "\n")
        self.HeaderFile.write("#define REGISTER_MAP_LIST_LENGTH " + str(len(self.RegistersList))+ "\n")
        self.HeaderFile.write("#define PSEUDO_REGISTER_MAP_LIST_LENGTH " + str(len(self.PseudoRegistersList))+ "\n")
        self.HeaderFile.write("#define SCRIPT_VARIABLE_TYPE_LIST_LENGTH " + str(len(self.VariableTypeList))+ "\n")
        self.HeaderFile.write("#define ASSIGNMENT_OPERATOR_LIST_LENGTH " + str(len(self.AssignmentOperator)) + "\n")
        self.HeaderFile.write("#define SEMANTIC_RULES_MAP_LIST_LENGTH " + str(len(self.keywordList) + len(self.OperatorsOneOperand) + len(self.OperatorsTwoOperand) + len(self.SemantiRulesList) + len(self.AssignmentOperator))+ "\n")
        for Key in self.FunctionsDict:
            self.HeaderFile.write("#define "+ Key[1:].upper() + "_LENGTH "+ str(len(self.FunctionsDict[Key]))+"\n")

       
        self.SourceFile.write("#include \"pch.h\"\n")



        # Prints Rules into output files
        self.WriteLhsList()
        self.WriteRhsList()
        
        # Prints size of each Rhs into output files
        self.WriteRhsSize()

        # Prints noneterminals and Terminal into output files
        self.WriteNoneTermianlList()
        self.WriteTerminalList()

        # Prints "Parse Table" into output files
        self.WriteParseTable()

        # Prints Keywords list into output files 
        self.WriteKeywordList()

        # Prints Operators List into output files 
        self.WriteOperatorsList()

        # Prints Maps into output files 
        self.WriteMaps()
        

        

        self.WriteSemanticMaps()
        self.WriteRegisterMaps()
        self.WritePseudoRegMaps()
        self.WriteVariableTypeList()

        # Closes Grammar Input File 
        self.GrammarFile.close()

 


    def SetLalr(self, Lalr, LalrParseTable):
        self.Lalr = Lalr
        self.LalrParseTable = LalrParseTable

    # This function simulates of script engine parser in ScriptEngine.C in
    # order to test the generated "Parse Table"
    def Parse(self, Tokens):
        # Initialize Parse Stack 
        Stack = []

        # Initialize Match Stack 
        MatchedStack = []

        # Push the end of stack indicator into stack
        Stack.append("$")

        # Push start variable into stack
        Stack.append(self.Start)

        # Assign top variable an invalid value 
        Top = ""

        # Read input
        Tokens, CurrentIn = Read(Tokens)

        # Temporary values counter initialized with 0 value 
        TempCounter = 0 
        
        # While Stack is not empty repeat 
        while Top != "$":

            # Read top of stack 
            Top = GetTop(Stack)
            # print(Stack)
            # print("Top:", Top)
            # print("CurrentIn:", CurrentIn, "\n\n")
            # x = input()


            
            if self.IsNoneTerminal(Top):
                if Top == "BOOLEAN_EXPRESSION":
                    print("Top == BOOLEAN_EXPRESSION:")
                    print(Stack)
                    print(Tokens)
                    print(CurrentIn)
                    print("=====================================\n\n")

                    Stack.pop()
                    
                    #------------------------------------------------------
                    # Get BE Tokens 
                    BETokensSize = 0
                    OpenParanthesesCount = 1 

                    i = 0
                    while True:
                        TempToken = Tokens[i]
                       
                        i +=1
                        if TempToken == '(' :
                            OpenParanthesesCount += 1
                            BETokensSize += 1
                        elif TempToken == ')':
                            OpenParanthesesCount -= 1
                            if OpenParanthesesCount == 0:
                                break 
                            else:
                                BETokensSize +=1
                        else:
                            BETokensSize +=1
                        print("TempToken: ", end = "")
                        print(TempToken)
                        print("BETokensSize: ", end = "")
                        print(BETokensSize)


                    # BETokens.append("$end")
                    print("BETokensSize: ", end = "")
                    print(BETokensSize)
                    y = input()
                    NewTokens = [CurrentIn]
                    for x in Tokens:
                        NewTokens.append(x)
                    #------------------------------------------------------
                    Tokens = self.Lalr.Parse(NewTokens, BETokensSize + 1)
                    # x = input()
                    print("after lalr parsing:")
                    print(Stack)
                    print(Tokens)
                    print("=====================================\n\n")
                    

                    CurrentIn = Tokens[0]   
                    if (len(Tokens) > 1):
                        Tokens = Tokens[1:]
                    # x = input()
                else:
                    Id = self.ParseTable[self.GetNoneTerminalId(Top)][self.GetTerminalId(CurrentIn)]

                    # Error Handling 
                    if Id == -1: 
                        
                        print("1)Error in input!")
                        print(Tokens)
                        print(Stack)
                        print("Top: ", Top)
                        print("CurrentIn: ", CurrentIn)
                        print("\n\n")
                        exit()

                    Stack.pop()
                    

                    Rhs = self.RhsList[Id]
                    if Rhs != ["eps"]:
                        for Symbol in reversed(Rhs):
                            Stack.append(Symbol)

                
            elif self.IsSemanticRule(Top):
                if Top == "@PUSH":
                    Stack.pop()
                    Top = GetTop(Stack)
                    if Top == CurrentIn:
                        MatchedStack.append(Top)
                        Tokens, CurrentIn = Read(Tokens)
                    else: 
                        print("2)Error in input!")
                        exit()   
                elif Top == "@JZ":
                    print("JZ:")
                    print(Stack)
                    print(Tokens)
                    print("\n\n")
                    y = input()

                elif Top == "@JZCMPL":
                    print("JZCOMPELETED:")
                    print(Stack)
                    print(Tokens)
                    print("\n\n")
                    y = input()
                    

                   
                
                else:
                    Op0 = MatchedStack.pop()
                    if Top == "@PRINT":
                        print(Top,"\t", Op0 )
                    elif Top == "@MOV":
                        Op1 = MatchedStack.pop()
                        print(Top,"\t", Op1, ", ", Op0 )
                    else:
                        pass
                        Op1 = MatchedStack.pop()
                        MatchedStack.append("t" + str(TempCounter))
                        print(Top, "\t", "t"+ str(TempCounter), ", ", Op1, ",", Op0 )
                        TempCounter += 1

                Stack.pop()

            else: # Terminal 
                
                CurrentIn = Tokens[0]
                if (len(Tokens) > 1):
                    Tokens = Tokens[1:]
                Stack.pop()

        return MatchedStack

    
                 

            
    def ReadGrammar(self):
        Flag = 1
        Counter = -1
        for Line in self.GrammarFile:
            Counter += 1
            Line = Line.strip()
            if Line == "" or Line[0] == "#":
                continue
            elif Line[0] == ".":
                L = Line.split("->")
                Elements = L[1].split(" ")
                if L[0][1:] == "OperatorsTwoOperand":
                    self.OperatorsTwoOperand += Elements
                    continue
                elif L[0][1:] == "OperatorsOneOperand":
                    self.OperatorsOneOperand += Elements
                    continue
                elif L[0][1:] == "SemantiRules":
                    self.SemantiRulesList += Elements
                    continue
                elif L[0][1:] == "Registers":
                    self.RegistersList += Elements
                    continue
                elif L[0][1:] == "PseudoRegisters":
                    self.PseudoRegistersList += Elements
                    continue
                elif L[0][1:] == "ScriptVariableType":
                    self.VariableTypeList += Elements
                    continue
                elif L[0][1:] == "AssignmentOperator":
                    self.AssignmentOperator += Elements
                    continue

                self.FunctionsDict[L[0]] = Elements
                continue

            L = Line.split("->", 1)
            Lhs = L[0]
            Rhs = L[1].split(" ")

            HasMapKeyword = False
            MapKeywordIdx1 = 0
            MapKeywordIdx2 = 0
            Idx = 0
            for X in Rhs:
                if X and X[0] == "." and X in self.FunctionsDict:
                    HasMapKeyword = True
                    MapKeywordIdx1 = Idx 
                elif X[0] == "@":
                    if X[1] == ".":
                        MapKeywordIdx2 = Idx
                   

                Idx += 1

            if not HasMapKeyword:
                self.NonTerminalSet.add(Lhs)
                self.LhsList.append(Lhs)
                self.RhsList.append(Rhs)
                for X in Rhs:
                    if not self.IsNoneTerminal(X) and not self.IsSemanticRule(X) and not X=="eps":
                        self.TerminalSet.add(X)
                    if self.IsSemanticRule(X):
                        pass
            
            else:
             
                for value in self.FunctionsDict[Rhs[MapKeywordIdx1]]:
                    RhsTemp =list(Rhs)
                    RhsTemp[MapKeywordIdx1] = value
                    RhsTemp[MapKeywordIdx2] = "@" + value.upper()

                    self.keywordList.append(value)

                    self.NonTerminalSet.add(Lhs)
                    self.LhsList.append(Lhs)
                    self.RhsList.append(RhsTemp)

                    for X in RhsTemp:
                        if not self.IsNoneTerminal(X) and not self.IsSemanticRule(X) and not X=="eps":
                            self.TerminalSet.add(X)
                
            if Flag:
                Flag = 0
                self.Start = Lhs
            self.MAXIMUM_RHS_LEN = max(self.MAXIMUM_RHS_LEN, len(Rhs))

           

        self.TerminalSet.add("$")
        
        self.NonTerminalList = sorted(self.NonTerminalSet)
        
        self.TerminalList = sorted(self.TerminalSet)

        
    def WriteSemanticMaps(self):
        # Serialized script buffers contain FUNC_* values.  Keep every legacy
        # value stable and append aggregate-language additions after them.
        aggregate_semantics = {
            "struct_forward_declaration", "struct_definition_begin",
            "struct_definition_end", "struct_variable_declaration",
            "struct_member_declaration", "typedef_declaration",
            "struct_pointer", "struct_array_dimension",
            "struct_declarator_complete", "typed_load", "typed_store",
            "aggregate_copy", "aggregate_zero"
            , "struct_initializer_begin", "struct_initializer_end",
            "struct_pointer_cast", "member_address", "member_read",
            "member_dot_lvalue", "member_arrow_lvalue", "member_dot_read", "member_arrow_read",
            "mov_float", "neg_float", "add_float", "sub_float", "mul_float", "div_float",
            "gt_float", "lt_float", "egt_float", "elt_float", "equal_float", "neq_float",
            "convert_float"
        }
        aggregate_keywords = {"struct", "typedef"}
        append_only_semantics = [
            "cast_scalar",
            "add_typed", "sub_typed", "mul_typed", "div_typed", "mod_typed",
            "bitwise_and_typed", "bitwise_or_typed", "bitwise_xor_typed",
            "shift_left_typed", "shift_right_typed",
            "gt_typed", "lt_typed", "egt_typed", "elt_typed", "equal_typed", "neq_typed",
            "neg_typed", "bitwise_not_typed", "logical_not_typed", "pointer_diff",
            "push_aggregate"
        ]
        compiler_only_semantics = {
            "type_name_begin", "sizeof_begin", "sizeof_type", "sizeof_expression",
            "logical_or_begin", "logical_or_end", "logical_and_begin", "logical_and_end",
            "function_parameter_struct_base", "function_parameter_pointer_to_array",
            "function_parameter_array_dimension", "function_parameter_empty_array_dimension",
            "member_dot_array_read", "member_arrow_array_read"
        }
        legacy_semantics = [x for x in self.SemantiRulesList if x not in aggregate_semantics and x not in append_only_semantics and x not in compiler_only_semantics]
        new_semantics = [x for x in self.SemantiRulesList if x in aggregate_semantics]
        legacy_keywords = [x for x in self.keywordList if x not in aggregate_keywords]
        new_keywords = [x for x in self.keywordList if x in aggregate_keywords]
        numbered_semantics = legacy_semantics + legacy_keywords + new_semantics + new_keywords + append_only_semantics
        
        self.CommonHeaderFileScala.write("object ScriptEvalFunc {\n  object ScriptOperators extends ChiselEnum {\n    val ")
        
        Counter = 0
        CheckForDuplicateList = []
        
        self.CommonHeaderFile.write("#define " + "FUNC_UNDEFINED " + str(Counter) + "\n")
        self.CommonHeaderFileScala.write("sFunc" + "Undefined")
        Counter += 1
        
        for X in self.OperatorsOneOperand:
        
            if X not in CheckForDuplicateList:
                self.CommonHeaderFile.write("#define " + "FUNC_" + X.upper() + " " + str(Counter) + "\n")
                self.CommonHeaderFileScala.write(", sFunc" + X.capitalize())
                    
                CheckForDuplicateList.append(X)
                Counter += 1

        for X in self.OperatorsTwoOperand:
        
            if X not in CheckForDuplicateList:
                self.CommonHeaderFile.write("#define " + "FUNC_" + X.upper() + " " + str(Counter) + "\n")
                self.CommonHeaderFileScala.write(", sFunc" + X.capitalize())
                CheckForDuplicateList.append(X)
                Counter += 1
        
        for X in numbered_semantics:
            if X not in CheckForDuplicateList:
                self.CommonHeaderFile.write("#define " + "FUNC_" + X.upper() + " " + str(Counter) + "\n")
                self.CommonHeaderFileScala.write(", sFunc" + X.capitalize() + "")
                CheckForDuplicateList.append(X)
                Counter += 1
                
            
        self.CommonHeaderFileScala.write(" = Value\n  }\n} ")


        self.SourceFile.write("const SYMBOL_MAP SemanticRulesMapList[]= {\n")
        self.HeaderFile.write("extern const SYMBOL_MAP SemanticRulesMapList[];\n")

        for X in self.OperatorsOneOperand:
            self.SourceFile.write("{\"@" + X.upper() + "\", "+ "FUNC_" + X.upper()   + "},\n")

        for X in self.OperatorsTwoOperand:
            self.SourceFile.write("{\"@" + X.upper() + "\", "+ "FUNC_" + X.upper()   + "},\n")

        for X in self.SemantiRulesList:
            if X in compiler_only_semantics:
                self.SourceFile.write("{\"@" + X.upper() + "\", FUNC_UNDEFINED},\n")
            else:
                self.SourceFile.write("{\"@" + X.upper() + "\", "+ "FUNC_" + X.upper()   + "},\n")

        for X in self.keywordList:
                self.SourceFile.write("{\"@" + X.upper() + "\", "+ "FUNC_" + X.upper()   + "},\n")

        for X in self.AssignmentOperator:
            self.SourceFile.write("{\"@" + X.upper() + "\", "+ "FUNC_" + X.upper().replace("_ASSIGNMENT", "")   + "},\n")

        self.SourceFile.write("};\n")

        CheckForDuplicateList = []
        self.CommonHeaderFile.write("\nstatic const char *const FunctionNames[] = {")
        self.CommonHeaderFile.write("\n\"FUNC_UNDEFINED\""+ ",\n")
        for X in self.OperatorsOneOperand:
            if X not in CheckForDuplicateList:
                self.CommonHeaderFile.write("\"" + "FUNC_" + X.upper() + "\"" + ",\n")
                CheckForDuplicateList.append(X)

        for X in self.OperatorsTwoOperand:
            if X not in CheckForDuplicateList:
                self.CommonHeaderFile.write("\"" + "FUNC_" + X.upper() + "\"" + ",\n")
                CheckForDuplicateList.append(X)
    
        for X in numbered_semantics:
            if X not in CheckForDuplicateList:
                self.CommonHeaderFile.write("\"" + "FUNC_" + X.upper() + "\"" + ",\n")
                CheckForDuplicateList.append(X)

        self.CommonHeaderFile.write("};\n")


    def WriteRegisterMaps(self):
        self.CommonHeaderFile.write("\ntypedef enum REGS_ENUM {\n")
        Counter = 0          
        for X in self.RegistersList:
            if Counter == len(self.RegistersList)-1:
                self.CommonHeaderFile.write("\t" + "REGISTER_" + X.upper() + " = " + str(Counter) + "\n")
            else:
                self.CommonHeaderFile.write("\t" + "REGISTER_" + X.upper() + " = " + str(Counter) + ",\n")
            Counter += 1
        self.CommonHeaderFile.write("\n} REGS_ENUM;\n\n")

        self.CommonHeaderFile.write("static const char *const RegistersNames[] = {\n")
        Counter = 0 
        for X in self.RegistersList:
            if Counter == len(self.RegistersList)-1:
                self.CommonHeaderFile.write("\t" + "\"" + X + "\"")
            else:
                if (Counter + 1) % 8 == 0:
                    self.CommonHeaderFile.write("" + "\"" + X + "\",\n")
                else:
                    self.CommonHeaderFile.write("" + "\"" + X + "\", ")

            Counter += 1
        self.CommonHeaderFile.write("\n};\n\n")




        self.SourceFile.write("const SYMBOL_MAP RegisterMapList[]= {\n")
        self.HeaderFile.write("extern const SYMBOL_MAP RegisterMapList[];\n")

        Counter = 0
        for X in self.RegistersList:
            if Counter == len(self.RegistersList)-1:
                self.SourceFile.write("{\"" + X + "\", "+ "REGISTER_" + X.upper()   + "}\n")
            else:
                self.SourceFile.write("{\"" + X + "\", "+ "REGISTER_" + X.upper()   + "},\n")
            Counter +=1
        self.SourceFile.write("};\n")


    def WritePseudoRegMaps(self):
        Counter = 0          
        for X in self.PseudoRegistersList:
            self.CommonHeaderFile.write("#define " + "PSEUDO_REGISTER_" + X.upper() + " " + str(Counter) + "\n")
            Counter += 1
        self.CommonHeaderFile.write("\n")

        self.SourceFile.write("const SYMBOL_MAP PseudoRegisterMapList[]= {\n")
        self.HeaderFile.write("extern const SYMBOL_MAP PseudoRegisterMapList[];\n")

        Counter = 0
        for X in self.PseudoRegistersList:
            if Counter == len(self.PseudoRegistersList)-1:
                self.SourceFile.write("{\"" + X + "\", "+ "PSEUDO_REGISTER_" + X.upper()   + "}\n")
            else:
                self.SourceFile.write("{\"" + X + "\", "+ "PSEUDO_REGISTER_" + X.upper()   + "},\n")
            Counter +=1
        self.SourceFile.write("};\n")

    def WriteVariableTypeList(self):
        self.SourceFile.write("const char* ScriptVariableTypeList[]= {\n")
        self.HeaderFile.write("extern const char* ScriptVariableTypeList[];\n")

        Counter = 0
        for X in self.VariableTypeList:
            if Counter == len(self.VariableTypeList)-1:
                self.SourceFile.write("\"" + X + "\""   + "\n")
            else:
                self.SourceFile.write("\"" + X + "\""  + ",\n")
            Counter +=1
        self.SourceFile.write("};\n")

    def WriteKeywordList(self):
        self.SourceFile.write("const char* KeywordList[]= {\n")
        self.HeaderFile.write("extern const char* KeywordList[];\n")

        Counter = 0
        for X in self.keywordList:
            if Counter == len(self.keywordList)-1:
                self.SourceFile.write("\"" + X + "\"" + "\n")
            else:
                self.SourceFile.write("\"" + X + "\"" + ",\n")
            Counter +=1
        self.SourceFile.write("};\n")

    def WriteOperatorsList(self):
        self.SourceFile.write("const char* OperatorsTwoOperandList[]= {\n")
        self.HeaderFile.write("extern const char* OperatorsTwoOperandList[];\n")

        Counter = 0
        for X in self.OperatorsTwoOperand:
            if Counter == len(self.OperatorsTwoOperand)-1:
                self.SourceFile.write("\"" + "@"+ X.upper() + "\"" + "\n")
            else:
                self.SourceFile.write("\"" + "@"+ X.upper() + "\"" + ",\n")
            Counter +=1
        self.SourceFile.write("};\n")

        self.SourceFile.write("const char* OperatorsOneOperandList[]= {\n")
        self.HeaderFile.write("extern const char* OperatorsOneOperandList[];\n")

        Counter = 0
        for X in self.OperatorsOneOperand:
            if Counter == len(self.OperatorsOneOperand)-1:
                self.SourceFile.write("\"" + "@"+ X.upper() + "\"" + "\n")
            else:
                self.SourceFile.write("\"" + "@"+ X.upper() + "\"" + ",\n")
            Counter +=1
        self.SourceFile.write("};\n")

        self.SourceFile.write("const char* AssignmentOperatorList[]= {\n")
        self.HeaderFile.write("extern const char* AssignmentOperatorList[];\n")

        Counter = 0
        for X in self.AssignmentOperator:
            if Counter == len(self.AssignmentOperator)-1:
                self.SourceFile.write("\"" + "@"+ X.upper() + "\"" + "\n")
            else:
                self.SourceFile.write("\"" + "@"+ X.upper() + "\"" + ",\n")
            Counter +=1
        self.SourceFile.write("};\n")        

     

    def WriteMaps(self):
        for Key in self.FunctionsDict:
            print(Key)

            self.HeaderFile.write("extern const char* "+ Key[1:]+ "[];\n")
            self.SourceFile.write("const char* "+ Key[1:]+ "[] = {\n")

            Counter = 0
            for X in self.FunctionsDict[Key]:
                if Counter == len(self.FunctionsDict[Key])-1:
                    self.SourceFile.write("\"" + "@"+ X.upper() + "\"" + "\n")
                else:
                    self.SourceFile.write("\"" +"@"+ X.upper() + "\"" + ",\n")
            Counter +=1
            self.SourceFile.write("};\n")



    def WriteLhsList(self):

        self.SourceFile.write("const struct _SCRIPT_ENGINE_TOKEN Lhs[RULES_COUNT]= \n{\n")
        self.HeaderFile.write("extern const struct _SCRIPT_ENGINE_TOKEN Lhs[RULES_COUNT];\n")
        Counter = 0
        for Lhs in self.LhsList:
            if Counter == len(self.LhsList)-1:
                self.SourceFile.write("\t{NON_TERMINAL, " + "\"" + Lhs + "\"}" + "\n")
            else:
                self.SourceFile.write("\t{NON_TERMINAL, " + "\"" + Lhs + "\"}" + ",\n")
            Counter +=1
        self.SourceFile.write("};\n")

    def GetType(self,Var):
        if self.IsNoneTerminal(Var):
            return "NON_TERMINAL"
        elif self.IsSemanticRule(Var):
            return "SEMANTIC_RULE"

        elif Var == "eps":
            return "EPSILON"

        elif Var in self.SPECIAL_TOKENS:
            return "SPECIAL_TOKEN"
        elif Var == "_float":
            return "FLOAT_LITERAL"
        elif Var[0] == "_":
            return Var[1:].upper()
        else:
            return "KEYWORD"


    def WriteRhsList(self):
        self.SourceFile.write("const struct _SCRIPT_ENGINE_TOKEN Rhs[RULES_COUNT][MAX_RHS_LEN]= \n{\n")
        self.HeaderFile.write("extern const struct _SCRIPT_ENGINE_TOKEN Rhs[RULES_COUNT][MAX_RHS_LEN];\n")
        Counter =0
        for Rhs in self.RhsList:
            self.SourceFile.write("\t{")

            C = 0
            for Var in Rhs:
                if C == len(Rhs) -1:
                    self.SourceFile.write("{"+self.GetType(Var) +", "+"\"" + Var + "\"}" )
                else:
                    self.SourceFile.write("{"+self.GetType(Var) +", "+"\"" + Var + "\"}," )
                C += 1

            if Counter == len(self.RhsList)-1:
                self.SourceFile.write("}\n")
            else:
                self.SourceFile.write("},\n")
            Counter+= 1

        self.SourceFile.write("};\n")

    def WriteRhsSize(self):
        self.SourceFile.write("const unsigned int RhsSize[RULES_COUNT]= \n{\n")
        self.HeaderFile.write("extern const unsigned int RhsSize[RULES_COUNT];\n")
        Counter =0
        for Rhs in self.RhsList:            
            if Counter == len(self.RhsList)-1:
               self.SourceFile.write( str(len(Rhs)) + "\n" )
            else:
                self.SourceFile.write( str(len(Rhs)) + ",\n" )
            Counter+= 1

        self.SourceFile.write("};\n")

    def WriteTerminalList(self):
        self.SourceFile.write("const char* TerminalMap[TERMINAL_COUNT]= \n{\n")
        self.HeaderFile.write("extern const char* TerminalMap[TERMINAL_COUNT];\n")
        Counter = 0
        for X in self.TerminalList:
            if Counter == len(self.TerminalList)-1:
                self.SourceFile.write("\"" + X + "\"" + "\n")
            else:
                self.SourceFile.write("\"" + X + "\"" + ",\n")
            Counter +=1
        self.SourceFile.write("};\n")

    def WriteNoneTermianlList(self):
        self.SourceFile.write("const char* NoneTerminalMap[NONETERMINAL_COUNT]= \n{\n")
        self.HeaderFile.write("extern const char* NoneTerminalMap[NONETERMINAL_COUNT];\n")
        Counter = 0
        for X in self.NonTerminalList:
            if Counter == len(self.NonTerminalList)-1:
                self.SourceFile.write("\"" + X + "\"" + "\n")
            else:
                self.SourceFile.write("\"" + X + "\"" + ",\n")
            Counter +=1
        self.SourceFile.write("};\n")

    def WriteParseTable(self):
        self.SourceFile.write("const int ParseTable[NONETERMINAL_COUNT][TERMINAL_COUNT]= \n{\n")
        self.HeaderFile.write("extern const int ParseTable[NONETERMINAL_COUNT][TERMINAL_COUNT];\n")
        i = 0
        for X in self.NonTerminalList:
            j = 0
            self.SourceFile.write("\t{")
            for y in self.TerminalList:
                self.SourceFile.write(str(self.ParseTable[i][j]))
                if j != len(self.TerminalList)-1:
                    self.SourceFile.write("\t\t,")
                j += 1

            if i == len(self.NonTerminalList)-1:
                self.SourceFile.write("\t}\n")

            else:
                self.SourceFile.write("\t},\n")
            i +=1
        self.SourceFile.write("};\n")
        


    def FindAllFirsts(self):
        
        self.FirstDict = {}
        for Symbol in self.NonTerminalList:
            self.FirstDict[Symbol] = set()

        t = 0 
        while True:
            Updated = False 
            i = 0 
            for Lhs in self.LhsList:
                Rhs = self.RhsList[i]
                Temp = set(self.FirstDict[Lhs])

                
                if Rhs[0] == "eps":
                    pass
                elif self.IsNoneTerminal(Rhs[0]):
                    self.FirstDict[Lhs] = self.FirstDict[Lhs].union(self.FirstDict[Rhs[0]])
                    p = 0
                    while self.IsNullable(Rhs[p]):
                        self.FirstDict[Lhs] = self.FirstDict[Lhs].union(self.FirstDict[Rhs[p+1]])
                        p += 1
                elif self.IsSemanticRule(Rhs[0]):
                    if self.IsNoneTerminal(Rhs[0]):
                        self.FirstDict[Lhs] = self.FirstDict[Lhs].union(self.FirstDict[Rhs[1]])
                    else: 
                        self.FirstDict[Lhs].add(Rhs[1])
                else:
                    self.FirstDict[Lhs].add(Rhs[0])
                i += 1
               
                if Temp != self.FirstDict[Lhs]:
                    Updated = True
            p += 1  
            if not Updated:
                break;    
            


    def PrintFirsts(self):
        for Id in self.FirstDict:
            print(Id, end=": ")
            for X in self.FirstDict[Id]:
                print(X,end = " ")
            print()

    def GetNoneTerminalId(self, nonterminal):
        for i in range(len(self.NonTerminalList)):
            if nonterminal == self.NonTerminalList[i]:
                return i
        return -1

    def GetTerminalId(self, Terminal):
        for i in range(len(self.TerminalList)):
            if Terminal == self.TerminalList[i]:
                return i
        return -1


    def FillParseTable(self):
        self.ParseTable = [[self.INVALID for y in range(len(self.TerminalList))] for X in range(len(self.NonTerminalList))]

        RuleId = 0 
        for Lhs in self.LhsList:
            i = self.GetNoneTerminalId(Lhs)

            j = 0
            for Terminal in self.TerminalList:
                if Terminal in self.PredictDict[RuleId]:
                    if i ==34 and j ==3:
                        dccc=3

                    if self.ParseTable[i][j] == self.INVALID:
                        self.ParseTable[i][j] = RuleId

                    else:
                        print("Error! Input grammar is not LL1: " + Lhs +
                              " on " + Terminal + " conflicts between rules " +
                              str(self.ParseTable[i][j]) + " and " + str(RuleId) + ".")
                        exit()

                j += 1

            RuleId += 1

    def PrintParseTable(self):
        print("\t", end = "")
        for j in range(len(self.TerminalList)):
            print(self.TerminalList[j], end= "\t")
        print()
        for i in range(len(self.NonTerminalList)):
            print(self.NonTerminalList[i], end= "\t")
            for j in range(len(self.TerminalList)):
                if self.ParseTable[i][j] == self.INVALID:
                    print(".", end= "\t")
                else:
                    print(self.ParseTable[i][j], end= "\t")
            print()
                

    def FindAllPredicts(self):
        self.PredictDict = {}
        for i in range(len(self.LhsList)):
            self.PredictDict[i] = set()

        i = 0
        for Lhs in self.LhsList:
            Rhs = self.RhsList[i]
            IsRightNullable = True
            for Symbol in Rhs:
                if self.IsSemanticRule(Symbol):
                    pass
                
                elif Symbol == "eps":
                    IsRightNullable = True
                    break
                elif self.IsNoneTerminal(Symbol):
                    self.PredictDict[i] |= self.FirstDict[Symbol]
                    if not self.IsNullable(Symbol):
                        IsRightNullable = False
                        break
                else:
                    self.PredictDict[i].add(Symbol)
                    IsRightNullable = False
                    break
            
            if IsRightNullable:
                self.PredictDict[i] |= self.FollowDict[Lhs]
            i += 1
               

    def print_predicts(self):
        for Key in self.PredictDict:
            print(Key, end=": ")
            for X in self.PredictDict[Key]:
                print(X,end = " ")
            print()


    
    def FindAllFollows(self):
        self.FollowDict = {}
        for Symbol in self.NonTerminalList:
            self.FollowDict[Symbol] = set()
            if Symbol == self.Start:
                self.FollowDict[Symbol].add('$')

        t = 0
        while True: 
            Updated = False 

            i = 0
            for Lhs in self.LhsList:
                Rhs = self.RhsList[i]

                p = 0
                for Symbol in Rhs:
                    
                    if self.IsNoneTerminal(Symbol):
                        
                        Temp = set(self.FollowDict[Symbol])
                        if p == len(Rhs)-1:
                            self.FollowDict[Symbol] = self.FollowDict[Symbol].union(self.FollowDict[Lhs])
                        
                        
                        
                        else:

                            NextVar = self.GetNextVar(Rhs, p)
                            if self.IsNoneTerminal(NextVar):
                                self.FollowDict[Symbol] = self.FollowDict[Symbol].union(self.FirstDict[NextVar])
                                if self.IsNullable(NextVar):    
                                    self.FollowDict[Symbol] = self.FollowDict[Symbol].union(self.FollowDict[NextVar])                                    
                            elif self.IsSemanticRule(NextVar):
                                pass      
                            else:
                                self.FollowDict[Symbol].add(NextVar)
                        
                        if p == len(Rhs)-2:
                            NextVar = self.GetNextVar(Rhs, p)
                            
                            if self.IsNullable(NextVar):
                                self.FollowDict[Symbol] = self.FollowDict[Symbol].union(self.FollowDict[Lhs])
                                self.FollowDict[Lhs] = self.FollowDict[Lhs].union(self.FollowDict[NextVar])
                        
                   

                        if Temp != self.FollowDict[Symbol]:
                            Updated = True
                    p += 1  
                i += 1
            t += 1

            if not Updated: 
                break
    def GetNextVar(self, Rhs, p):
        if p == len(Rhs)-1:
            return None
        
        X = p +1
        while self.IsSemanticRule(Rhs[X]) and X + 1 < len(Rhs):
            X+=1
        return Rhs[X]
        
    def PrintFollows(self):
        for Key in self.FollowDict:
            print(Key, end=": ")
            for X in self.FollowDict[Key]:
                print(X,end = " ")
            print()

    def IsNoneTerminal(self,X):     
        if X[0].isupper():
            return True
        else:
            return False

    def IsSemanticRule(self, X):
        if X[0] == '@':
            return True
        else: 
            return False

    def IsNullable(self, s):

        if not s[0].isupper():
            return False
        i = 0 
        for Lhs in self.LhsList:
            Rhs = self.RhsList[i]
            
            if Lhs == s:

                if Rhs[0] == "eps":
                    return True

                p = 0 
                while True:
                    if self.IsNullable(Rhs[p]):
                        return True
                    else:
                        break
                    p += 1
            i +=1
                    
        return False