HyperDbg Debugger
Loading...
Searching...
No Matches
ll1_parser.LL1Parser Class Reference

Public Member Functions

 __init__ (self, SourceFile, HeaderFile, CommonHeaderFile, CommonHeaderFileScala)
 Run (self)
 SetLalr (self, Lalr, LalrParseTable)
 Parse (self, Tokens)
 ReadGrammar (self)
 WriteSemanticMaps (self)
 WriteRegisterMaps (self)
 WritePseudoRegMaps (self)
 WriteVariableTypeList (self)
 WriteKeywordList (self)
 WriteOperatorsList (self)
 WriteMaps (self)
 WriteLhsList (self)
 GetType (self, Var)
 WriteRhsList (self)
 WriteRhsSize (self)
 WriteTerminalList (self)
 WriteNoneTermianlList (self)
 WriteParseTable (self)
 FindAllFirsts (self)
 PrintFirsts (self)
 GetNoneTerminalId (self, nonterminal)
 GetTerminalId (self, Terminal)
 FillParseTable (self)
 PrintParseTable (self)
 FindAllPredicts (self)
 print_predicts (self)
 FindAllFollows (self)
 GetNextVar (self, Rhs, p)
 PrintFollows (self)
 IsNoneTerminal (self, X)
 IsSemanticRule (self, X)
 IsNullable (self, s)

Public Attributes

 GrammarFile = open("Grammar.txt", "r")
 SourceFile = SourceFile
 HeaderFile = HeaderFile
 CommonHeaderFile = CommonHeaderFile
 CommonHeaderFileScala = CommonHeaderFileScala
list RhsList = []
list LhsList = []
 TerminalSet = set()
 NonTerminalSet = set()
str Start = ""
int MAXIMUM_RHS_LEN = 0
list SPECIAL_TOKENS
int INVALID = 0x80000000
 FunctionsDict = dict()
list OperatorsTwoOperand = []
list OperatorsOneOperand = []
list RegistersList = []
list PseudoRegistersList = []
list VariableTypeList = []
list keywordList = []
list SemantiRulesList = []
list AssignmentOperator = []
dict FirstDict = dict()
dict FollowDict = dict()
 NonTerminalList
 Lalr = Lalr
 LalrParseTable = LalrParseTable
 TerminalList = list(self.TerminalSet)
list ParseTable = [[self.INVALID for y in range(len(self.TerminalList))] for X in range(len(self.NonTerminalList))]
dict PredictDict = {}

Constructor & Destructor Documentation

◆ __init__()

ll1_parser.LL1Parser.__init__ ( self,
SourceFile,
HeaderFile,
CommonHeaderFile,
CommonHeaderFileScala )
21 def __init__(self, SourceFile, HeaderFile, CommonHeaderFile, CommonHeaderFileScala):
22 # The file which contains the grammar of the language
23 self.GrammarFile = open("Grammar.txt", "r")
24
25 # The file which is used by parser for parsing the input
26 self.SourceFile = SourceFile
27 self.HeaderFile = HeaderFile
28 self.CommonHeaderFile = CommonHeaderFile
29 self.CommonHeaderFileScala = CommonHeaderFileScala
30
31
32 # Lists which used for storing the rules:
33 # Right Hand Side(Rhs)
34 self.RhsList = []
35
36 # Left Hand Side(Lhs)
37 self.LhsList = []
38
39 # Set of all terminals and noneterminals
40 self.TerminalSet = set()
41 self.NonTerminalSet = set()
42
43 # Start variable
44 self.Start = ""
45
46
47 # maximum of "Right Hand Side(Rhs)" length
48 self.MAXIMUM_RHS_LEN = 0
49
50
51 self.SPECIAL_TOKENS = ['%', '+', '~', '++', '-', '--', "*", "/", "=", "==", "!=", ",", ";", "(", ")", "{", "}", "|", "||", ">>", ">=", "<<", "<=", "&", "&&", "^",
52 "+=", "-=", "*=", "/=", "%=", "<<=", ">>=", "&=", "^=", "|=" , "[", "]"]
53
54 # INVALID rule indicator
55 self.INVALID = 0x80000000
56
57 self.FunctionsDict = dict()
58 self.OperatorsTwoOperand = []
59 self.OperatorsOneOperand = []
60 self.RegistersList = []
61 self.PseudoRegistersList = []
62 self.VariableTypeList = []
63 self.keywordList = []
64 self.SemantiRulesList = []
65 self.AssignmentOperator = []
66
67
68 # Dictionaries used for storing first and follow sets
69 self.FirstDict = dict()
70 self.FollowDict = dict()
71
72
73
set
set(SourceFiles "header/core/Core.h" "header/driver/Driver.h" "header/driver/Loader.h" "header/misc/Global.h" "header/pch.h" "code/core/Core.c" "code/driver/Driver.c" "code/driver/Ioctl.c" "code/driver/Loader.c") include_directories("../../../hyperdbg/include" "header") wdk_add_driver(hyperdbg_driver KMDF 1.15 $
Definition CMakeLists.txt:2

Member Function Documentation

◆ FillParseTable()

ll1_parser.LL1Parser.FillParseTable ( self)
853 def FillParseTable(self):
854 self.ParseTable = [[self.INVALID for y in range(len(self.TerminalList))] for X in range(len(self.NonTerminalList))]
855
856 RuleId = 0
857 for Lhs in self.LhsList:
858 i = self.GetNoneTerminalId(Lhs)
859
860 j = 0
861 for Terminal in self.TerminalList:
862 if Terminal in self.PredictDict[RuleId]:
863 if i ==34 and j ==3:
864 dccc=3
865
866 if self.ParseTable[i][j] == self.INVALID:
867 self.ParseTable[i][j] = RuleId
868
869 else:
870
871 print("Error! Input grammar is not LL1.")
872 exit()
873
874 j += 1
875
876 RuleId += 1
877

◆ FindAllFirsts()

ll1_parser.LL1Parser.FindAllFirsts ( self)
793 def FindAllFirsts(self):
794
795 self.FirstDict = {}
796 for Symbol in self.NonTerminalList:
797 self.FirstDict[Symbol] = set()
798
799 t = 0
800 while True:
801 Updated = False
802 i = 0
803 for Lhs in self.LhsList:
804 Rhs = self.RhsList[i]
805 Temp = set(self.FirstDict[Lhs])
806
807
808 if Rhs[0] == "eps":
809 pass
810 elif self.IsNoneTerminal(Rhs[0]):
811 self.FirstDict[Lhs] = self.FirstDict[Lhs].union(self.FirstDict[Rhs[0]])
812 p = 0
813 while self.IsNullable(Rhs[p]):
814 self.FirstDict[Lhs] = self.FirstDict[Lhs].union(self.FirstDict[Rhs[p+1]])
815 p += 1
816 elif self.IsSemanticRule(Rhs[0]):
817 if self.IsNoneTerminal(Rhs[0]):
818 self.FirstDict[Lhs] = self.FirstDict[Lhs].union(self.FirstDict[Rhs[1]])
819 else:
820 self.FirstDict[Lhs].add(Rhs[1])
821 else:
822 self.FirstDict[Lhs].add(Rhs[0])
823 i += 1
824
825 if Temp != self.FirstDict[Lhs]:
826 Updated = True
827 p += 1
828 if not Updated:
829 break;
830
831
832

◆ FindAllFollows()

ll1_parser.LL1Parser.FindAllFollows ( self)
933 def FindAllFollows(self):
934 self.FollowDict = {}
935 for Symbol in self.NonTerminalList:
936 self.FollowDict[Symbol] = set()
937 if Symbol == self.Start:
938 self.FollowDict[Symbol].add('$')
939
940 t = 0
941 while True:
942 Updated = False
943
944 i = 0
945 for Lhs in self.LhsList:
946 Rhs = self.RhsList[i]
947
948 p = 0
949 for Symbol in Rhs:
950
951 if self.IsNoneTerminal(Symbol):
952
953 Temp = set(self.FollowDict[Symbol])
954 if p == len(Rhs)-1:
955 self.FollowDict[Symbol] = self.FollowDict[Symbol].union(self.FollowDict[Lhs])
956
957
958
959 else:
960
961 NextVar = self.GetNextVar(Rhs, p)
962 if self.IsNoneTerminal(NextVar):
963 self.FollowDict[Symbol] = self.FollowDict[Symbol].union(self.FirstDict[NextVar])
964 if self.IsNullable(NextVar):
965 self.FollowDict[Symbol] = self.FollowDict[Symbol].union(self.FollowDict[NextVar])
966 elif self.IsSemanticRule(NextVar):
967 pass
968 else:
969 self.FollowDict[Symbol].add(NextVar)
970
971 if p == len(Rhs)-2:
972 NextVar = self.GetNextVar(Rhs, p)
973
974 if self.IsNullable(NextVar):
975 self.FollowDict[Symbol] = self.FollowDict[Symbol].union(self.FollowDict[Lhs])
976 self.FollowDict[Lhs] = self.FollowDict[Lhs].union(self.FollowDict[NextVar])
977
978
979
980 if Temp != self.FollowDict[Symbol]:
981 Updated = True
982 p += 1
983 i += 1
984 t += 1
985
986 if not Updated:
987 break

◆ FindAllPredicts()

ll1_parser.LL1Parser.FindAllPredicts ( self)
893 def FindAllPredicts(self):
894 self.PredictDict = {}
895 for i in range(len(self.LhsList)):
896 self.PredictDict[i] = set()
897
898 i = 0
899 for Lhs in self.LhsList:
900 Rhs = self.RhsList[i]
901 IsRightNullable = True
902 for Symbol in Rhs:
903 if self.IsSemanticRule(Symbol):
904 pass
905
906 elif Symbol == "eps":
907 IsRightNullable = True
908 break
909 elif self.IsNoneTerminal(Symbol):
910 self.PredictDict[i] |= self.FirstDict[Symbol]
911 if not self.IsNullable(Symbol):
912 IsRightNullable = False
913 break
914 else:
915 self.PredictDict[i].add(Symbol)
916 IsRightNullable = False
917 break
918
919 if IsRightNullable:
920 self.PredictDict[i] |= self.FollowDict[Lhs]
921 i += 1
922
923

◆ GetNextVar()

ll1_parser.LL1Parser.GetNextVar ( self,
Rhs,
p )
988 def GetNextVar(self, Rhs, p):
989 if p == len(Rhs)-1:
990 return None
991
992 X = p +1
993 while self.IsSemanticRule(Rhs[X]) and X + 1 < len(Rhs):
994 X+=1
995 return Rhs[X]
996

◆ GetNoneTerminalId()

ll1_parser.LL1Parser.GetNoneTerminalId ( self,
nonterminal )
840 def GetNoneTerminalId(self, nonterminal):
841 for i in range(len(self.NonTerminalList)):
842 if nonterminal == self.NonTerminalList[i]:
843 return i
844 return -1
845

◆ GetTerminalId()

ll1_parser.LL1Parser.GetTerminalId ( self,
Terminal )
846 def GetTerminalId(self, Terminal):
847 for i in range(len(self.TerminalList)):
848 if Terminal == self.TerminalList[i]:
849 return i
850 return -1
851
852
GetTerminalId
int GetTerminalId(PSCRIPT_ENGINE_TOKEN Token)
Gets the Terminal Id object.
Definition common.c:1118

◆ GetType()

ll1_parser.LL1Parser.GetType ( self,
Var )
693 def GetType(self,Var):
694 if self.IsNoneTerminal(Var):
695 return "NON_TERMINAL"
696 elif self.IsSemanticRule(Var):
697 return "SEMANTIC_RULE"
698
699 elif Var == "eps":
700 return "EPSILON"
701
702 elif Var in self.SPECIAL_TOKENS:
703 return "SPECIAL_TOKEN"
704 elif Var[0] == "_":
705 return Var[1:].upper()
706 else:
707 return "KEYWORD"
708
709

◆ IsNoneTerminal()

ll1_parser.LL1Parser.IsNoneTerminal ( self,
X )
1004 def IsNoneTerminal(self,X):
1005 if X[0].isupper():
1006 return True
1007 else:
1008 return False
1009
IsNoneTerminal
char IsNoneTerminal(PSCRIPT_ENGINE_TOKEN Token)
Checks whether this Token is noneterminal NoneTerminal token starts with capital letter.
Definition common.c:1070

◆ IsNullable()

ll1_parser.LL1Parser.IsNullable ( self,
s )
1016 def IsNullable(self, s):
1017
1018 if not s[0].isupper():
1019 return False
1020 i = 0
1021 for Lhs in self.LhsList:
1022 Rhs = self.RhsList[i]
1023
1024 if Lhs == s:
1025
1026 if Rhs[0] == "eps":
1027 return True
1028
1029 p = 0
1030 while True:
1031 if self.IsNullable(Rhs[p]):
1032 return True
1033 else:
1034 break
1035 p += 1
1036 i +=1
1037
1038 return False

◆ IsSemanticRule()

ll1_parser.LL1Parser.IsSemanticRule ( self,
X )
1010 def IsSemanticRule(self, X):
1011 if X[0] == '@':
1012 return True
1013 else:
1014 return False
1015
IsSemanticRule
char IsSemanticRule(PSCRIPT_ENGINE_TOKEN Token)
Checks whether this Token is semantic rule SemanticRule token starts with '@'.
Definition common.c:1086

◆ Parse()

ll1_parser.LL1Parser.Parse ( self,
Tokens )
172 def Parse(self, Tokens):
173 # Initialize Parse Stack
174 Stack = []
175
176 # Initialize Match Stack
177 MatchedStack = []
178
179 # Push the end of stack indicator into stack
180 Stack.append("$")
181
182 # Push start variable into stack
183 Stack.append(self.Start)
184
185 # Assign top variable an invalid value
186 Top = ""
187
188 # Read input
189 Tokens, CurrentIn = Read(Tokens)
190
191 # Temporary values counter initialized with 0 value
192 TempCounter = 0
193
194 # While Stack is not empty repeat
195 while Top != "$":
196
197 # Read top of stack
198 Top = GetTop(Stack)
199 # print(Stack)
200 # print("Top:", Top)
201 # print("CurrentIn:", CurrentIn, "\n\n")
202 # x = input()
203
204
205
206 if self.IsNoneTerminal(Top):
207 if Top == "BOOLEAN_EXPRESSION":
208 print("Top == BOOLEAN_EXPRESSION:")
209 print(Stack)
210 print(Tokens)
211 print(CurrentIn)
212 print("=====================================\n\n")
213
214 Stack.pop()
215
216 #------------------------------------------------------
217 # Get BE Tokens
218 BETokensSize = 0
219 OpenParanthesesCount = 1
220
221 i = 0
222 while True:
223 TempToken = Tokens[i]
224
225 i +=1
226 if TempToken == '(' :
227 OpenParanthesesCount += 1
228 BETokensSize += 1
229 elif TempToken == ')':
230 OpenParanthesesCount -= 1
231 if OpenParanthesesCount == 0:
232 break
233 else:
234 BETokensSize +=1
235 else:
236 BETokensSize +=1
237 print("TempToken: ", end = "")
238 print(TempToken)
239 print("BETokensSize: ", end = "")
240 print(BETokensSize)
241
242
243 # BETokens.append("$end")
244 print("BETokensSize: ", end = "")
245 print(BETokensSize)
246 y = input()
247 NewTokens = [CurrentIn]
248 for x in Tokens:
249 NewTokens.append(x)
250 #------------------------------------------------------
251 Tokens = self.Lalr.Parse(NewTokens, BETokensSize + 1)
252 # x = input()
253 print("after lalr parsing:")
254 print(Stack)
255 print(Tokens)
256 print("=====================================\n\n")
257
258
259 CurrentIn = Tokens[0]
260 if (len(Tokens) > 1):
261 Tokens = Tokens[1:]
262 # x = input()
263 else:
264 Id = self.ParseTable[self.GetNoneTerminalId(Top)][self.GetTerminalId(CurrentIn)]
265
266 # Error Handling
267 if Id == -1:
268
269 print("1)Error in input!")
270 print(Tokens)
271 print(Stack)
272 print("Top: ", Top)
273 print("CurrentIn: ", CurrentIn)
274 print("\n\n")
275 exit()
276
277 Stack.pop()
278
279
280 Rhs = self.RhsList[Id]
281 if Rhs != ["eps"]:
282 for Symbol in reversed(Rhs):
283 Stack.append(Symbol)
284
285
286 elif self.IsSemanticRule(Top):
287 if Top == "@PUSH":
288 Stack.pop()
289 Top = GetTop(Stack)
290 if Top == CurrentIn:
291 MatchedStack.append(Top)
292 Tokens, CurrentIn = Read(Tokens)
293 else:
294 print("2)Error in input!")
295 exit()
296 elif Top == "@JZ":
297 print("JZ:")
298 print(Stack)
299 print(Tokens)
300 print("\n\n")
301 y = input()
302
303 elif Top == "@JZCMPL":
304 print("JZCOMPELETED:")
305 print(Stack)
306 print(Tokens)
307 print("\n\n")
308 y = input()
309
310
311
312
313 else:
314 Op0 = MatchedStack.pop()
315 if Top == "@PRINT":
316 print(Top,"\t", Op0 )
317 elif Top == "@MOV":
318 Op1 = MatchedStack.pop()
319 print(Top,"\t", Op1, ", ", Op0 )
320 else:
321 pass
322 Op1 = MatchedStack.pop()
323 MatchedStack.append("t" + str(TempCounter))
324 print(Top, "\t", "t"+ str(TempCounter), ", ", Op1, ",", Op0 )
325 TempCounter += 1
326
327 Stack.pop()
328
329 else: # Terminal
330
331 CurrentIn = Tokens[0]
332 if (len(Tokens) > 1):
333 Tokens = Tokens[1:]
334 Stack.pop()
335
336 return MatchedStack
337
338
339
340
341

◆ print_predicts()

ll1_parser.LL1Parser.print_predicts ( self)
924 def print_predicts(self):
925 for Key in self.PredictDict:
926 print(Key, end=": ")
927 for X in self.PredictDict[Key]:
928 print(X,end = " ")
929 print()
930
931
932

◆ PrintFirsts()

ll1_parser.LL1Parser.PrintFirsts ( self)
833 def PrintFirsts(self):
834 for Id in self.FirstDict:
835 print(Id, end=": ")
836 for X in self.FirstDict[Id]:
837 print(X,end = " ")
838 print()
839

◆ PrintFollows()

ll1_parser.LL1Parser.PrintFollows ( self)
997 def PrintFollows(self):
998 for Key in self.FollowDict:
999 print(Key, end=": ")
1000 for X in self.FollowDict[Key]:
1001 print(X,end = " ")
1002 print()
1003

◆ PrintParseTable()

ll1_parser.LL1Parser.PrintParseTable ( self)
878 def PrintParseTable(self):
879 print("\t", end = "")
880 for j in range(len(self.TerminalList)):
881 print(self.TerminalList[j], end= "\t")
882 print()
883 for i in range(len(self.NonTerminalList)):
884 print(self.NonTerminalList[i], end= "\t")
885 for j in range(len(self.TerminalList)):
886 if self.ParseTable[i][j] == self.INVALID:
887 print(".", end= "\t")
888 else:
889 print(self.ParseTable[i][j], end= "\t")
890 print()
891
892

◆ ReadGrammar()

ll1_parser.LL1Parser.ReadGrammar ( self)
342 def ReadGrammar(self):
343 Flag = 1
344 Counter = -1
345 for Line in self.GrammarFile:
346 Counter += 1
347 Line = Line.strip()
348 if Line == "" or Line[0] == "#":
349 continue
350 elif Line[0] == ".":
351 L = Line.split("->")
352 Elements = L[1].split(" ")
353 if L[0][1:] == "OperatorsTwoOperand":
354 self.OperatorsTwoOperand += Elements
355 continue
356 elif L[0][1:] == "OperatorsOneOperand":
357 self.OperatorsOneOperand += Elements
358 continue
359 elif L[0][1:] == "SemantiRules":
360 self.SemantiRulesList += Elements
361 continue
362 elif L[0][1:] == "Registers":
363 self.RegistersList += Elements
364 continue
365 elif L[0][1:] == "PseudoRegisters":
366 self.PseudoRegistersList += Elements
367 continue
368 elif L[0][1:] == "ScriptVariableType":
369 self.VariableTypeList += Elements
370 continue
371 elif L[0][1:] == "AssignmentOperator":
372 self.AssignmentOperator += Elements
373 continue
374
375 self.FunctionsDict[L[0]] = Elements
376 continue
377
378 L = Line.split("->")
379 Lhs = L[0]
380 Rhs = L[1].split(" ")
381
382 HasMapKeyword = False
383 MapKeywordIdx1 = 0
384 MapKeywordIdx2 = 0
385 Idx = 0
386 for X in Rhs:
387 if X[0] == ".":
388 HasMapKeyword = True
389 MapKeywordIdx1 = Idx
390 elif X[0] == "@":
391 if X[1] == ".":
392 MapKeywordIdx2 = Idx
393
394
395 Idx += 1
396
397 if not HasMapKeyword:
398 self.NonTerminalSet.add(Lhs)
399 self.LhsList.append(Lhs)
400 self.RhsList.append(Rhs)
401 for X in Rhs:
402 if not self.IsNoneTerminal(X) and not self.IsSemanticRule(X) and not X=="eps":
403 self.TerminalSet.add(X)
404 if self.IsSemanticRule(X):
405 pass
406
407 else:
408
409 for value in self.FunctionsDict[Rhs[MapKeywordIdx1]]:
410 RhsTemp =list(Rhs)
411 RhsTemp[MapKeywordIdx1] = value
412 RhsTemp[MapKeywordIdx2] = "@" + value.upper()
413
414 self.keywordList.append(value)
415
416 self.NonTerminalSet.add(Lhs)
417 self.LhsList.append(Lhs)
418 self.RhsList.append(RhsTemp)
419
420 for X in RhsTemp:
421 if not self.IsNoneTerminal(X) and not self.IsSemanticRule(X) and not X=="eps":
422 self.TerminalSet.add(X)
423
424 if Flag:
425 Flag = 0
426 self.Start = Lhs
427 self.MAXIMUM_RHS_LEN = max(self.MAXIMUM_RHS_LEN, len(Rhs))
428
429
430
431 self.TerminalSet.add("$")
432
433 self.NonTerminalList = list(self.NonTerminalSet)
434
435 self.TerminalList = list(self.TerminalSet)
436
437

◆ Run()

ll1_parser.LL1Parser.Run ( self)
74 def Run(self):
75 # Read grammar from input file and initialize grammar related variables
76 self.ReadGrammar()
77
78 # Calculate "First Set" for all nonterminals and print it
79 self.FindAllFirsts()
80 # print("Firsts:")
81 # self.PrintFirsts()
82 # print("________________________________________________________________________________")
83
84 # Calculate "Follow Set" for all nonterminals and print it
85 self.FindAllFollows()
86 # print("Follows:")
87 # self.PrintFollows()
88 # print("________________________________________________________________________________")
89
90 # Calculate "Prdicted Set" for each rule and print it
91 self.FindAllPredicts()
92 # print("Predicts:")
93 # self.print_predicts()
94 # print("________________________________________________________________________________")
95
96 # Fills "Parse Table" according to calculated "Predicted Set" and print "Parse Table"
97 self.FillParseTable()
98 # print("Parse Table:")
99 # self.PrintParseTable()
100 # print()
101
102 # Prints variables that are needed for parser for parsing into the output file
103 self.HeaderFile.write("#pragma once\n")
104
105 self.HeaderFile.write("#ifndef PARSE_TABLE_H\n")
106 self.HeaderFile.write("#define PARSE_TABLE_H\n")
107
108 self.HeaderFile.write("#define RULES_COUNT " + str(len(self.LhsList)) + "\n")
109 self.HeaderFile.write("#define TERMINAL_COUNT " + str(len(list(self.TerminalSet))) + "\n")
110 self.HeaderFile.write("#define NONETERMINAL_COUNT " + str(len(list(self.NonTerminalList))) + "\n")
111 self.HeaderFile.write("#define START_VARIABLE " + "\"" + self.Start +"\"\n")
112 self.HeaderFile.write("#define MAX_RHS_LEN " + str(self.MAXIMUM_RHS_LEN) +"\n")
113 self.HeaderFile.write("#define KEYWORD_LIST_LENGTH " + str(len(self.keywordList)) +"\n")
114 self.HeaderFile.write("#define OPERATORS_ONE_OPERAND_LIST_LENGTH " + str(len(self.OperatorsOneOperand)) + "\n")
115 self.HeaderFile.write("#define OPERATORS_TWO_OPERAND_LIST_LENGTH " + str(len(self.OperatorsTwoOperand)) + "\n")
116 self.HeaderFile.write("#define REGISTER_MAP_LIST_LENGTH " + str(len(self.RegistersList))+ "\n")
117 self.HeaderFile.write("#define PSEUDO_REGISTER_MAP_LIST_LENGTH " + str(len(self.PseudoRegistersList))+ "\n")
118 self.HeaderFile.write("#define SCRIPT_VARIABLE_TYPE_LIST_LENGTH " + str(len(self.VariableTypeList))+ "\n")
119 self.HeaderFile.write("#define ASSIGNMENT_OPERATOR_LIST_LENGTH " + str(len(self.AssignmentOperator)) + "\n")
120 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")
121 for Key in self.FunctionsDict:
122 self.HeaderFile.write("#define "+ Key[1:].upper() + "_LENGTH "+ str(len(self.FunctionsDict[Key]))+"\n")
123
124
125 self.SourceFile.write("#include \"pch.h\"\n")
126
127
128
129 # Prints Rules into output files
130 self.WriteLhsList()
131 self.WriteRhsList()
132
133 # Prints size of each Rhs into output files
134 self.WriteRhsSize()
135
136 # Prints noneterminals and Terminal into output files
137 self.WriteNoneTermianlList()
138 self.WriteTerminalList()
139
140 # Prints "Parse Table" into output files
141 self.WriteParseTable()
142
143 # Prints Keywords list into output files
144 self.WriteKeywordList()
145
146 # Prints Operators List into output files
147 self.WriteOperatorsList()
148
149 # Prints Maps into output files
150 self.WriteMaps()
151
152
153
154
155 self.WriteSemanticMaps()
156 self.WriteRegisterMaps()
157 self.WritePseudoRegMaps()
158 self.WriteVariableTypeList()
159
160 # Closes Grammar Input File
161 self.GrammarFile.close()
162
163
164
165

◆ SetLalr()

ll1_parser.LL1Parser.SetLalr ( self,
Lalr,
LalrParseTable )
166 def SetLalr(self, Lalr, LalrParseTable):
167 self.Lalr = Lalr
168 self.LalrParseTable = LalrParseTable
169

◆ WriteKeywordList()

ll1_parser.LL1Parser.WriteKeywordList ( self)
610 def WriteKeywordList(self):
611 self.SourceFile.write("const char* KeywordList[]= {\n")
612 self.HeaderFile.write("extern const char* KeywordList[];\n")
613
614 Counter = 0
615 for X in self.keywordList:
616 if Counter == len(self.keywordList)-1:
617 self.SourceFile.write("\"" + X + "\"" + "\n")
618 else:
619 self.SourceFile.write("\"" + X + "\"" + ",\n")
620 Counter +=1
621 self.SourceFile.write("};\n")
622

◆ WriteLhsList()

ll1_parser.LL1Parser.WriteLhsList ( self)
680 def WriteLhsList(self):
681
682 self.SourceFile.write("const struct _SCRIPT_ENGINE_TOKEN Lhs[RULES_COUNT]= \n{\n")
683 self.HeaderFile.write("extern const struct _SCRIPT_ENGINE_TOKEN Lhs[RULES_COUNT];\n")
684 Counter = 0
685 for Lhs in self.LhsList:
686 if Counter == len(self.LhsList)-1:
687 self.SourceFile.write("\t{NON_TERMINAL, " + "\"" + Lhs + "\"}" + "\n")
688 else:
689 self.SourceFile.write("\t{NON_TERMINAL, " + "\"" + Lhs + "\"}" + ",\n")
690 Counter +=1
691 self.SourceFile.write("};\n")
692

◆ WriteMaps()

ll1_parser.LL1Parser.WriteMaps ( self)
662 def WriteMaps(self):
663 for Key in self.FunctionsDict:
664 print(Key)
665
666 self.HeaderFile.write("extern const char* "+ Key[1:]+ "[];\n")
667 self.SourceFile.write("const char* "+ Key[1:]+ "[] = {\n")
668
669 Counter = 0
670 for X in self.FunctionsDict[Key]:
671 if Counter == len(self.FunctionsDict[Key])-1:
672 self.SourceFile.write("\"" + "@"+ X.upper() + "\"" + "\n")
673 else:
674 self.SourceFile.write("\"" +"@"+ X.upper() + "\"" + ",\n")
675 Counter +=1
676 self.SourceFile.write("};\n")
677
678
679

◆ WriteNoneTermianlList()

ll1_parser.LL1Parser.WriteNoneTermianlList ( self)
758 def WriteNoneTermianlList(self):
759 self.SourceFile.write("const char* NoneTerminalMap[NONETERMINAL_COUNT]= \n{\n")
760 self.HeaderFile.write("extern const char* NoneTerminalMap[NONETERMINAL_COUNT];\n")
761 Counter = 0
762 for X in self.NonTerminalList:
763 if Counter == len(self.NonTerminalList)-1:
764 self.SourceFile.write("\"" + X + "\"" + "\n")
765 else:
766 self.SourceFile.write("\"" + X + "\"" + ",\n")
767 Counter +=1
768 self.SourceFile.write("};\n")
769

◆ WriteOperatorsList()

ll1_parser.LL1Parser.WriteOperatorsList ( self)
623 def WriteOperatorsList(self):
624 self.SourceFile.write("const char* OperatorsTwoOperandList[]= {\n")
625 self.HeaderFile.write("extern const char* OperatorsTwoOperandList[];\n")
626
627 Counter = 0
628 for X in self.OperatorsTwoOperand:
629 if Counter == len(self.OperatorsTwoOperand)-1:
630 self.SourceFile.write("\"" + "@"+ X.upper() + "\"" + "\n")
631 else:
632 self.SourceFile.write("\"" + "@"+ X.upper() + "\"" + ",\n")
633 Counter +=1
634 self.SourceFile.write("};\n")
635
636 self.SourceFile.write("const char* OperatorsOneOperandList[]= {\n")
637 self.HeaderFile.write("extern const char* OperatorsOneOperandList[];\n")
638
639 Counter = 0
640 for X in self.OperatorsOneOperand:
641 if Counter == len(self.OperatorsOneOperand)-1:
642 self.SourceFile.write("\"" + "@"+ X.upper() + "\"" + "\n")
643 else:
644 self.SourceFile.write("\"" + "@"+ X.upper() + "\"" + ",\n")
645 Counter +=1
646 self.SourceFile.write("};\n")
647
648 self.SourceFile.write("const char* AssignmentOperatorList[]= {\n")
649 self.HeaderFile.write("extern const char* AssignmentOperatorList[];\n")
650
651 Counter = 0
652 for X in self.AssignmentOperator:
653 if Counter == len(self.AssignmentOperator)-1:
654 self.SourceFile.write("\"" + "@"+ X.upper() + "\"" + "\n")
655 else:
656 self.SourceFile.write("\"" + "@"+ X.upper() + "\"" + ",\n")
657 Counter +=1
658 self.SourceFile.write("};\n")
659
660
661

◆ WriteParseTable()

ll1_parser.LL1Parser.WriteParseTable ( self)
770 def WriteParseTable(self):
771 self.SourceFile.write("const int ParseTable[NONETERMINAL_COUNT][TERMINAL_COUNT]= \n{\n")
772 self.HeaderFile.write("extern const int ParseTable[NONETERMINAL_COUNT][TERMINAL_COUNT];\n")
773 i = 0
774 for X in self.NonTerminalList:
775 j = 0
776 self.SourceFile.write("\t{")
777 for y in self.TerminalList:
778 self.SourceFile.write(str(self.ParseTable[i][j]))
779 if j != len(self.TerminalList)-1:
780 self.SourceFile.write("\t\t,")
781 j += 1
782
783 if i == len(self.NonTerminalList)-1:
784 self.SourceFile.write("\t}\n")
785
786 else:
787 self.SourceFile.write("\t},\n")
788 i +=1
789 self.SourceFile.write("};\n")
790
791
792

◆ WritePseudoRegMaps()

ll1_parser.LL1Parser.WritePseudoRegMaps ( self)
578 def WritePseudoRegMaps(self):
579 Counter = 0
580 for X in self.PseudoRegistersList:
581 self.CommonHeaderFile.write("#define " + "PSEUDO_REGISTER_" + X.upper() + " " + str(Counter) + "\n")
582 Counter += 1
583 self.CommonHeaderFile.write("\n")
584
585 self.SourceFile.write("const SYMBOL_MAP PseudoRegisterMapList[]= {\n")
586 self.HeaderFile.write("extern const SYMBOL_MAP PseudoRegisterMapList[];\n")
587
588 Counter = 0
589 for X in self.PseudoRegistersList:
590 if Counter == len(self.PseudoRegistersList)-1:
591 self.SourceFile.write("{\"" + X + "\", "+ "PSEUDO_REGISTER_" + X.upper() + "}\n")
592 else:
593 self.SourceFile.write("{\"" + X + "\", "+ "PSEUDO_REGISTER_" + X.upper() + "},\n")
594 Counter +=1
595 self.SourceFile.write("};\n")
596

◆ WriteRegisterMaps()

ll1_parser.LL1Parser.WriteRegisterMaps ( self)
537 def WriteRegisterMaps(self):
538 self.CommonHeaderFile.write("\ntypedef enum REGS_ENUM {\n")
539 Counter = 0
540 for X in self.RegistersList:
541 if Counter == len(self.RegistersList)-1:
542 self.CommonHeaderFile.write("\t" + "REGISTER_" + X.upper() + " = " + str(Counter) + "\n")
543 else:
544 self.CommonHeaderFile.write("\t" + "REGISTER_" + X.upper() + " = " + str(Counter) + ",\n")
545 Counter += 1
546 self.CommonHeaderFile.write("\n} REGS_ENUM;\n\n")
547
548 self.CommonHeaderFile.write("static const char *const RegistersNames[] = {\n")
549 Counter = 0
550 for X in self.RegistersList:
551 if Counter == len(self.RegistersList)-1:
552 self.CommonHeaderFile.write("\t" + "\"" + X + "\"")
553 else:
554 if (Counter + 1) % 8 == 0:
555 self.CommonHeaderFile.write("" + "\"" + X + "\",\n")
556 else:
557 self.CommonHeaderFile.write("" + "\"" + X + "\", ")
558
559 Counter += 1
560 self.CommonHeaderFile.write("\n};\n\n")
561
562
563
564
565 self.SourceFile.write("const SYMBOL_MAP RegisterMapList[]= {\n")
566 self.HeaderFile.write("extern const SYMBOL_MAP RegisterMapList[];\n")
567
568 Counter = 0
569 for X in self.RegistersList:
570 if Counter == len(self.RegistersList)-1:
571 self.SourceFile.write("{\"" + X + "\", "+ "REGISTER_" + X.upper() + "}\n")
572 else:
573 self.SourceFile.write("{\"" + X + "\", "+ "REGISTER_" + X.upper() + "},\n")
574 Counter +=1
575 self.SourceFile.write("};\n")
576
577

◆ WriteRhsList()

ll1_parser.LL1Parser.WriteRhsList ( self)
710 def WriteRhsList(self):
711 self.SourceFile.write("const struct _SCRIPT_ENGINE_TOKEN Rhs[RULES_COUNT][MAX_RHS_LEN]= \n{\n")
712 self.HeaderFile.write("extern const struct _SCRIPT_ENGINE_TOKEN Rhs[RULES_COUNT][MAX_RHS_LEN];\n")
713 Counter =0
714 for Rhs in self.RhsList:
715 self.SourceFile.write("\t{")
716
717 C = 0
718 for Var in Rhs:
719 if C == len(Rhs) -1:
720 self.SourceFile.write("{"+self.GetType(Var) +", "+"\"" + Var + "\"}" )
721 else:
722 self.SourceFile.write("{"+self.GetType(Var) +", "+"\"" + Var + "\"}," )
723 C += 1
724
725 if Counter == len(self.RhsList)-1:
726 self.SourceFile.write("}\n")
727 else:
728 self.SourceFile.write("},\n")
729 Counter+= 1
730
731 self.SourceFile.write("};\n")
732

◆ WriteRhsSize()

ll1_parser.LL1Parser.WriteRhsSize ( self)
733 def WriteRhsSize(self):
734 self.SourceFile.write("const unsigned int RhsSize[RULES_COUNT]= \n{\n")
735 self.HeaderFile.write("extern const unsigned int RhsSize[RULES_COUNT];\n")
736 Counter =0
737 for Rhs in self.RhsList:
738 if Counter == len(self.RhsList)-1:
739 self.SourceFile.write( str(len(Rhs)) + "\n" )
740 else:
741 self.SourceFile.write( str(len(Rhs)) + ",\n" )
742 Counter+= 1
743
744 self.SourceFile.write("};\n")
745

◆ WriteSemanticMaps()

ll1_parser.LL1Parser.WriteSemanticMaps ( self)
438 def WriteSemanticMaps(self):
439
440 self.CommonHeaderFileScala.write("object ScriptEvalFunc {\n object ScriptOperators extends ChiselEnum {\n val ")
441
442 Counter = 0
443 CheckForDuplicateList = []
444
445 self.CommonHeaderFile.write("#define " + "FUNC_UNDEFINED " + str(Counter) + "\n")
446 self.CommonHeaderFileScala.write("sFunc" + "Undefined")
447 Counter += 1
448
449 for X in self.OperatorsOneOperand:
450
451 if X not in CheckForDuplicateList:
452 self.CommonHeaderFile.write("#define " + "FUNC_" + X.upper() + " " + str(Counter) + "\n")
453 self.CommonHeaderFileScala.write(", sFunc" + X.capitalize())
454
455 CheckForDuplicateList.append(X)
456 Counter += 1
457
458 for X in self.OperatorsTwoOperand:
459
460 if X not in CheckForDuplicateList:
461 self.CommonHeaderFile.write("#define " + "FUNC_" + X.upper() + " " + str(Counter) + "\n")
462 self.CommonHeaderFileScala.write(", sFunc" + X.capitalize())
463 CheckForDuplicateList.append(X)
464 Counter += 1
465
466 for X in self.SemantiRulesList:
467
468 if X not in CheckForDuplicateList:
469 self.CommonHeaderFile.write("#define " + "FUNC_" + X.upper() + " " + str(Counter) + "\n")
470 self.CommonHeaderFileScala.write(", sFunc" + X.capitalize())
471 CheckForDuplicateList.append(X)
472 Counter += 1
473
474 for X in self.keywordList:
475
476 if X not in CheckForDuplicateList:
477 self.CommonHeaderFile.write("#define " + "FUNC_" + X.upper() + " " + str(Counter) + "\n")
478
479 #
480 # Check if it's the last item
481 #
482 self.CommonHeaderFileScala.write(", sFunc" + X.capitalize() + "")
483
484 CheckForDuplicateList.append(X)
485 Counter += 1
486
487
488 self.CommonHeaderFileScala.write(" = Value\n }\n} ")
489
490
491 self.SourceFile.write("const SYMBOL_MAP SemanticRulesMapList[]= {\n")
492 self.HeaderFile.write("extern const SYMBOL_MAP SemanticRulesMapList[];\n")
493
494 for X in self.OperatorsOneOperand:
495 self.SourceFile.write("{\"@" + X.upper() + "\", "+ "FUNC_" + X.upper() + "},\n")
496
497 for X in self.OperatorsTwoOperand:
498 self.SourceFile.write("{\"@" + X.upper() + "\", "+ "FUNC_" + X.upper() + "},\n")
499
500 for X in self.SemantiRulesList:
501 self.SourceFile.write("{\"@" + X.upper() + "\", "+ "FUNC_" + X.upper() + "},\n")
502
503 for X in self.keywordList:
504 self.SourceFile.write("{\"@" + X.upper() + "\", "+ "FUNC_" + X.upper() + "},\n")
505
506 for X in self.AssignmentOperator:
507 self.SourceFile.write("{\"@" + X.upper() + "\", "+ "FUNC_" + X.upper().replace("_ASSIGNMENT", "") + "},\n")
508
509 self.SourceFile.write("};\n")
510
511 CheckForDuplicateList = []
512 self.CommonHeaderFile.write("\nstatic const char *const FunctionNames[] = {")
513 self.CommonHeaderFile.write("\n\"FUNC_UNDEFINED\""+ ",\n")
514 for X in self.OperatorsOneOperand:
515 if X not in CheckForDuplicateList:
516 self.CommonHeaderFile.write("\"" + "FUNC_" + X.upper() + "\"" + ",\n")
517 CheckForDuplicateList.append(X)
518
519 for X in self.OperatorsTwoOperand:
520 if X not in CheckForDuplicateList:
521 self.CommonHeaderFile.write("\"" + "FUNC_" + X.upper() + "\"" + ",\n")
522 CheckForDuplicateList.append(X)
523
524 for X in self.SemantiRulesList:
525 if X not in CheckForDuplicateList:
526 self.CommonHeaderFile.write("\"" + "FUNC_" + X.upper() + "\"" + ",\n")
527 CheckForDuplicateList.append(X)
528
529 for X in self.keywordList:
530 if X not in CheckForDuplicateList:
531 self.CommonHeaderFile.write("\"" + "FUNC_" + X.upper() + "\"" + ",\n")
532 CheckForDuplicateList.append(X)
533
534 self.CommonHeaderFile.write("};\n")
535
536
replace
-sdk-wdk

◆ WriteTerminalList()

ll1_parser.LL1Parser.WriteTerminalList ( self)
746 def WriteTerminalList(self):
747 self.SourceFile.write("const char* TerminalMap[TERMINAL_COUNT]= \n{\n")
748 self.HeaderFile.write("extern const char* TerminalMap[TERMINAL_COUNT];\n")
749 Counter = 0
750 for X in self.TerminalList:
751 if Counter == len(self.TerminalList)-1:
752 self.SourceFile.write("\"" + X + "\"" + "\n")
753 else:
754 self.SourceFile.write("\"" + X + "\"" + ",\n")
755 Counter +=1
756 self.SourceFile.write("};\n")
757

◆ WriteVariableTypeList()

ll1_parser.LL1Parser.WriteVariableTypeList ( self)
597 def WriteVariableTypeList(self):
598 self.SourceFile.write("const char* ScriptVariableTypeList[]= {\n")
599 self.HeaderFile.write("extern const char* ScriptVariableTypeList[];\n")
600
601 Counter = 0
602 for X in self.VariableTypeList:
603 if Counter == len(self.VariableTypeList)-1:
604 self.SourceFile.write("\"" + X + "\"" + "\n")
605 else:
606 self.SourceFile.write("\"" + X + "\"" + ",\n")
607 Counter +=1
608 self.SourceFile.write("};\n")
609

Member Data Documentation

◆ AssignmentOperator

ll1_parser.LL1Parser.AssignmentOperator = []

◆ CommonHeaderFile

ll1_parser.LL1Parser.CommonHeaderFile = CommonHeaderFile

◆ CommonHeaderFileScala

ll1_parser.LL1Parser.CommonHeaderFileScala = CommonHeaderFileScala

◆ FirstDict

dict ll1_parser.LL1Parser.FirstDict = dict()

◆ FollowDict

dict ll1_parser.LL1Parser.FollowDict = dict()

◆ FunctionsDict

ll1_parser.LL1Parser.FunctionsDict = dict()

◆ GrammarFile

ll1_parser.LL1Parser.GrammarFile = open("Grammar.txt", "r")

◆ HeaderFile

ll1_parser.LL1Parser.HeaderFile = HeaderFile

◆ INVALID

int ll1_parser.LL1Parser.INVALID = 0x80000000

◆ keywordList

ll1_parser.LL1Parser.keywordList = []

◆ Lalr

ll1_parser.LL1Parser.Lalr = Lalr

◆ LalrParseTable

ll1_parser.LL1Parser.LalrParseTable = LalrParseTable

◆ LhsList

ll1_parser.LL1Parser.LhsList = []

◆ MAXIMUM_RHS_LEN

ll1_parser.LL1Parser.MAXIMUM_RHS_LEN = 0

◆ NonTerminalList

ll1_parser.LL1Parser.NonTerminalList

◆ NonTerminalSet

ll1_parser.LL1Parser.NonTerminalSet = set()

◆ OperatorsOneOperand

ll1_parser.LL1Parser.OperatorsOneOperand = []

◆ OperatorsTwoOperand

ll1_parser.LL1Parser.OperatorsTwoOperand = []

◆ ParseTable

list ll1_parser.LL1Parser.ParseTable = [[self.INVALID for y in range(len(self.TerminalList))] for X in range(len(self.NonTerminalList))]

◆ PredictDict

dict ll1_parser.LL1Parser.PredictDict = {}

◆ PseudoRegistersList

ll1_parser.LL1Parser.PseudoRegistersList = []

◆ RegistersList

ll1_parser.LL1Parser.RegistersList = []

◆ RhsList

list ll1_parser.LL1Parser.RhsList = []

◆ SemantiRulesList

ll1_parser.LL1Parser.SemantiRulesList = []

◆ SourceFile

ll1_parser.LL1Parser.SourceFile = SourceFile

◆ SPECIAL_TOKENS

list ll1_parser.LL1Parser.SPECIAL_TOKENS
Initial value:
= ['%', '+', '~', '++', '-', '--', "*", "/", "=", "==", "!=", ",", ";", "(", ")", "{", "}", "|", "||", ">>", ">=", "<<", "<=", "&", "&&", "^",
"+=", "-=", "*=", "/=", "%=", "<<=", ">>=", "&=", "^=", "|=" , "[", "]"]

◆ Start

ll1_parser.LL1Parser.Start = ""

◆ TerminalList

ll1_parser.LL1Parser.TerminalList = list(self.TerminalSet)

◆ TerminalSet

ll1_parser.LL1Parser.TerminalSet = set()

◆ VariableTypeList

ll1_parser.LL1Parser.VariableTypeList = []
The documentation for this class was generated from the following file: