CompilerSpring2019/TransitionGraph.txt at master · Crouzbehmeshkin/CompilerSpring2019 · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
0. (0, 0)
1. (1, 0)|(NT, declaration-list, 4, 2)
2. (0, 0)|(T, EOF, "End Of File", 3, "check_main")
3. (0, 1)
4. (1, 0)|(NT, declaration-listB, 6, 5)
5. (0, 1)
6. (1, 0)|(NT, declaration, 9, 7)|(T, epsilon, "epsilon", 8)
7. (0, 0)|(NT, declaration-listB, 6, 8)
8. (0, 1)
9. (1, 0)|(NT, type-specifier, 23, 10)
10. (0, 0)|(T, ID, "*", 11, "save_id_name")
11. (0, 0)|(NT, type, 13, 12)
12. (0, 1)
13. (1, 0)|(NT, var-declarationB, 18, 17, "", "finalize_declaration1")|(T, SYMBOL, "(", 14, "start_function")
14. (0, 0)|(NT, params, 25, 15, "", "add_function_params")
15. (0, 0)|(T, SYMBOL, ")", 16)
16. (0, 0)|(NT, compound-stmt, 48, 17, "", "return3")
17. (0, 1)
18. (1, 0)|(T, SYMBOL, "[", 19)|(T, SYMBOL, ";", 22, "simple_var")
19. (0, 0)|(T, NUM, "*", 20, "save_dimension")
20. (0, 0)|(T, SYMBOL, "]", 21)
21. (0, 0)|(T, SYMBOL, ";", 22)
22. (0, 1)
23. (1, 0)|(T, KEYWORD, "int", 24, "type_specifier1")|(T, KEYWORD, "void", 24, "type_specifier2")
24. (0, 1)
25. (1, 0)|(T, KEYWORD, "void", 26)|(T, KEYWORD, "int", 28, "add_param_type")
26. (0, 0)|(NT, paramsB, 31, 27)
27. (0, 1)
28. (0, 0)|(T, ID, "*", 29, "add_param_name")
29. (0, 0)|(NT, paramB, 45, 30)
30. (0, 0)|(NT, param-listB, 35, 27, "add_param", "")
31. (1, 0)|(T, ID, "*", 32, "add_param_exc")|(T, epsilon, "epsilon", 34, "zero_param")
32. (0, 0)|(NT, paramB, 45, 33)
33. (0, 0)|(NT, param-listB, 35, 34, "add_param", "")
34. (0, 1)
35. (1, 0)|(T, SYMBOL, ",", 36)|(T, epsilon, "epsilon", 38)
36. (0, 0)|(NT, param, 39, 37, "", "add_param")
37. (0, 0)|(NT, param-listB, 35, 38)
38. (0, 1)
39. (1, 0)|(T, KEYWORD, "int", 40, "add_param_type")|(T, KEYWORD, "void", 43, "add_param_type")
40. (0, 0)|(T, ID, "*", 41, "add_param_name")
41. (0, 0)|(NT, paramB, 45, 42)
42. (0, 1)
43. (0, 0)|(T, ID, "*", 44, "add_param_name")
44. (0, 0)|(NT, paramB, 45, 42)
45. (1, 0)|(T, SYMBOL, "[", 46, "set_param_dimension")|(T, epsilon, "epsilon", 47)
46. (0, 0)|(T, SYMBOL, "]", 47)
47. (0, 1)
48. (1, 0)|(T, SYMBOL, "{", 49, "start_compound_statement")
49. (0, 0)|(NT, declaration-list, 4, 50)
50. (0, 0)|(NT, statement-list, 53, 51)
51. (0, 0)|(T, SYMBOL, "}", 52, "end_compound_statement")
52. (0, 1)
53. (1, 0)|(NT, statement-listB, 55, 54)
54. (0, 1)
55. (1, 0)|(NT, statement, 58, 56)|(T, epsilon, "epsilon", 57)
56. (0, 0)|(NT, statement-listB, 55, 57)
57. (0, 1)
58. (1, 0)|(NT, expression-stmt, 60, 59)|(NT, compound-stmt, 48, 59)|(NT, selection-stmt, 65, 59)|(NT, iteration-stmt, 73, 59)|(NT, return-stmt, 79, 59)|(NT, switch-stmt, 85, 59)
59. (0, 1)
60. (1, 0)|(NT, expression, 109, 61)|(T, KEYWORD, "continue", 62, "fix_continue")|(T, KEYWORD, "break", 63, "add_break")|(T, SYMBOL, ";", 64)
61. (0, 0)|(T, SYMBOL, ";", 64, "pop_result")
62. (0, 0)|(T, SYMBOL, ";", 64)
63. (0, 0)|(T, SYMBOL, ";", 64)
64. (0, 1)
65. (1, 0)|(T, KEYWORD, "if", 66)
66. (0, 0)|(T, SYMBOL, "(", 67)
67. (0, 0)|(NT, expression, 109, 68)
68. (0, 0)|(T, SYMBOL, ")", 69)
69. (0, 0)|(NT, statement, 58, 70, "label_if1", "label_if2")
70. (0, 0)|(T, KEYWORD, "else", 71)
71. (0, 0)|(NT, statement, 58, 72, "fill_if1", "fill_if2")
72. (0, 1)
73. (1, 0)|(T, KEYWORD, "while", 74)
74. (0, 0)|(T, SYMBOL, "(", 75, "label_while")
75. (0, 0)|(NT, expression, 109, 76)
76. (0, 0)|(T, SYMBOL, ")", 77)
77. (0, 0)|(NT, statement, 58, 78, "save_while", "fill_while")
78. (0, 1)
79. (1, 0)|(T, KEYWORD, "return", 80)
80. (0, 0)|(NT, return-stmtB, 82, 81)
81. (0, 1)
82. (1, 0)|(T, SYMBOL, ";", 84, "return1")|(NT, expression, 109, 83)
83. (0, 0)|(T, SYMBOL, ";", 84, "return2")
84. (0, 1)
85. (1, 0)|(T, KEYWORD, "switch", 86)
86. (0, 0)|(T, SYMBOL, "(", 87)
87. (0, 0)|(NT, expression, 109, 88)
88. (0, 0)|(T, SYMBOL, ")", 89)
89. (0, 0)|(T, SYMBOL, "{", 90, "add_switch_scope")
90. (0, 0)|(NT, case-stmts, 95, 92)
91. (0, 0)
92. (0, 0)|(NT, default-stmt, 105, 93)
93. (0, 0)|(T, SYMBOL, "}", 94, "remove_switch_scope")
94. (0, 1)
95. (1, 0)|(NT, case-stmtB, 97, 96)
96. (0, 1)
97. (1, 0)|(NT, case-stmt, 100, 98)|(T, epsilon, "epsilon", 99, "fill_case")
98. (0, 0)|(NT, case-stmtB, 97, 99)
99. (0, 1)
100. (1, 0)|(T, KEYWORD, "case", 101)
101. (0, 0)|(T, NUM, "*", 102, "save_case")
102. (0, 0)|(T, SYMBOL, ":", 103)
103. (0, 0)|(NT, statement-list, 53, 104)
104. (0, 1)
105. (1, 0)|(T, KEYWORD, "default", 106)|(T, epsilon, "epsilon", 108)
106. (0, 0)|(T, SYMBOL, ":", 107)
107. (0, 0)|(NT, statement-list, 53, 108)
108. (0, 1)
109. (1, 0)|(T, ID, "*", 110, "pid")|(NT, signed-factorA, 181, 112)
110. (0, 0)|(NT, expressionB, 115, 111)
111. (0, 1)
112. (0, 0)|(NT, termB, 155, 113)
113. (0, 0)|(NT, additive-expressionB, 144, 114)
114. (0, 0)|(NT, simple-expressionB, 132, 111)
115. (1, 0)|(T, SYMBOL, "(", 118, "pre_call")|(NT, varB, 128, 116, "pid2", "")
116. (0, 0)|(NT, expressionC, 123, 117)
117. (0, 1)
118. (0, 0)|(NT, args, 185, 119)
119. (0, 0)|(T, SYMBOL, ")", 120, "call")
120. (0, 0)|(NT, termB, 155, 121)
121. (0, 0)|(NT, additive-expressionB, 137, 122)
122. (0, 0)|(NT, simple-expressionB, 132, 117)
123. (0, 0)|(T, SYMBOL, "=", 124)|(NT, termB, 155, 126)
124. (0, 0)|(NT, expression, 109, 125, "", "assignment")
125. (0, 1)
126. (0, 0)|(NT, additive-expressionB, 144, 127)
127. (0, 0)|(NT, simple-expressionB, 132, 125)
128. (1, 0)|(T, SYMBOL, "[", 129)|(T, epsilon, "epsilon", 131)
129. (0, 0)|(NT, expression, 109, 130)
130. (0, 0)|(T, SYMBOL, "]", 131, "find_array_address")
131. (0, 1)
132. (1, 0)|(T, epsilon, "epsilon", 134)|(NT, relop, 135, 133)
133. (0, 0)|(NT, additive-expression, 137, 134, "", "compare_exp")
134. (0, 1)
135. (1, 0)|(T, SYMBOL, "<", 136, "relop1")|(T, SYMBOL, "==", 136, "relop2")
136. (0, 1)
137. (1, 0)|(T, ID, "*", 138, "pid")|(NT, signed-factorA, 181, 142)
138. (0, 0)|(NT, factorB, 184, 139)
139. (0, 0)|(NT, termB, 155, 140)
140. (0, 0)|(NT, additive-expressionB, 144, 141)
141. (0, 1)
142. (0, 0)|(NT, termB, 155, 143)
143. (0, 0)|(NT, additive-expressionB, 144, 141)
144. (1, 0)|(NT, addop, 148, 145)|(T, epsilon, "epsilon", 147)
145. (0, 0)|(NT, term, 150, 146, "", "add_exp")
146. (0, 0)|(NT, additive-expressionB, 144, 147)
147. (0, 1)
148. (1, 0)|(T, SYMBOL, "+", 149, "addop1")|(T, SYMBOL, "-", 149, "addop2")
149. (0, 1)
150. (1, 0)|(T, ID, "*", 151, "pid")|(NT, signed-factorA, 181, 154)
151. (0, 0)|(NT, factorB, 184, 152)
152. (0, 0)|(NT, termB, 155, 153)
153. (0, 1)
154. (0, 0)|(NT, termB, 155, 153)
155. (1, 0)|(T, SYMBOL, "*", 156)|(T, epsilon, "epsilon", 158)
156. (0, 0)|(NT, signed-factor, 159, 157, "", "mult_termB")
157. (0, 0)|(NT, termB, 155, 158)
158. (0, 1)
159. (1, 0)|(T, ID, "*", 160, "pid")|(NT, signed-factorA, 181, 161)
160. (0, 0)|(NT, factorB, 184, 161)
161. (0, 1)
162. (0, 0)|(NT, factor, 182, 163, "", "minus_factor")
163. (0, 1)
164. (0, 0)|(NT, factor, 182, 163)
165. (0, 0)|(NT, factorB, 184, 166)
166. (0, 1)
167. (0, 0)|(NT, expression, 109, 168)
168. (0, 0)|(T, SYMBOL, ")", 169)
169. (0, 1)
170. (0, 1)
171. (0, 0)|(NT, args, 185, 172)
172. (0, 0)|(T, SYMBOL, ")", 173, "call")
173. (0, 0)
174. (0, 1)
175. (0, 0)|(NT, arg-listB, 177, 176)
176. (0, 1)
177. (1, 0)|(T, SYMBOL, ",", 178)|(T, epsilon, "epsilon", 180)
178. (0, 0)|(NT, expression, 109, 179, "", "add_to_stack")
179. (0, 0)|(NT, arg-listB, 177, 180)
180. (0, 1)
181. (1, 0)|(T, SYMBOL, "-", 162)|(T, SYMBOL, "+", 164)|(NT, factorA, 183, 163)
182. (1, 0)|(T, ID, "*", 165, "pid")|(NT, factorA, 183, 166)
183. (1, 0)|(T, NUM, "*", 169, "allocate_num")|(T, SYMBOL, "(", 167)
184. (1, 0)|(NT, varB, 128, 170, "pid2", "")|(T, SYMBOL, "(", 171, "pre_call")
185. (1, 0)|(NT, arg-list, 186, 174)|(T, epsilon, "epsilon", 174)
186. (1, 0)|(NT, expression, 109, 175, "", "add_to_stack")