Last active
September 23, 2020 19:53
-
-
Save jlindsey/11473f4e41c49881cc115a294f2b31f3 to your computer and use it in GitHub Desktop.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
❯ target/debug/hcl2 <<EOF | pbcopy | |
test block "label" { | |
a = 1.4e9 | |
b = -73.19e-12 | |
internal { | |
a = "test string here" | |
b = 5 | |
c = 7.3 | |
d = -3 | |
e = -4.873 | |
k = <<EOF | |
heredoc string | |
is here, doc | |
EOF | |
} | |
block two { | |
a = false | |
b = true | |
c = null | |
d = [1, 2, 3] | |
e = [false, null, "string", ["sub", "array", true]] | |
} | |
} | |
another test block { | |
a = "another test string" | |
b = 1.7e10 | |
c = false | |
} | |
EOF |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
input: test block "label" { | |
a = 1.4e9 | |
b = -73.19e-12 | |
internal { | |
a = "test string here" | |
b = 5 | |
c = 7.3 | |
d = -3 | |
e = -4.873 | |
k = <<EOF | |
heredoc string | |
is here, doc | |
EOF | |
} | |
block two { | |
a = false | |
b = true | |
c = null | |
d = [1, 2, 3] | |
e = [false, null, "string", ["sub", "array", true]] | |
} | |
} | |
another test block { | |
a = "another test string" | |
b = 1.7e10 | |
c = false | |
} | |
forward backward : parser : offset : fragment | |
1 : -> attribute : 0 : test block "label" { | |
2 : -> identifier : 0 : test block "label" { | |
1 : <- identifier : 4 : block "label" { | |
2 : <- attribute | |
forward backward : parser : offset : fragment | |
1 : -> block : 0 : test block "label" { | |
2 : -> one_line_block : 0 : test block "label" { | |
3 : -> identifier : 0 : test block "label" { | |
1 : <- identifier : 4 : block "label" { | |
4 : -> block_label : 5 : block "label" { | |
5 : -> identifier : 5 : block "label" { | |
2 : <- identifier : 10 : "label" { | |
3 : <- block_label : 10 : "label" { | |
6 : -> block_label : 11 : "label" { | |
7 : -> string : 11 : "label" { | |
8 : -> single_line_string : 11 : "label" { | |
4 : <- single_line_string : 18 : { | |
5 : <- string : 18 : { | |
6 : <- block_label : 18 : { | |
9 : -> block_label : 19 : { | |
10 : -> identifier : 19 : { | |
7 : <- identifier | |
8 : <- block_label | |
11 : -> attribute : 20 : | |
12 : -> identifier : 20 : | |
9 : <- identifier | |
10 : <- attribute | |
11 : <- one_line_block | |
13 : -> multi_line_block : 0 : test block "label" { | |
14 : -> identifier : 0 : test block "label" { | |
12 : <- identifier : 4 : block "label" { | |
15 : -> block_label : 5 : block "label" { | |
16 : -> identifier : 5 : block "label" { | |
13 : <- identifier : 10 : "label" { | |
14 : <- block_label : 10 : "label" { | |
17 : -> block_label : 11 : "label" { | |
18 : -> string : 11 : "label" { | |
19 : -> single_line_string : 11 : "label" { | |
15 : <- single_line_string : 18 : { | |
16 : <- string : 18 : { | |
17 : <- block_label : 18 : { | |
20 : -> block_label : 19 : { | |
21 : -> identifier : 19 : { | |
18 : <- identifier | |
19 : <- block_label | |
22 : -> body : 21 : a = 1.4e9 | |
23 : -> attribute : 25 : a = 1.4e9 | |
24 : -> identifier : 25 : a = 1.4e9 | |
20 : <- identifier : 26 : = 1.4e9 | |
25 : -> expr_item : 29 : 1.4e9 | |
26 : -> literal_val : 29 : 1.4e9 | |
27 : -> number : 29 : 1.4e9 | |
28 : -> sign : 29 : 1.4e9 | |
21 : <- sign | |
29 : -> exponent : 32 : e9 | |
30 : -> sign : 33 : 9 | |
22 : <- sign | |
23 : <- exponent : 34 : | |
24 : <- number : 34 : | |
25 : <- literal_val : 34 : | |
26 : <- expr_item : 34 : | |
27 : <- attribute : 35 : b = -73.19e-12 | |
31 : -> attribute : 39 : b = -73.19e-12 | |
32 : -> identifier : 39 : b = -73.19e-12 | |
28 : <- identifier : 40 : = -73.19e-12 | |
33 : -> expr_item : 43 : -73.19e-12 | |
34 : -> literal_val : 43 : -73.19e-12 | |
35 : -> number : 43 : -73.19e-12 | |
36 : -> sign : 43 : -73.19e-12 | |
29 : <- sign : 44 : 73.19e-12 | |
37 : -> exponent : 49 : e-12 | |
38 : -> sign : 50 : -12 | |
30 : <- sign : 51 : 12 | |
31 : <- exponent : 53 : | |
32 : <- number : 53 : | |
33 : <- literal_val : 53 : | |
34 : <- expr_item : 53 : | |
35 : <- attribute : 54 : | |
39 : -> attribute : 59 : internal { | |
40 : -> identifier : 59 : internal { | |
36 : <- identifier : 67 : { | |
37 : <- attribute | |
41 : -> block : 59 : internal { | |
42 : -> one_line_block : 59 : internal { | |
43 : -> identifier : 59 : internal { | |
38 : <- identifier : 67 : { | |
44 : -> block_label : 68 : { | |
45 : -> identifier : 68 : { | |
39 : <- identifier | |
40 : <- block_label | |
46 : -> attribute : 69 : | |
47 : -> identifier : 69 : | |
41 : <- identifier | |
42 : <- attribute | |
43 : <- one_line_block | |
48 : -> multi_line_block : 59 : internal { | |
49 : -> identifier : 59 : internal { | |
44 : <- identifier : 67 : { | |
50 : -> block_label : 68 : { | |
51 : -> identifier : 68 : { | |
45 : <- identifier | |
46 : <- block_label | |
52 : -> body : 70 : a = "test string here" | |
53 : -> attribute : 78 : a = "test string here" | |
54 : -> identifier : 78 : a = "test string here" | |
47 : <- identifier : 79 : = "test string here" | |
55 : -> expr_item : 82 : "test string here" | |
56 : -> literal_val : 82 : "test string here" | |
57 : -> string : 82 : "test string here" | |
58 : -> single_line_string : 82 : "test string here" | |
48 : <- single_line_string : 100 : | |
49 : <- string : 100 : | |
50 : <- literal_val : 100 : | |
51 : <- expr_item : 100 : | |
52 : <- attribute : 101 : b = 5 | |
59 : -> attribute : 109 : b = 5 | |
60 : -> identifier : 109 : b = 5 | |
53 : <- identifier : 110 : = 5 | |
61 : -> expr_item : 113 : 5 | |
62 : -> literal_val : 113 : 5 | |
63 : -> number : 113 : 5 | |
64 : -> sign : 113 : 5 | |
54 : <- sign | |
65 : -> exponent : 114 : | |
55 : <- exponent | |
56 : <- number : 114 : | |
57 : <- literal_val : 114 : | |
58 : <- expr_item : 114 : | |
59 : <- attribute : 115 : c = 7.3 | |
66 : -> attribute : 123 : c = 7.3 | |
67 : -> identifier : 123 : c = 7.3 | |
60 : <- identifier : 124 : = 7.3 | |
68 : -> expr_item : 127 : 7.3 | |
69 : -> literal_val : 127 : 7.3 | |
70 : -> number : 127 : 7.3 | |
71 : -> sign : 127 : 7.3 | |
61 : <- sign | |
72 : -> exponent : 130 : | |
62 : <- exponent | |
63 : <- number : 130 : | |
64 : <- literal_val : 130 : | |
65 : <- expr_item : 130 : | |
66 : <- attribute : 131 : d = -3 | |
73 : -> attribute : 139 : d = -3 | |
74 : -> identifier : 139 : d = -3 | |
67 : <- identifier : 140 : = -3 | |
75 : -> expr_item : 143 : -3 | |
76 : -> literal_val : 143 : -3 | |
77 : -> number : 143 : -3 | |
78 : -> sign : 143 : -3 | |
68 : <- sign : 144 : 3 | |
79 : -> exponent : 145 : | |
69 : <- exponent | |
70 : <- number : 145 : | |
71 : <- literal_val : 145 : | |
72 : <- expr_item : 145 : | |
73 : <- attribute : 146 : e = -4.873 | |
80 : -> attribute : 154 : e = -4.873 | |
81 : -> identifier : 154 : e = -4.873 | |
74 : <- identifier : 155 : = -4.873 | |
82 : -> expr_item : 158 : -4.873 | |
83 : -> literal_val : 158 : -4.873 | |
84 : -> number : 158 : -4.873 | |
85 : -> sign : 158 : -4.873 | |
75 : <- sign : 159 : 4.873 | |
86 : -> exponent : 164 : | |
76 : <- exponent | |
77 : <- number : 164 : | |
78 : <- literal_val : 164 : | |
79 : <- expr_item : 164 : | |
80 : <- attribute : 165 : k = <<EOF | |
87 : -> attribute : 173 : k = <<EOF | |
88 : -> identifier : 173 : k = <<EOF | |
81 : <- identifier : 174 : = <<EOF | |
89 : -> expr_item : 177 : <<EOF | |
90 : -> literal_val : 177 : <<EOF | |
91 : -> string : 177 : <<EOF | |
92 : -> heredoc : 177 : <<EOF | |
93 : -> identifier : 179 : EOF | |
82 : <- identifier : 182 : | |
83 : <- heredoc : 239 : } | |
84 : <- string : 239 : } | |
85 : <- literal_val : 239 : } | |
86 : <- expr_item : 239 : } | |
87 : <- attribute : 239 : } | |
94 : -> attribute : 243 : } | |
95 : -> identifier : 243 : } | |
88 : <- identifier | |
89 : <- attribute | |
96 : -> block : 243 : } | |
97 : -> one_line_block : 243 : } | |
98 : -> identifier : 243 : } | |
90 : <- identifier | |
91 : <- one_line_block | |
99 : -> multi_line_block : 243 : } | |
100 : -> identifier : 243 : } | |
92 : <- identifier | |
93 : <- multi_line_block | |
94 : <- block | |
95 : <- body : 239 : } | |
96 : <- multi_line_block : 245 : | |
97 : <- block : 245 : | |
101 : -> attribute : 250 : block two { | |
102 : -> identifier : 250 : block two { | |
98 : <- identifier : 255 : two { | |
99 : <- attribute | |
103 : -> block : 250 : block two { | |
104 : -> one_line_block : 250 : block two { | |
105 : -> identifier : 250 : block two { | |
100 : <- identifier : 255 : two { | |
106 : -> block_label : 256 : two { | |
107 : -> identifier : 256 : two { | |
101 : <- identifier : 259 : { | |
102 : <- block_label : 259 : { | |
108 : -> block_label : 260 : { | |
109 : -> identifier : 260 : { | |
103 : <- identifier | |
104 : <- block_label | |
110 : -> attribute : 261 : | |
111 : -> identifier : 261 : | |
105 : <- identifier | |
106 : <- attribute | |
107 : <- one_line_block | |
112 : -> multi_line_block : 250 : block two { | |
113 : -> identifier : 250 : block two { | |
108 : <- identifier : 255 : two { | |
114 : -> block_label : 256 : two { | |
115 : -> identifier : 256 : two { | |
109 : <- identifier : 259 : { | |
110 : <- block_label : 259 : { | |
116 : -> block_label : 260 : { | |
117 : -> identifier : 260 : { | |
111 : <- identifier | |
112 : <- block_label | |
118 : -> body : 262 : a = false | |
119 : -> attribute : 270 : a = false | |
120 : -> identifier : 270 : a = false | |
113 : <- identifier : 271 : = false | |
121 : -> expr_item : 274 : false | |
122 : -> literal_val : 274 : false | |
123 : -> boolean : 274 : false | |
124 : -> false_literal : 274 : false | |
114 : <- false_literal : 279 : | |
115 : <- boolean : 279 : | |
116 : <- literal_val : 279 : | |
117 : <- expr_item : 279 : | |
118 : <- attribute : 280 : b = true | |
125 : -> attribute : 288 : b = true | |
126 : -> identifier : 288 : b = true | |
119 : <- identifier : 289 : = true | |
127 : -> expr_item : 292 : true | |
128 : -> literal_val : 292 : true | |
129 : -> boolean : 292 : true | |
130 : -> true_literal : 292 : true | |
120 : <- true_literal : 296 : | |
121 : <- boolean : 296 : | |
122 : <- literal_val : 296 : | |
123 : <- expr_item : 296 : | |
124 : <- attribute : 297 : c = null | |
131 : -> attribute : 305 : c = null | |
132 : -> identifier : 305 : c = null | |
125 : <- identifier : 306 : = null | |
133 : -> expr_item : 309 : null | |
134 : -> literal_val : 309 : null | |
135 : -> null_literal : 309 : null | |
126 : <- null_literal : 313 : | |
127 : <- literal_val : 313 : | |
128 : <- expr_item : 313 : | |
129 : <- attribute : 314 : d = [1, 2, 3] | |
136 : -> attribute : 322 : d = [1, 2, 3] | |
137 : -> identifier : 322 : d = [1, 2, 3] | |
130 : <- identifier : 323 : = [1, 2, 3] | |
138 : -> expr_item : 326 : [1, 2, 3] | |
139 : -> literal_val : 326 : [1, 2, 3] | |
131 : <- literal_val | |
140 : -> collection_val : 326 : [1, 2, 3] | |
141 : -> array : 326 : [1, 2, 3] | |
142 : -> expr_item : 327 : 1, 2, 3] | |
143 : -> literal_val : 327 : 1, 2, 3] | |
144 : -> number : 327 : 1, 2, 3] | |
145 : -> sign : 327 : 1, 2, 3] | |
132 : <- sign | |
146 : -> exponent : 328 : , 2, 3] | |
133 : <- exponent | |
134 : <- number : 328 : , 2, 3] | |
135 : <- literal_val : 328 : , 2, 3] | |
136 : <- expr_item : 328 : , 2, 3] | |
147 : -> expr_item : 330 : 2, 3] | |
148 : -> literal_val : 330 : 2, 3] | |
149 : -> number : 330 : 2, 3] | |
150 : -> sign : 330 : 2, 3] | |
137 : <- sign | |
151 : -> exponent : 331 : , 3] | |
138 : <- exponent | |
139 : <- number : 331 : , 3] | |
140 : <- literal_val : 331 : , 3] | |
141 : <- expr_item : 331 : , 3] | |
152 : -> expr_item : 333 : 3] | |
153 : -> literal_val : 333 : 3] | |
154 : -> number : 333 : 3] | |
155 : -> sign : 333 : 3] | |
142 : <- sign | |
156 : -> exponent : 334 : ] | |
143 : <- exponent | |
144 : <- number : 334 : ] | |
145 : <- literal_val : 334 : ] | |
146 : <- expr_item : 334 : ] | |
147 : <- array : 335 : | |
148 : <- collection_val : 335 : | |
149 : <- expr_item : 335 : | |
150 : <- attribute : 336 : e = [false, null, "string", ["sub", "array", true]] | |
157 : -> attribute : 344 : e = [false, null, "string", ["sub", "array", true]] | |
158 : -> identifier : 344 : e = [false, null, "string", ["sub", "array", true]] | |
151 : <- identifier : 345 : = [false, null, "string", ["sub", "array", true]] | |
159 : -> expr_item : 348 : [false, null, "string", ["sub", "array", true]] | |
160 : -> literal_val : 348 : [false, null, "string", ["sub", "array", true]] | |
152 : <- literal_val | |
161 : -> collection_val : 348 : [false, null, "string", ["sub", "array", true]] | |
162 : -> array : 348 : [false, null, "string", ["sub", "array", true]] | |
163 : -> expr_item : 349 : false, null, "string", ["sub", "array", true]] | |
164 : -> literal_val : 349 : false, null, "string", ["sub", "array", true]] | |
165 : -> boolean : 349 : false, null, "string", ["sub", "array", true]] | |
166 : -> false_literal : 349 : false, null, "string", ["sub", "array", true]] | |
153 : <- false_literal : 354 : , null, "string", ["sub", "array", true]] | |
154 : <- boolean : 354 : , null, "string", ["sub", "array", true]] | |
155 : <- literal_val : 354 : , null, "string", ["sub", "array", true]] | |
156 : <- expr_item : 354 : , null, "string", ["sub", "array", true]] | |
167 : -> expr_item : 356 : null, "string", ["sub", "array", true]] | |
168 : -> literal_val : 356 : null, "string", ["sub", "array", true]] | |
169 : -> null_literal : 356 : null, "string", ["sub", "array", true]] | |
157 : <- null_literal : 360 : , "string", ["sub", "array", true]] | |
158 : <- literal_val : 360 : , "string", ["sub", "array", true]] | |
159 : <- expr_item : 360 : , "string", ["sub", "array", true]] | |
170 : -> expr_item : 362 : "string", ["sub", "array", true]] | |
171 : -> literal_val : 362 : "string", ["sub", "array", true]] | |
172 : -> string : 362 : "string", ["sub", "array", true]] | |
173 : -> single_line_string : 362 : "string", ["sub", "array", true]] | |
160 : <- single_line_string : 370 : , ["sub", "array", true]] | |
161 : <- string : 370 : , ["sub", "array", true]] | |
162 : <- literal_val : 370 : , ["sub", "array", true]] | |
163 : <- expr_item : 370 : , ["sub", "array", true]] | |
174 : -> expr_item : 372 : ["sub", "array", true]] | |
175 : -> literal_val : 372 : ["sub", "array", true]] | |
164 : <- literal_val | |
176 : -> collection_val : 372 : ["sub", "array", true]] | |
177 : -> array : 372 : ["sub", "array", true]] | |
178 : -> expr_item : 373 : "sub", "array", true]] | |
179 : -> literal_val : 373 : "sub", "array", true]] | |
180 : -> string : 373 : "sub", "array", true]] | |
181 : -> single_line_string : 373 : "sub", "array", true]] | |
165 : <- single_line_string : 378 : , "array", true]] | |
166 : <- string : 378 : , "array", true]] | |
167 : <- literal_val : 378 : , "array", true]] | |
168 : <- expr_item : 378 : , "array", true]] | |
182 : -> expr_item : 380 : "array", true]] | |
183 : -> literal_val : 380 : "array", true]] | |
184 : -> string : 380 : "array", true]] | |
185 : -> single_line_string : 380 : "array", true]] | |
169 : <- single_line_string : 387 : , true]] | |
170 : <- string : 387 : , true]] | |
171 : <- literal_val : 387 : , true]] | |
172 : <- expr_item : 387 : , true]] | |
186 : -> expr_item : 389 : true]] | |
187 : -> literal_val : 389 : true]] | |
188 : -> boolean : 389 : true]] | |
189 : -> true_literal : 389 : true]] | |
173 : <- true_literal : 393 : ]] | |
174 : <- boolean : 393 : ]] | |
175 : <- literal_val : 393 : ]] | |
176 : <- expr_item : 393 : ]] | |
177 : <- array : 394 : ] | |
178 : <- collection_val : 394 : ] | |
179 : <- expr_item : 394 : ] | |
180 : <- array : 395 : | |
181 : <- collection_val : 395 : | |
182 : <- expr_item : 395 : | |
183 : <- attribute : 396 : } | |
190 : -> attribute : 400 : } | |
191 : -> identifier : 400 : } | |
184 : <- identifier | |
185 : <- attribute | |
192 : -> block : 400 : } | |
193 : -> one_line_block : 400 : } | |
194 : -> identifier : 400 : } | |
186 : <- identifier | |
187 : <- one_line_block | |
195 : -> multi_line_block : 400 : } | |
196 : -> identifier : 400 : } | |
188 : <- identifier | |
189 : <- multi_line_block | |
190 : <- block | |
191 : <- body : 396 : } | |
192 : <- multi_line_block : 402 : } | |
193 : <- block : 402 : } | |
197 : -> attribute : 402 : } | |
198 : -> identifier : 402 : } | |
194 : <- identifier | |
195 : <- attribute | |
199 : -> block : 402 : } | |
200 : -> one_line_block : 402 : } | |
201 : -> identifier : 402 : } | |
196 : <- identifier | |
197 : <- one_line_block | |
202 : -> multi_line_block : 402 : } | |
203 : -> identifier : 402 : } | |
198 : <- identifier | |
199 : <- multi_line_block | |
200 : <- block | |
201 : <- body : 402 : } | |
202 : <- multi_line_block : 404 : | |
203 : <- block : 404 : | |
forward backward : parser : offset : fragment | |
1 : -> attribute : 405 : another test block { | |
2 : -> identifier : 405 : another test block { | |
1 : <- identifier : 412 : test block { | |
2 : <- attribute | |
forward backward : parser : offset : fragment | |
1 : -> block : 405 : another test block { | |
2 : -> one_line_block : 405 : another test block { | |
3 : -> identifier : 405 : another test block { | |
1 : <- identifier : 412 : test block { | |
4 : -> block_label : 413 : test block { | |
5 : -> identifier : 413 : test block { | |
2 : <- identifier : 417 : block { | |
3 : <- block_label : 417 : block { | |
6 : -> block_label : 418 : block { | |
7 : -> identifier : 418 : block { | |
4 : <- identifier : 423 : { | |
5 : <- block_label : 423 : { | |
8 : -> block_label : 424 : { | |
9 : -> identifier : 424 : { | |
6 : <- identifier | |
7 : <- block_label | |
10 : -> attribute : 425 : | |
11 : -> identifier : 425 : | |
8 : <- identifier | |
9 : <- attribute | |
10 : <- one_line_block | |
12 : -> multi_line_block : 405 : another test block { | |
13 : -> identifier : 405 : another test block { | |
11 : <- identifier : 412 : test block { | |
14 : -> block_label : 413 : test block { | |
15 : -> identifier : 413 : test block { | |
12 : <- identifier : 417 : block { | |
13 : <- block_label : 417 : block { | |
16 : -> block_label : 418 : block { | |
17 : -> identifier : 418 : block { | |
14 : <- identifier : 423 : { | |
15 : <- block_label : 423 : { | |
18 : -> block_label : 424 : { | |
19 : -> identifier : 424 : { | |
16 : <- identifier | |
17 : <- block_label | |
20 : -> body : 426 : a = "another test string" | |
21 : -> attribute : 430 : a = "another test string" | |
22 : -> identifier : 430 : a = "another test string" | |
18 : <- identifier : 431 : = "another test string" | |
23 : -> expr_item : 434 : "another test string" | |
24 : -> literal_val : 434 : "another test string" | |
25 : -> string : 434 : "another test string" | |
26 : -> single_line_string : 434 : "another test string" | |
19 : <- single_line_string : 455 : | |
20 : <- string : 455 : | |
21 : <- literal_val : 455 : | |
22 : <- expr_item : 455 : | |
23 : <- attribute : 456 : b = 1.7e10 | |
27 : -> attribute : 460 : b = 1.7e10 | |
28 : -> identifier : 460 : b = 1.7e10 | |
24 : <- identifier : 461 : = 1.7e10 | |
29 : -> expr_item : 464 : 1.7e10 | |
30 : -> literal_val : 464 : 1.7e10 | |
31 : -> number : 464 : 1.7e10 | |
32 : -> sign : 464 : 1.7e10 | |
25 : <- sign | |
33 : -> exponent : 467 : e10 | |
34 : -> sign : 468 : 10 | |
26 : <- sign | |
27 : <- exponent : 470 : | |
28 : <- number : 470 : | |
29 : <- literal_val : 470 : | |
30 : <- expr_item : 470 : | |
31 : <- attribute : 471 : c = false | |
35 : -> attribute : 475 : c = false | |
36 : -> identifier : 475 : c = false | |
32 : <- identifier : 476 : = false | |
37 : -> expr_item : 479 : false | |
38 : -> literal_val : 479 : false | |
39 : -> boolean : 479 : false | |
40 : -> false_literal : 479 : false | |
33 : <- false_literal : 484 : | |
34 : <- boolean : 484 : | |
35 : <- literal_val : 484 : | |
36 : <- expr_item : 484 : | |
37 : <- attribute : 485 : } | |
41 : -> attribute : 485 : } | |
42 : -> identifier : 485 : } | |
38 : <- identifier | |
39 : <- attribute | |
43 : -> block : 485 : } | |
44 : -> one_line_block : 485 : } | |
45 : -> identifier : 485 : } | |
40 : <- identifier | |
41 : <- one_line_block | |
46 : -> multi_line_block : 485 : } | |
47 : -> identifier : 485 : } | |
42 : <- identifier | |
43 : <- multi_line_block | |
44 : <- block | |
45 : <- body : 485 : } | |
46 : <- multi_line_block : 487 : | |
47 : <- block : 487 : | |
forward backward : parser : offset : fragment | |
1 : -> attribute : 487 : | |
2 : -> identifier : 487 : | |
1 : <- identifier | |
2 : <- attribute | |
forward backward : parser : offset : fragment | |
1 : -> block : 487 : | |
2 : -> one_line_block : 487 : | |
3 : -> identifier : 487 : | |
1 : <- identifier | |
2 : <- one_line_block | |
4 : -> multi_line_block : 487 : | |
5 : -> identifier : 487 : | |
3 : <- identifier | |
4 : <- multi_line_block | |
5 : <- block | |
parsed ast: [ | |
Node { | |
offset: 0, | |
line: 1, | |
column: 1, | |
token: Block( | |
Block { | |
ident: Node { | |
offset: 0, | |
line: 1, | |
column: 1, | |
token: Identifier( | |
"test", | |
), | |
}, | |
labels: [ | |
Node { | |
offset: 5, | |
line: 1, | |
column: 6, | |
token: Identifier( | |
"block", | |
), | |
}, | |
Node { | |
offset: 12, | |
line: 1, | |
column: 13, | |
token: String( | |
"label", | |
), | |
}, | |
], | |
body: Some( | |
Node { | |
offset: 21, | |
line: 2, | |
column: 1, | |
token: Body( | |
[ | |
Node { | |
offset: 25, | |
line: 2, | |
column: 5, | |
token: Attribute( | |
Attribute { | |
ident: Node { | |
offset: 25, | |
line: 2, | |
column: 5, | |
token: Identifier( | |
"a", | |
), | |
}, | |
expr: Node { | |
offset: 29, | |
line: 2, | |
column: 9, | |
token: Number( | |
Int( | |
1400000000, | |
), | |
), | |
}, | |
}, | |
), | |
}, | |
Node { | |
offset: 39, | |
line: 3, | |
column: 5, | |
token: Attribute( | |
Attribute { | |
ident: Node { | |
offset: 39, | |
line: 3, | |
column: 5, | |
token: Identifier( | |
"b", | |
), | |
}, | |
expr: Node { | |
offset: 43, | |
line: 3, | |
column: 9, | |
token: UnaryOp( | |
UnaryOp { | |
operator: Node { | |
offset: 43, | |
line: 3, | |
column: 9, | |
token: Operator( | |
Minus, | |
), | |
}, | |
operand: Node { | |
offset: 43, | |
line: 3, | |
column: 9, | |
token: Number( | |
Float( | |
0.00000000007319, | |
), | |
), | |
}, | |
}, | |
), | |
}, | |
}, | |
), | |
}, | |
Node { | |
offset: 59, | |
line: 5, | |
column: 5, | |
token: Block( | |
Block { | |
ident: Node { | |
offset: 59, | |
line: 5, | |
column: 5, | |
token: Identifier( | |
"internal", | |
), | |
}, | |
labels: [], | |
body: Some( | |
Node { | |
offset: 70, | |
line: 6, | |
column: 1, | |
token: Body( | |
[ | |
Node { | |
offset: 78, | |
line: 6, | |
column: 9, | |
token: Attribute( | |
Attribute { | |
ident: Node { | |
offset: 78, | |
line: 6, | |
column: 9, | |
token: Identifier( | |
"a", | |
), | |
}, | |
expr: Node { | |
offset: 83, | |
line: 6, | |
column: 14, | |
token: String( | |
"test string here", | |
), | |
}, | |
}, | |
), | |
}, | |
Node { | |
offset: 109, | |
line: 7, | |
column: 9, | |
token: Attribute( | |
Attribute { | |
ident: Node { | |
offset: 109, | |
line: 7, | |
column: 9, | |
token: Identifier( | |
"b", | |
), | |
}, | |
expr: Node { | |
offset: 113, | |
line: 7, | |
column: 13, | |
token: Number( | |
Int( | |
5, | |
), | |
), | |
}, | |
}, | |
), | |
}, | |
Node { | |
offset: 123, | |
line: 8, | |
column: 9, | |
token: Attribute( | |
Attribute { | |
ident: Node { | |
offset: 123, | |
line: 8, | |
column: 9, | |
token: Identifier( | |
"c", | |
), | |
}, | |
expr: Node { | |
offset: 127, | |
line: 8, | |
column: 13, | |
token: Number( | |
Float( | |
7.3, | |
), | |
), | |
}, | |
}, | |
), | |
}, | |
Node { | |
offset: 139, | |
line: 9, | |
column: 9, | |
token: Attribute( | |
Attribute { | |
ident: Node { | |
offset: 139, | |
line: 9, | |
column: 9, | |
token: Identifier( | |
"d", | |
), | |
}, | |
expr: Node { | |
offset: 143, | |
line: 9, | |
column: 13, | |
token: UnaryOp( | |
UnaryOp { | |
operator: Node { | |
offset: 143, | |
line: 9, | |
column: 13, | |
token: Operator( | |
Minus, | |
), | |
}, | |
operand: Node { | |
offset: 143, | |
line: 9, | |
column: 13, | |
token: Number( | |
Int( | |
3, | |
), | |
), | |
}, | |
}, | |
), | |
}, | |
}, | |
), | |
}, | |
Node { | |
offset: 154, | |
line: 10, | |
column: 9, | |
token: Attribute( | |
Attribute { | |
ident: Node { | |
offset: 154, | |
line: 10, | |
column: 9, | |
token: Identifier( | |
"e", | |
), | |
}, | |
expr: Node { | |
offset: 158, | |
line: 10, | |
column: 13, | |
token: UnaryOp( | |
UnaryOp { | |
operator: Node { | |
offset: 158, | |
line: 10, | |
column: 13, | |
token: Operator( | |
Minus, | |
), | |
}, | |
operand: Node { | |
offset: 158, | |
line: 10, | |
column: 13, | |
token: Number( | |
Float( | |
4.873, | |
), | |
), | |
}, | |
}, | |
), | |
}, | |
}, | |
), | |
}, | |
Node { | |
offset: 173, | |
line: 11, | |
column: 9, | |
token: Attribute( | |
Attribute { | |
ident: Node { | |
offset: 173, | |
line: 11, | |
column: 9, | |
token: Identifier( | |
"k", | |
), | |
}, | |
expr: Node { | |
offset: 177, | |
line: 11, | |
column: 13, | |
token: Heredoc( | |
Heredoc { | |
ident: Node { | |
offset: 179, | |
line: 11, | |
column: 15, | |
token: Identifier( | |
"EOF", | |
), | |
}, | |
truncate: false, | |
content: " heredoc string\n is here, doc\n", | |
}, | |
), | |
}, | |
}, | |
), | |
}, | |
], | |
), | |
}, | |
), | |
}, | |
), | |
}, | |
Node { | |
offset: 250, | |
line: 17, | |
column: 5, | |
token: Block( | |
Block { | |
ident: Node { | |
offset: 250, | |
line: 17, | |
column: 5, | |
token: Identifier( | |
"block", | |
), | |
}, | |
labels: [ | |
Node { | |
offset: 256, | |
line: 17, | |
column: 11, | |
token: Identifier( | |
"two", | |
), | |
}, | |
], | |
body: Some( | |
Node { | |
offset: 262, | |
line: 18, | |
column: 1, | |
token: Body( | |
[ | |
Node { | |
offset: 270, | |
line: 18, | |
column: 9, | |
token: Attribute( | |
Attribute { | |
ident: Node { | |
offset: 270, | |
line: 18, | |
column: 9, | |
token: Identifier( | |
"a", | |
), | |
}, | |
expr: Node { | |
offset: 274, | |
line: 18, | |
column: 13, | |
token: False, | |
}, | |
}, | |
), | |
}, | |
Node { | |
offset: 288, | |
line: 19, | |
column: 9, | |
token: Attribute( | |
Attribute { | |
ident: Node { | |
offset: 288, | |
line: 19, | |
column: 9, | |
token: Identifier( | |
"b", | |
), | |
}, | |
expr: Node { | |
offset: 292, | |
line: 19, | |
column: 13, | |
token: True, | |
}, | |
}, | |
), | |
}, | |
Node { | |
offset: 305, | |
line: 20, | |
column: 9, | |
token: Attribute( | |
Attribute { | |
ident: Node { | |
offset: 305, | |
line: 20, | |
column: 9, | |
token: Identifier( | |
"c", | |
), | |
}, | |
expr: Node { | |
offset: 309, | |
line: 20, | |
column: 13, | |
token: Null, | |
}, | |
}, | |
), | |
}, | |
Node { | |
offset: 322, | |
line: 21, | |
column: 9, | |
token: Attribute( | |
Attribute { | |
ident: Node { | |
offset: 322, | |
line: 21, | |
column: 9, | |
token: Identifier( | |
"d", | |
), | |
}, | |
expr: Node { | |
offset: 326, | |
line: 21, | |
column: 13, | |
token: List( | |
[ | |
Node { | |
offset: 327, | |
line: 21, | |
column: 14, | |
token: Number( | |
Int( | |
1, | |
), | |
), | |
}, | |
Node { | |
offset: 330, | |
line: 21, | |
column: 17, | |
token: Number( | |
Int( | |
2, | |
), | |
), | |
}, | |
Node { | |
offset: 333, | |
line: 21, | |
column: 20, | |
token: Number( | |
Int( | |
3, | |
), | |
), | |
}, | |
], | |
), | |
}, | |
}, | |
), | |
}, | |
Node { | |
offset: 344, | |
line: 22, | |
column: 9, | |
token: Attribute( | |
Attribute { | |
ident: Node { | |
offset: 344, | |
line: 22, | |
column: 9, | |
token: Identifier( | |
"e", | |
), | |
}, | |
expr: Node { | |
offset: 348, | |
line: 22, | |
column: 13, | |
token: List( | |
[ | |
Node { | |
offset: 349, | |
line: 22, | |
column: 14, | |
token: False, | |
}, | |
Node { | |
offset: 356, | |
line: 22, | |
column: 21, | |
token: Null, | |
}, | |
Node { | |
offset: 363, | |
line: 22, | |
column: 28, | |
token: String( | |
"string", | |
), | |
}, | |
Node { | |
offset: 372, | |
line: 22, | |
column: 37, | |
token: List( | |
[ | |
Node { | |
offset: 374, | |
line: 22, | |
column: 39, | |
token: String( | |
"sub", | |
), | |
}, | |
Node { | |
offset: 381, | |
line: 22, | |
column: 46, | |
token: String( | |
"array", | |
), | |
}, | |
Node { | |
offset: 389, | |
line: 22, | |
column: 54, | |
token: True, | |
}, | |
], | |
), | |
}, | |
], | |
), | |
}, | |
}, | |
), | |
}, | |
], | |
), | |
}, | |
), | |
}, | |
), | |
}, | |
], | |
), | |
}, | |
), | |
}, | |
), | |
}, | |
Node { | |
offset: 405, | |
line: 26, | |
column: 1, | |
token: Block( | |
Block { | |
ident: Node { | |
offset: 405, | |
line: 26, | |
column: 1, | |
token: Identifier( | |
"another", | |
), | |
}, | |
labels: [ | |
Node { | |
offset: 413, | |
line: 26, | |
column: 9, | |
token: Identifier( | |
"test", | |
), | |
}, | |
Node { | |
offset: 418, | |
line: 26, | |
column: 14, | |
token: Identifier( | |
"block", | |
), | |
}, | |
], | |
body: Some( | |
Node { | |
offset: 426, | |
line: 27, | |
column: 1, | |
token: Body( | |
[ | |
Node { | |
offset: 430, | |
line: 27, | |
column: 5, | |
token: Attribute( | |
Attribute { | |
ident: Node { | |
offset: 430, | |
line: 27, | |
column: 5, | |
token: Identifier( | |
"a", | |
), | |
}, | |
expr: Node { | |
offset: 435, | |
line: 27, | |
column: 10, | |
token: String( | |
"another test string", | |
), | |
}, | |
}, | |
), | |
}, | |
Node { | |
offset: 460, | |
line: 28, | |
column: 5, | |
token: Attribute( | |
Attribute { | |
ident: Node { | |
offset: 460, | |
line: 28, | |
column: 5, | |
token: Identifier( | |
"b", | |
), | |
}, | |
expr: Node { | |
offset: 464, | |
line: 28, | |
column: 9, | |
token: Number( | |
Int( | |
17000000000, | |
), | |
), | |
}, | |
}, | |
), | |
}, | |
Node { | |
offset: 475, | |
line: 29, | |
column: 5, | |
token: Attribute( | |
Attribute { | |
ident: Node { | |
offset: 475, | |
line: 29, | |
column: 5, | |
token: Identifier( | |
"c", | |
), | |
}, | |
expr: Node { | |
offset: 479, | |
line: 29, | |
column: 9, | |
token: False, | |
}, | |
}, | |
), | |
}, | |
], | |
), | |
}, | |
), | |
}, | |
), | |
}, | |
] | |
parser | histogram | count | |
---------------- | -------------------------------------------------- | ----- | |
identifier | .................................................. | 2 | |
multi_line_block | ......................... | 1 | |
block | ......................... | 1 | |
one_line_block | ......................... | 1 | |
parser | cumulative histogram | count | |
---------------- | -------------------------------------------------- | ----- | |
block | .................................................. | 5 | |
one_line_block | .................... | 2 | |
multi_line_block | .................... | 2 | |
identifier | .................... | 2 | |
duration: 8.338278ms |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment