HyperDbg Debugger
Loading...
Searching...
No Matches
Public Member Functions | Public Attributes | List of all members
lalr1_parser.LALR1Parser Class Reference

Public Member Functions

 __init__ (self, SourceFile, HeaderFile)
 
 Run (self)
 
 WriteLhsList (self)
 
 WriteRhsList (self)
 
 WriteRhsSize (self)
 
 WriteTerminalList (self)
 
 WriteNoneTermianlList (self)
 
 WriteSemanticRules (self)
 
 GetType (self, Var)
 
 ReadGrammar (self)
 
 FillActionTable (self)
 
 FillGotoTable (self)
 
 WriteParseTable (self)
 
 WriteActionTable (self)
 
 WriteGotoTable (self)
 
 Parse (self, Tokens, InputSize)
 
 IsNoneTerminal (self, X)
 
 IsSemanticRule (self, X)
 
 GetNoneTerminalId (self, NonTerminal)
 
 GetTerminalId (self, Terminal)
 

Public Attributes

 GrammarFile
 
 SourceFile
 
 HeaderFile
 
 RhsList
 
 SemanticList
 
 LhsList
 
 TerminalSet
 
 NonTerminalSet
 
 Start
 
 MAXIMUM_RHS_LEN
 
 SPECIAL_TOKENS
 
 INVALID
 
 ACCEPT
 
 FunctionsDict
 
 OperatorsList
 
 RegistersList
 
 PseudoRegistersList
 
 keywordList
 
 ParseTable
 
 StateCount
 
 NonTerminalList
 
 TerminalList
 
 ActionTable
 
 GotoTable
 

Constructor & Destructor Documentation

◆ __init__()

lalr1_parser.LALR1Parser.__init__ ( self,
SourceFile,
HeaderFile )
22 def __init__(self, SourceFile, HeaderFile):
23 # The file which contains the grammar of the language
24 self.GrammarFile = open("Boolean_Expression_Grammar.txt", "r")
25 self.SourceFile = SourceFile
26 self.HeaderFile = HeaderFile
27
28 # Lists which used for storing the rules:
29 # Right Hand Side(Rhs)
30 self.RhsList = []
31
32 self.SemanticList = []
33
34 # Left Hand Side(Lhs)
35 self.LhsList = []
36
37 # Set of all terminals and noneterminals
38 self.TerminalSet = set()
39 self.NonTerminalSet = set()
40
41 # Start variable
42 self.Start = ""
43
44 # maximum of "Right Hand Side(Rhs)" length
45 self.MAXIMUM_RHS_LEN = 0
46
47 self.SPECIAL_TOKENS = ['%', '+', '++', '-', '--', "*", "/", "=", "==", "!=", ",", ";", "(", ")", "{", "}", "|", "||", ">>", ">=", "<<", "<=", "&", "&&", "^"]
48
49
50
51 # INVALID rule indicator
52 self.INVALID = 0x80000000
53 self.ACCEPT = 0x7fffffff
54
55 self.FunctionsDict = dict()
56 self.OperatorsList = []
57 self.RegistersList = []
58 self.PseudoRegistersList = []
59 self.keywordList = []
60 self.ParseTable = None
61
set
set(SourceFiles "hyperdbg-cli.cpp" "../include/platform/user/header/Environment.h") include_directories("../include" "../dependencies") add_executable(hyperdbg-cli $
Definition CMakeLists.txt:1

Member Function Documentation

◆ FillActionTable()

lalr1_parser.LALR1Parser.FillActionTable ( self)
297 def FillActionTable(self):
298 self.ActionTable = [[self.INVALID for y in range(len(self.TerminalList))] for X in range(self.StateCount)]
299
300 for RowId in range(self.StateCount):
301
302 for Terminal in self.ParseTable.action[RowId].keys():
303 Action = self.ParseTable.action[RowId][Terminal]
304 Type = None
305 StateId = None
306 for Element in Action:
307 Type = Element[0]
308 StateId = Element[1]
309 if Type != None:
310 if Type == 'S':
311 self.ActionTable[RowId][self.GetTerminalId(Terminal)] = StateId
312 elif Type == 'R':
313 self.ActionTable[RowId][self.GetTerminalId(Terminal)] = str(-int(StateId))
314 elif Type == 'accept':
315 self.ActionTable[RowId][self.GetTerminalId(Terminal)] = self.ACCEPT
316
317

◆ FillGotoTable()

lalr1_parser.LALR1Parser.FillGotoTable ( self)
318 def FillGotoTable(self):
319 self.GotoTable = [[self.INVALID for y in range(len(self.NonTerminalList))] for X in range(self.StateCount)]
320 for RowId in range(self.StateCount):
321
322 for NonTerminal in self.ParseTable.goto[RowId].keys():
323 Goto = self.ParseTable.goto[RowId][NonTerminal]
324 if Goto != None:
325 Id = self.GetNoneTerminalId(NonTerminal.name)
326 self.GotoTable[RowId][Id] = Goto
327
328
329

◆ GetNoneTerminalId()

lalr1_parser.LALR1Parser.GetNoneTerminalId ( self,
NonTerminal )
584 def GetNoneTerminalId(self, NonTerminal):
585 for i in range(len(self.NonTerminalList)):
586 if NonTerminal == self.NonTerminalList[i]:
587 return i
588 return -1
589

◆ GetTerminalId()

lalr1_parser.LALR1Parser.GetTerminalId ( self,
Terminal )
590 def GetTerminalId(self, Terminal):
591 if Terminal == "'$end'":
592 X = "$"
593 else:
594 X = Terminal[1:-1]
595 for i in range(len(self.TerminalList)):
596 if X == self.TerminalList[i]:
597 return i
598 return -1
599
600
GetTerminalId
int GetTerminalId(PTOKEN Token)
Gets the Terminal Id object.
Definition common.c:1129

◆ GetType()

lalr1_parser.LALR1Parser.GetType ( self,
Var )
193 def GetType(self,Var):
194 if self.IsNoneTerminal(Var):
195 return "NON_TERMINAL"
196 elif self.IsSemanticRule(Var):
197 return "SEMANTIC_RULE"
198
199 elif Var == "eps":
200 return "EPSILON"
201
202 elif Var in self.SPECIAL_TOKENS:
203 return "SPECIAL_TOKEN"
204 elif Var[0] == "_":
205 return Var[1:].upper()
206 else:
207 return "KEYWORD"
208
209

◆ IsNoneTerminal()

lalr1_parser.LALR1Parser.IsNoneTerminal ( self,
X )
572 def IsNoneTerminal(self,X):
573 if X[0].isupper():
574 return True
575 else:
576 return False
577
IsNoneTerminal
char IsNoneTerminal(PTOKEN Token)
Checks whether this Token is noneterminal NoneTerminal token starts with capital letter.
Definition common.c:1081

◆ IsSemanticRule()

lalr1_parser.LALR1Parser.IsSemanticRule ( self,
X )
578 def IsSemanticRule(self, X):
579 if X[0] == '@':
580 return True
581 else:
582 return False
583
IsSemanticRule
char IsSemanticRule(PTOKEN Token)
Checks whether this Token is semantic rule SemanticRule token starts with '@'.
Definition common.c:1097

◆ Parse()

lalr1_parser.LALR1Parser.Parse ( self,
Tokens,
InputSize )
388 def Parse(self, Tokens, InputSize):
389 # print("Lalr parser called...\n")
390 # print("Tokens : ", end = "")
391 # print(Tokens)
392
393 ReadCount = 0
394
395 Stack = [ 0 ]
396 MatchedStack = []
397
398 if ReadCount < InputSize:
399 Tokens, CurrentIn = Read(Tokens)
400 CurrentIn = "'" + CurrentIn + "'"
401 ReadCount +=1
402 else:
403 CurrentIn = "'$end'"
404
405 # print("OpenParanthesisCount = ", OpenParenthesesCount)
406
407
408 while True:
409 # Read top of stack
410 Top = GetTop(Stack)
411 # for key, value in self.ParseTable.action.items() :
412 # print (key, value)
413 # print("CurrentIn: ", CurrentIn)
414 Action = self.ParseTable.action[Top][CurrentIn]
415 # print("Action:",Action)
416 # print()
417 Type = None
418 StateId = None
419 for Element in Action:
420 Type = Element[0]
421 StateId = Element[1]
422 # print("Stack:", end =" ")
423 # print(Stack)
424
425 # print("Tokens:", end =" ")
426 # print(Tokens)
427
428 # print("CurrentIn: ", CurrentIn)
429
430 # print("Action : ", Action,'\n\n')
431
432 # print("Matched Stack:", end = " ")
433 # print(MatchedStack)
434
435
436
437
438 if Type == 'S':
439 Stack.append(CurrentIn)
440 Stack.append(StateId)
441
442 if ReadCount < InputSize:
443 Tokens, CurrentIn = Read(Tokens)
444 CurrentIn = "'" + CurrentIn + "'"
445 ReadCount += 1
446 else:
447 CurrentIn = "'$end'"
448 # print("CurrentIn = ", CurrentIn)
449
450
451 # print("Stack:", end =" ")
452 # print(Stack)
453
454 # print("Tokens:", end =" ")
455 # print(Tokens)
456
457 # print("CurrentIn: ", CurrentIn)
458
459 # print("Action : ", Action,'\n\n')
460
461 # print("OpenParanthesisCount = ", OpenParenthesesCount, end = "\n\n")
462
463 # if OpenParenthesesCount == 0:
464 # print("1) LALR Returned...\n")
465 # return Tokens
466
467 # print("Shift ", StateId, ": ")
468 # print(Stack)
469 # print()
470 # x = input()
471
472 elif Type == 'R':
473
474 def get_length(Rhs):
475 i = 0
476 for X in Rhs:
477 if self.IsSemanticRule(X):
478 continue
479 elif X == 'eps':
480 continue
481 i += 1
482 return i
483
484
485
486
487
488 Lhs = self.LhsList[StateId - 1]
489 Rhs = self.RhsList[StateId - 1]
490 RhsLen = get_length(Rhs)
491
492 SemanticRule = self.SemanticList[StateId - 1]
493 # print("Semantic Rule :", SemanticRule)
494 # print("Rhs : ", Rhs)
495 Operand = None
496 for i in range(RhsLen * 2):
497 Temp = Stack.pop()
498 # print("Temp : ", Temp)
499 if type(Temp) == str:
500 print("Temp : ", Temp)
501 Operand = Temp
502 if SemanticRule == "@PUSH":
503 MatchedStack.append(Operand)
504 if SemanticRule == "@GT":
505 print("Matched Stack:", end = " ")
506 print(MatchedStack)
507
508 Operand0 = MatchedStack.pop()
509 Operand1 = MatchedStack.pop()
510 print("GT ", Operand0, " ", Operand1)
511 MatchedStack.append(Operand0)
512
513 if SemanticRule == "@LT":
514 print("Matched Stack:", end = " ")
515 print(MatchedStack)
516
517 Operand0 = MatchedStack.pop()
518 Operand1 = MatchedStack.pop()
519 print("LT ", Operand0, " ", Operand1)
520 MatchedStack.append(Operand0)
521
522 elif SemanticRule == "@AND":
523 print("Matched Stack:", end = " ")
524 print(MatchedStack)
525
526 Operand0 = MatchedStack.pop()
527 Operand1 = MatchedStack.pop()
528 print("AND ", Operand0, " ", Operand1)
529 MatchedStack.append(Operand0)
530 # x = input()
531 # print("\n\n")
532
533 StateId = GetTop(Stack)
534
535 Top = GetTop(Stack)
536 Stack.append(Lhs)
537
538
539 LhsNonTerm = None
540 for NonTerm in self.ParseTable.nonterms:
541 if Lhs == NonTerm.name:
542 LhsNonTerm = NonTerm
543 # print(LhsNonTerm.name)
544
545 Goto = self.ParseTable.goto[StateId][LhsNonTerm]
546
547 Stack.append(Goto)
548 # print("Reduce ", StateId, ": ")
549 # print(Action)
550 # print(Stack)
551 # print()
552 # x = input()
553
554 elif Type == 'accept':
555 # print("Accepted")
556 # print()
557 # x = input()
558 return Tokens
559 else :
560
561 # print("Error")
562 # print(Stack)
563 # print()
564 # x = input()
565 pass
566
567
568
569
570
571

◆ ReadGrammar()

lalr1_parser.LALR1Parser.ReadGrammar ( self)
210 def ReadGrammar(self):
211 Flag = 1
212 Counter = -1
213 for Line in self.GrammarFile:
214 Counter += 1
215 Line = Line.strip()
216 if Line == "" or Line[0] == "#":
217 continue
218 elif Line[0] == ".":
219 L = Line.split("->")
220 Elements = L[1].split(" ")
221 if L[0][1:] == "Operators":
222 self.OperatorsList += Elements
223 continue
224 elif L[0][1:] == "Registers":
225 self.RegistersList += Elements
226 continue
227 elif L[0][1:] == "PseudoRegisters":
228 self.PseudoRegistersList += Elements
229 continue
230
231 self.FunctionsDict[L[0]] = Elements
232 continue
233
234 L = Line.split("->")
235 Lhs = L[0]
236 Rhs = L[1].split(" ")
237
238 HasMapKeyword = False
239 MapKeywordIdx1 = 0
240 MapKeywordIdx2 = 0
241 Idx = 0
242
243 for X in Rhs:
244 if X[0] == ".":
245 HasMapKeyword = True
246 MapKeywordIdx1 = Idx
247 elif X[0] == "@":
248 if X[1] == ".":
249 MapKeywordIdx2 = Idx
250 Idx += 1
251
252 if not HasMapKeyword:
253 self.NonTerminalSet.add(Lhs)
254 self.LhsList.append(Lhs)
255 self.RhsList.append(Rhs)
256 for X in Rhs:
257 if not self.IsNoneTerminal(X) and not self.IsSemanticRule(X) and not X=="eps":
258 self.TerminalSet.add(X)
259
260 else:
261
262 for value in self.FunctionsDict[Rhs[MapKeywordIdx1]]:
263 RhsTemp =list(Rhs)
264 RhsTemp[MapKeywordIdx1] = value
265 RhsTemp[MapKeywordIdx2] = "@" + value.upper()
266
267 self.keywordList.append(value)
268
269 self.NonTerminalSet.add(Lhs)
270 self.LhsList.append(Lhs)
271 self.RhsList.append(RhsTemp)
272
273 for X in RhsTemp:
274 if not self.IsNoneTerminal(X) and not self.IsSemanticRule(X) and not X=="eps":
275 self.TerminalSet.add(X)
276
277 if Flag:
278 Flag = 0
279 self.Start = Lhs
280 self.MAXIMUM_RHS_LEN = max(self.MAXIMUM_RHS_LEN, len(Rhs))
281
282
283 ii = 0
284 for Rhs in self.RhsList:
285 if self.IsSemanticRule(Rhs[len(Rhs)-1]):
286 self.SemanticList.append(Rhs[len(Rhs)-1])
287 else:
288 self.SemanticList.append(None)
289 ii += 1
290
291 self.TerminalSet.add("$")
292
293 self.NonTerminalList = list(self.NonTerminalSet)
294
295 self.TerminalList = list(self.TerminalSet)
296

◆ Run()

lalr1_parser.LALR1Parser.Run ( self)
62 def Run(self):
63 self.StateCount = len(list(self.ParseTable.goto))
64
65 # Prints variables that are needed for parser for parsing into the output file
66 self.HeaderFile.write("#define LALR_RULES_COUNT " + str(len(self.LhsList)) + "\n")
67 self.HeaderFile.write("#define LALR_TERMINAL_COUNT " + str(len(list(self.TerminalSet))) + "\n")
68 self.HeaderFile.write("#define LALR_NONTERMINAL_COUNT " + str(len(list(self.NonTerminalList))) + "\n")
69 self.HeaderFile.write("#define LALR_MAX_RHS_LEN " + str(self.MAXIMUM_RHS_LEN) +"\n")
70 self.HeaderFile.write("#define LALR_STATE_COUNT " + str(self.StateCount) +"\n")
71
72
73
74
75
76
77 # Prints Rules into output files
78 self.WriteLhsList()
79 self.WriteRhsList()
80
81 # Prints size of each Rhs into output files
82 self.WriteRhsSize()
83
84 # Prints noneterminals and Terminal into output files
85 self.WriteNoneTermianlList()
86 self.WriteTerminalList()
87
88 self.WriteParseTable()
89 self.WriteSemanticRules()
90
91 self.HeaderFile.write("#endif\n")
92
93
94

◆ WriteActionTable()

lalr1_parser.LALR1Parser.WriteActionTable ( self)
343 def WriteActionTable(self):
344 self.SourceFile.write("const int LalrActionTable[LALR_STATE_COUNT][LALR_TERMINAL_COUNT]= \n{\n")
345 self.HeaderFile.write("extern const int LalrActionTable[LALR_STATE_COUNT][LALR_TERMINAL_COUNT];\n")
346 i = 0
347 for Row in self.ActionTable:
348 j = 0
349 self.SourceFile.write("\t{")
350 for Element in Row:
351 self.SourceFile.write(str(self.ActionTable[i][j]))
352 if j != len(Row)-1:
353 self.SourceFile.write("\t\t,")
354 j += 1
355 if i == len(self.ActionTable)-1:
356 self.SourceFile.write("\t}\n")
357
358 else:
359 self.SourceFile.write("\t},\n")
360 i +=1
361 self.SourceFile.write("};\n")
362

◆ WriteGotoTable()

lalr1_parser.LALR1Parser.WriteGotoTable ( self)
363 def WriteGotoTable(self):
364 self.SourceFile.write("const int LalrGotoTable[LALR_STATE_COUNT][LALR_NONTERMINAL_COUNT]= \n{\n")
365 self.HeaderFile.write("extern const int LalrGotoTable[LALR_STATE_COUNT][LALR_NONTERMINAL_COUNT];\n")
366 i = 0
367 for Row in self.GotoTable:
368 self.SourceFile.write("\t{")
369 for j in range(len(Row)):
370 self.SourceFile.write(str(self.GotoTable[i][j]))
371 if j != len(Row)-1:
372 self.SourceFile.write("\t\t,")
373
374 if i == self.StateCount-1:
375 self.SourceFile.write("\t}\n")
376
377 else:
378 self.SourceFile.write("\t},\n")
379 i +=1
380 self.SourceFile.write("};\n")
381
382
383
384
385

◆ WriteLhsList()

lalr1_parser.LALR1Parser.WriteLhsList ( self)
95 def WriteLhsList(self):
96
97 self.SourceFile.write("const struct _TOKEN LalrLhs[RULES_COUNT]= \n{\n")
98 self.HeaderFile.write("extern const struct _TOKEN LalrLhs[RULES_COUNT];\n")
99 Counter = 0
100 for Lhs in self.LhsList:
101 if Counter == len(self.LhsList)-1:
102 self.SourceFile.write("\t{NON_TERMINAL, " + "\"" + Lhs + "\"}" + "\n")
103 else:
104 self.SourceFile.write("\t{NON_TERMINAL, " + "\"" + Lhs + "\"}" + ",\n")
105 Counter +=1
106 self.SourceFile.write("};\n")
107

◆ WriteNoneTermianlList()

lalr1_parser.LALR1Parser.WriteNoneTermianlList ( self)
156 def WriteNoneTermianlList(self):
157 self.SourceFile.write("const char* LalrNoneTerminalMap[NONETERMINAL_COUNT]= \n{\n")
158 self.HeaderFile.write("extern const char* LalrNoneTerminalMap[NONETERMINAL_COUNT];\n")
159 Counter = 0
160 for X in self.NonTerminalList:
161 if Counter == len(self.NonTerminalList)-1:
162 self.SourceFile.write("\"" + X + "\"" + "\n")
163 else:
164 self.SourceFile.write("\"" + X + "\"" + ",\n")
165 Counter +=1
166 self.SourceFile.write("};\n")
167
168

◆ WriteParseTable()

lalr1_parser.LALR1Parser.WriteParseTable ( self)
330 def WriteParseTable(self):
331 # Action = self.ParseTable.action[Top][CurrentIn]
332
333 self.FillGotoTable()
334 self.WriteGotoTable()
335
336 self.FillActionTable()
337 self.WriteActionTable()
338
339
340
341
342

◆ WriteRhsList()

lalr1_parser.LALR1Parser.WriteRhsList ( self)
108 def WriteRhsList(self):
109 self.SourceFile.write("const struct _TOKEN LalrRhs[RULES_COUNT][MAX_RHS_LEN]= \n{\n")
110 self.HeaderFile.write("extern const struct _TOKEN LalrRhs[RULES_COUNT][MAX_RHS_LEN];\n")
111 Counter =0
112 for Rhs in self.RhsList:
113 self.SourceFile.write("\t{")
114
115 C = 0
116 for Var in Rhs:
117 if C == len(Rhs) -1:
118 self.SourceFile.write("{"+self.GetType(Var) +", "+"\"" + Var + "\"}" )
119 else:
120 self.SourceFile.write("{"+self.GetType(Var) +", "+"\"" + Var + "\"}," )
121 C += 1
122
123 if Counter == len(self.RhsList)-1:
124 self.SourceFile.write("}\n")
125 else:
126 self.SourceFile.write("},\n")
127 Counter+= 1
128
129 self.SourceFile.write("};\n")
130

◆ WriteRhsSize()

lalr1_parser.LALR1Parser.WriteRhsSize ( self)
131 def WriteRhsSize(self):
132 self.SourceFile.write("const unsigned int LalrRhsSize[RULES_COUNT]= \n{\n")
133 self.HeaderFile.write("extern const unsigned int LalrRhsSize[RULES_COUNT];\n")
134 Counter =0
135 for Rhs in self.RhsList:
136 if Counter == len(self.RhsList)-1:
137 self.SourceFile.write( str(len(Rhs)) + "\n" )
138 else:
139 self.SourceFile.write( str(len(Rhs)) + ",\n" )
140 Counter+= 1
141
142 self.SourceFile.write("};\n")
143

◆ WriteSemanticRules()

lalr1_parser.LALR1Parser.WriteSemanticRules ( self)
169 def WriteSemanticRules(self):
170
171 self.SourceFile.write("const struct _TOKEN LalrSemanticRules[RULES_COUNT]= \n{\n")
172 self.HeaderFile.write("extern const struct _TOKEN LalrSemanticRules[RULES_COUNT];\n")
173
174 Counter = 0
175 for SemanticRule in self.SemanticList:
176 if Counter == len(self.SemanticList)-1:
177 if SemanticRule == None:
178 self.SourceFile.write("\t{UNKNOWN, " + "\""+"\"}" + "\n")
179 else:
180 self.SourceFile.write("\t{SEMANTIC_RULE, " + "\"" + SemanticRule+ "\"}" + "\n")
181 else:
182 if SemanticRule == None:
183 self.SourceFile.write("\t{UNKNOWN, " + "\""+"\"}" + ",\n")
184 else:
185 self.SourceFile.write("\t{SEMANTIC_RULE, " + "\"" + SemanticRule+ "\"}" + ",\n")
186 Counter +=1
187 self.SourceFile.write("};\n")
188
189
190
191
192

◆ WriteTerminalList()

lalr1_parser.LALR1Parser.WriteTerminalList ( self)
144 def WriteTerminalList(self):
145 self.SourceFile.write("const char* LalrTerminalMap[TERMINAL_COUNT]= \n{\n")
146 self.HeaderFile.write("extern const char* LalrTerminalMap[TERMINAL_COUNT];\n")
147 Counter = 0
148 for X in self.TerminalList:
149 if Counter == len(self.TerminalList)-1:
150 self.SourceFile.write("\"" + X + "\"" + "\n")
151 else:
152 self.SourceFile.write("\"" + X + "\"" + ",\n")
153 Counter +=1
154 self.SourceFile.write("};\n")
155

Member Data Documentation

◆ ACCEPT

lalr1_parser.LALR1Parser.ACCEPT

◆ ActionTable

lalr1_parser.LALR1Parser.ActionTable

◆ FunctionsDict

lalr1_parser.LALR1Parser.FunctionsDict

◆ GotoTable

lalr1_parser.LALR1Parser.GotoTable

◆ GrammarFile

lalr1_parser.LALR1Parser.GrammarFile

◆ HeaderFile

lalr1_parser.LALR1Parser.HeaderFile

◆ INVALID

lalr1_parser.LALR1Parser.INVALID

◆ keywordList

lalr1_parser.LALR1Parser.keywordList

◆ LhsList

lalr1_parser.LALR1Parser.LhsList

◆ MAXIMUM_RHS_LEN

lalr1_parser.LALR1Parser.MAXIMUM_RHS_LEN

◆ NonTerminalList

lalr1_parser.LALR1Parser.NonTerminalList

◆ NonTerminalSet

lalr1_parser.LALR1Parser.NonTerminalSet

◆ OperatorsList

lalr1_parser.LALR1Parser.OperatorsList

◆ ParseTable

lalr1_parser.LALR1Parser.ParseTable

◆ PseudoRegistersList

lalr1_parser.LALR1Parser.PseudoRegistersList

◆ RegistersList

lalr1_parser.LALR1Parser.RegistersList

◆ RhsList

lalr1_parser.LALR1Parser.RhsList

◆ SemanticList

lalr1_parser.LALR1Parser.SemanticList

◆ SourceFile

lalr1_parser.LALR1Parser.SourceFile

◆ SPECIAL_TOKENS

lalr1_parser.LALR1Parser.SPECIAL_TOKENS

◆ Start

lalr1_parser.LALR1Parser.Start

◆ StateCount

lalr1_parser.LALR1Parser.StateCount

◆ TerminalList

lalr1_parser.LALR1Parser.TerminalList

◆ TerminalSet

lalr1_parser.LALR1Parser.TerminalSet
The documentation for this class was generated from the following file: