go/hcl
2
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
e571ec5810
hcl/zcl/zclsyntax/scan_tokens.go

3763 lines
114 KiB
Go
Raw Normal View History

zclsyntax: scanner to return whole token slice at once On reflection, it seems easier to maintain the necessary state we need by doing all of the scanning in a single pass, since we can then just use local variables within the scanner function.
2017-05-28 14:11:24 +00:00
// line 1 "scan_tokens.rl"
zclsyntax: start of a ragel-based scanner Using Ragel here because the scanner is going to be somewhat complex due to the need to switch back and forth between normal and template states, etc. This should be easier to maintain than a hand-written scanner, while ragel gives us the extra features we need to implement things that would normally be too complex for a "regular" scanner generator.
2017-05-28 02:01:43 +00:00
package zclsyntax
import (
zclsyntax: heredoc support in the scanner
2017-05-29 15:55:53 +00:00
"bytes"
zclsyntax: start of a ragel-based scanner Using Ragel here because the scanner is going to be somewhat complex due to the need to switch back and forth between normal and template states, etc. This should be easier to maintain than a hand-written scanner, while ragel gives us the extra features we need to implement things that would normally be too complex for a "regular" scanner generator.
2017-05-28 02:01:43 +00:00
"github.com/zclconf/go-zcl/zcl"
)
zclsyntax: scanner to return whole token slice at once On reflection, it seems easier to maintain the necessary state we need by doing all of the scanning in a single pass, since we can then just use local variables within the scanner function.
2017-05-28 14:11:24 +00:00
// This file is generated from scan_tokens.rl. DO NOT EDIT.
zclsyntax: start of a ragel-based scanner Using Ragel here because the scanner is going to be somewhat complex due to the need to switch back and forth between normal and template states, etc. This should be easier to maintain than a hand-written scanner, while ragel gives us the extra features we need to implement things that would normally be too complex for a "regular" scanner generator.
2017-05-28 02:01:43 +00:00
zclsyntax: heredoc support in the scanner
2017-05-29 15:55:53 +00:00
// line 14 "scan_tokens.go"
zclsyntax: start of a ragel-based scanner Using Ragel here because the scanner is going to be somewhat complex due to the need to switch back and forth between normal and template states, etc. This should be easier to maintain than a hand-written scanner, while ragel gives us the extra features we need to implement things that would normally be too complex for a "regular" scanner generator.
2017-05-28 02:01:43 +00:00
var _zcltok_actions []byte = []byte{
zclsyntax: heredoc support in the scanner
2017-05-29 15:55:53 +00:00
0, 1, 0, 1, 2, 1, 3, 1, 4,
1, 5, 1, 6, 1, 7, 1, 8,
1, 9, 1, 10, 1, 11, 1, 12,
1, 13, 1, 14, 1, 15, 1, 18,
1, 19, 1, 20, 1, 21, 1, 22,
1, 23, 1, 24, 1, 25, 1, 26,
zclsyntax: scanning of bare (top-level) templates This alternative scanning mode makes the scanner start in template context rather than normal context. This will be later used by the parser to allow parsing of standalone templates that aren't embedded inside a zcl configuration file.
2017-05-29 16:42:20 +00:00
1, 27, 1, 30, 1, 31, 1, 32,
1, 33, 1, 34, 1, 35, 1, 36,
1, 37, 1, 38, 1, 39, 1, 45,
1, 46, 1, 47, 1, 48, 1, 49,
1, 50, 1, 51, 1, 52, 1, 53,
1, 54, 1, 55, 1, 56, 1, 57,
1, 58, 1, 59, 1, 60, 1, 61,
1, 62, 1, 63, 1, 64, 1, 65,
1, 66, 1, 67, 1, 68, 1, 69,
zclwrite: absorb lead comments into attributes The native parser's ranges don't include any surrounding comments, so we need to do a little more work to pick them out of the surrounding token sequences. This just takes care of _lead_ comments, which are those that appear as whole line comments above the item in question. Line comments, which appear after the item on the same line, will follow in a later commit.
2017-06-08 16:04:27 +00:00
1, 70, 1, 71, 1, 72, 1, 73,
2, 0, 1, 2, 3, 16, 2, 3,
17, 2, 3, 28, 2, 3, 29, 2,
3, 40, 2, 3, 41, 2, 3, 42,
2, 3, 43, 2, 3, 44,
zclsyntax: start of a ragel-based scanner Using Ragel here because the scanner is going to be somewhat complex due to the need to switch back and forth between normal and template states, etc. This should be easier to maintain than a hand-written scanner, while ragel gives us the extra features we need to implement things that would normally be too complex for a "regular" scanner generator.
2017-05-28 02:01:43 +00:00
}
zclsyntax: identifiers in the scanner
2017-05-28 16:16:53 +00:00
var _zcltok_key_offsets []int16 = []int16{
zclsyntax: scanning of comments
2017-05-29 16:13:35 +00:00
0, 0, 1, 2, 4, 8, 10, 51,
91, 136, 137, 141, 147, 147, 149, 151,
160, 166, 173, 174, 177, 178, 182, 187,
196, 200, 204, 212, 214, 216, 218, 221,
253, 255, 257, 261, 265, 268, 279, 292,
311, 324, 340, 352, 368, 383, 404, 414,
426, 437, 451, 466, 476, 488, 497, 509,
511, 515, 536, 545, 555, 561, 567, 568,
617, 619, 623, 625, 631, 638, 646, 653,
656, 662, 666, 670, 672, 676, 680, 684,
690, 698, 706, 712, 714, 718, 720, 726,
730, 734, 738, 742, 747, 754, 760, 762,
764, 768, 770, 776, 780, 784, 794, 799,
813, 828, 830, 838, 840, 845, 859, 864,
866, 870, 871, 875, 881, 887, 897, 907,
918, 926, 929, 932, 936, 940, 942, 945,
945, 948, 950, 980, 982, 984, 988, 993,
997, 1002, 1004, 1006, 1008, 1017, 1021, 1025,
1031, 1033, 1041, 1049, 1061, 1064, 1070, 1074,
1076, 1080, 1100, 1102, 1104, 1115, 1121, 1123,
1125, 1127, 1131, 1137, 1143, 1145, 1150, 1154,
1156, 1164, 1182, 1222, 1232, 1236, 1238, 1240,
1241, 1245, 1249, 1253, 1257, 1261, 1266, 1270,
1274, 1278, 1280, 1282, 1286, 1296, 1300, 1302,
1306, 1310, 1314, 1327, 1329, 1331, 1335, 1337,
1341, 1343, 1345, 1375, 1379, 1383, 1387, 1390,
1397, 1402, 1413, 1417, 1433, 1447, 1451, 1456,
1460, 1464, 1470, 1472, 1478, 1480, 1484, 1486,
1492, 1497, 1502, 1512, 1514, 1516, 1520, 1524,
1526, 1539, 1541, 1545, 1549, 1557, 1559, 1563,
1565, 1566, 1569, 1574, 1576, 1578, 1582, 1584,
1588, 1594, 1614, 1620, 1626, 1628, 1629, 1639,
1640, 1648, 1655, 1657, 1660, 1662, 1664, 1666,
1671, 1675, 1679, 1684, 1694, 1704, 1708, 1712,
1726, 1752, 1762, 1764, 1766, 1769, 1771, 1774,
1776, 1780, 1782, 1783, 1787, 1789, 1792, 1799,
1807, 1809, 1811, 1815, 1817, 1823, 1834, 1837,
1839, 1843, 1848, 1878, 1883, 1885, 1888, 1893,
1907, 1914, 1928, 1933, 1946, 1950, 1963, 1968,
1986, 1987, 1996, 2000, 2012, 2017, 2024, 2031,
2038, 2040, 2044, 2066, 2071, 2072, 2076, 2078,
2128, 2131, 2142, 2146, 2148, 2154, 2160, 2162,
2167, 2169, 2173, 2175, 2176, 2178, 2180, 2186,
2188, 2190, 2194, 2200, 2213, 2215, 2221, 2225,
2233, 2244, 2252, 2255, 2285, 2291, 2294, 2299,
2301, 2305, 2309, 2313, 2315, 2322, 2324, 2333,
2340, 2348, 2350, 2370, 2382, 2386, 2388, 2406,
2445, 2447, 2451, 2453, 2460, 2464, 2492, 2494,
2496, 2498, 2500, 2503, 2505, 2509, 2513, 2515,
2518, 2520, 2522, 2525, 2527, 2529, 2530, 2532,
2534, 2538, 2542, 2545, 2558, 2560, 2566, 2570,
2572, 2576, 2580, 2594, 2597, 2606, 2608, 2612,
2618, 2618, 2620, 2622, 2631, 2637, 2644, 2645,
2648, 2649, 2653, 2658, 2667, 2671, 2675, 2683,
2685, 2687, 2689, 2692, 2724, 2726, 2728, 2732,
2736, 2739, 2750, 2763, 2782, 2795, 2811, 2823,
2839, 2854, 2875, 2885, 2897, 2908, 2922, 2937,
2947, 2959, 2968, 2980, 2982, 2986, 3007, 3016,
3026, 3032, 3038, 3039, 3088, 3090, 3094, 3096,
3102, 3109, 3117, 3124, 3127, 3133, 3137, 3141,
3143, 3147, 3151, 3155, 3161, 3169, 3177, 3183,
3185, 3189, 3191, 3197, 3201, 3205, 3209, 3213,
3218, 3225, 3231, 3233, 3235, 3239, 3241, 3247,
3251, 3255, 3265, 3270, 3284, 3299, 3301, 3309,
3311, 3316, 3330, 3335, 3337, 3341, 3342, 3346,
3352, 3358, 3368, 3378, 3389, 3397, 3400, 3403,
3407, 3411, 3413, 3416, 3416, 3419, 3421, 3451,
3453, 3455, 3459, 3464, 3468, 3473, 3475, 3477,
3479, 3488, 3492, 3496, 3502, 3504, 3512, 3520,
3532, 3535, 3541, 3545, 3547, 3551, 3571, 3573,
3575, 3586, 3592, 3594, 3596, 3598, 3602, 3608,
3614, 3616, 3621, 3625, 3627, 3635, 3653, 3693,
3703, 3707, 3709, 3711, 3712, 3716, 3720, 3724,
3728, 3732, 3737, 3741, 3745, 3749, 3751, 3753,
3757, 3767, 3771, 3773, 3777, 3781, 3785, 3798,
3800, 3802, 3806, 3808, 3812, 3814, 3816, 3846,
3850, 3854, 3858, 3861, 3868, 3873, 3884, 3888,
3904, 3918, 3922, 3927, 3931, 3935, 3941, 3943,
3949, 3951, 3955, 3957, 3963, 3968, 3973, 3983,
3985, 3987, 3991, 3995, 3997, 4010, 4012, 4016,
4020, 4028, 4030, 4034, 4036, 4037, 4040, 4045,
4047, 4049, 4053, 4055, 4059, 4065, 4085, 4091,
4097, 4099, 4100, 4110, 4111, 4119, 4126, 4128,
4131, 4133, 4135, 4137, 4142, 4146, 4150, 4155,
4165, 4175, 4179, 4183, 4197, 4223, 4233, 4235,
4237, 4240, 4242, 4245, 4247, 4251, 4253, 4254,
4258, 4260, 4262, 4269, 4273, 4280, 4287, 4296,
4312, 4324, 4342, 4353, 4365, 4373, 4391, 4399,
4429, 4432, 4442, 4452, 4464, 4475, 4484, 4497,
4509, 4513, 4519, 4546, 4555, 4558, 4563, 4569,
4574, 4595, 4599, 4605, 4605, 4612, 4621, 4629,
4632, 4636, 4642, 4648, 4651, 4655, 4662, 4668,
4677, 4686, 4690, 4694, 4698, 4702, 4709, 4713,
4717, 4727, 4733, 4737, 4743, 4747, 4750, 4756,
4762, 4774, 4778, 4782, 4792, 4796, 4807, 4809,
4811, 4815, 4827, 4832, 4856, 4860, 4866, 4888,
4897, 4901, 4904, 4905, 4913, 4921, 4927, 4937,
4944, 4962, 4965, 4968, 4976, 4982, 4986, 4990,
4994, 5000, 5008, 5013, 5019, 5023, 5031, 5038,
5042, 5049, 5055, 5063, 5071, 5077, 5083, 5094,
5098, 5110, 5119, 5136, 5153, 5156, 5160, 5162,
5168, 5170, 5174, 5189, 5193, 5197, 5201, 5205,
5209, 5211, 5217, 5222, 5226, 5232, 5239, 5242,
5260, 5262, 5307, 5313, 5319, 5323, 5327, 5333,
5337, 5343, 5349, 5356, 5358, 5364, 5370, 5374,
5378, 5386, 5399, 5405, 5412, 5420, 5426, 5435,
5441, 5445, 5450, 5454, 5462, 5466, 5470, 5500,
5506, 5512, 5518, 5524, 5531, 5537, 5544, 5549,
5559, 5563, 5570, 5576, 5580, 5587, 5591, 5597,
5600, 5604, 5608, 5612, 5616, 5621, 5626, 5630,
5641, 5645, 5649, 5655, 5663, 5667, 5684, 5688,
5694, 5704, 5710, 5716, 5719, 5724, 5733, 5737,
5741, 5747, 5751, 5757, 5765, 5783, 5784, 5794,
5795, 5804, 5812, 5814, 5817, 5819, 5821, 5823,
5828, 5841, 5845, 5860, 5889, 5900, 5902, 5906,
5910, 5915, 5919, 5921, 5928, 5932, 5940, 5944,
5945, 5947, 5949, 5951, 5953, 5955, 5956, 5957,
zclsyntax: scanning of bare (top-level) templates This alternative scanning mode makes the scanner start in template context rather than normal context. This will be later used by the parser to allow parsing of standalone templates that aren't embedded inside a zcl configuration file.
2017-05-29 16:42:20 +00:00
5959, 5961, 5963, 5964, 5965, 5966, 5967, 5969,
zclsyntax: separate tokens for assign = and equality test ==
2017-06-04 23:00:40 +00:00
5971, 5973, 5974, 5975, 6049, 6050, 6051, 6052,
6053, 6054, 6055, 6057, 6058, 6063, 6065, 6066,
6067, 6110, 6111, 6112, 6114, 6119, 6123, 6123,
6125, 6127, 6138, 6148, 6156, 6157, 6159, 6160,
6164, 6168, 6178, 6182, 6189, 6200, 6207, 6211,
6217, 6228, 6260, 6309, 6324, 6339, 6344, 6346,
6351, 6383, 6391, 6393, 6415, 6437, 6439, 6455,
6471, 6486, 6495, 6509, 6523, 6539, 6540, 6541,
6542, 6543, 6545, 6547, 6549, 6563, 6577, 6578,
6579, 6581, 6583, 6585, 6599, 6613, 6614, 6615,
6617, 6619,
zclsyntax: start of a ragel-based scanner Using Ragel here because the scanner is going to be somewhat complex due to the need to switch back and forth between normal and template states, etc. This should be easier to maintain than a hand-written scanner, while ragel gives us the extra features we need to implement things that would normally be too complex for a "regular" scanner generator.
2017-05-28 02:01:43 +00:00
}
var _zcltok_trans_keys []byte = []byte{
zclsyntax: scanning of comments
2017-05-29 16:13:35 +00:00
10, 42, 42, 47, 43, 45, 48, 57,
48, 57, 45, 194, 195, 198, 199, 203,
zclsyntax: heredoc support in the scanner
2017-05-29 15:55:53 +00:00
205, 206, 207, 210, 212, 213, 214, 215,
216, 217, 219, 220, 221, 222, 223, 224,
225, 226, 227, 228, 233, 234, 237, 239,
zclsyntax: scanning of comments
2017-05-29 16:13:35 +00:00
240, 65, 90, 97, 122, 196, 202, 208,
218, 229, 236, 194, 195, 198, 199, 203,
205, 206, 207, 210, 212, 213, 214, 215,
216, 217, 219, 220, 221, 222, 223, 224,
225, 226, 227, 228, 233, 234, 237, 239,
240, 65, 90, 97, 122, 196, 202, 208,
218, 229, 236, 10, 13, 95, 194, 195,
198, 199, 203, 204, 205, 206, 207, 210,
212, 213, 214, 215, 216, 217, 219, 220,
221, 222, 223, 224, 225, 226, 227, 228,
233, 234, 237, 239, 240, 243, 48, 57,
65, 90, 97, 122, 196, 218, 229, 236,
10, 170, 181, 183, 186, 128, 150, 152,
zclwrite: absorb lead comments into attributes The native parser's ranges don't include any surrounding comments, so we need to do a little more work to pick them out of the surrounding token sequences. This just takes care of _lead_ comments, which are those that appear as whole line comments above the item in question. Line comments, which appear after the item on the same line, will follow in a later commit.
2017-06-08 16:04:27 +00:00
182, 184, 255, 192, 255, 0, 127, 173,
zclsyntax: scanning of comments
2017-05-29 16:13:35 +00:00
130, 133, 146, 159, 165, 171, 175, 255,
181, 190, 184, 185, 192, 255, 140, 134,
138, 142, 161, 163, 255, 182, 130, 136,
137, 176, 151, 152, 154, 160, 190, 136,
144, 192, 255, 135, 129, 130, 132, 133,
144, 170, 176, 178, 144, 154, 160, 191,
128, 169, 174, 255, 148, 169, 157, 158,
189, 190, 192, 255, 144, 255, 139, 140,
178, 255, 186, 128, 181, 160, 161, 162,
zclsyntax: heredoc support in the scanner
2017-05-29 15:55:53 +00:00
163, 164, 165, 166, 167, 168, 169, 170,
zclsyntax: scanning of comments
2017-05-29 16:13:35 +00:00
171, 172, 173, 174, 175, 176, 177, 178,
179, 180, 181, 182, 183, 184, 185, 186,
187, 188, 189, 190, 191, 128, 173, 128,
155, 160, 180, 182, 189, 148, 161, 163,
255, 176, 164, 165, 132, 169, 177, 141,
142, 145, 146, 179, 181, 186, 187, 158,
133, 134, 137, 138, 143, 150, 152, 155,
164, 165, 178, 255, 188, 129, 131, 133,
138, 143, 144, 147, 168, 170, 176, 178,
179, 181, 182, 184, 185, 190, 255, 157,
131, 134, 137, 138, 142, 144, 146, 152,
159, 165, 182, 255, 129, 131, 133, 141,
143, 145, 147, 168, 170, 176, 178, 179,
181, 185, 188, 255, 134, 138, 142, 143,
145, 159, 164, 165, 176, 184, 186, 255,
129, 131, 133, 140, 143, 144, 147, 168,
170, 176, 178, 179, 181, 185, 188, 191,
177, 128, 132, 135, 136, 139, 141, 150,
151, 156, 157, 159, 163, 166, 175, 156,
130, 131, 133, 138, 142, 144, 146, 149,
153, 154, 158, 159, 163, 164, 168, 170,
174, 185, 190, 191, 144, 151, 128, 130,
134, 136, 138, 141, 166, 175, 128, 131,
zclsyntax: heredoc support in the scanner
2017-05-29 15:55:53 +00:00
133, 140, 142, 144, 146, 168, 170, 185,
zclsyntax: scanning of comments
2017-05-29 16:13:35 +00:00
189, 255, 133, 137, 151, 142, 148, 155,
159, 164, 165, 176, 255, 128, 131, 133,
140, 142, 144, 146, 168, 170, 179, 181,
185, 188, 191, 158, 128, 132, 134, 136,
138, 141, 149, 150, 160, 163, 166, 175,
177, 178, 129, 131, 133, 140, 142, 144,
146, 186, 189, 255, 133, 137, 143, 147,
152, 158, 164, 165, 176, 185, 192, 255,
189, 130, 131, 133, 150, 154, 177, 179,
187, 138, 150, 128, 134, 143, 148, 152,
159, 166, 175, 178, 179, 129, 186, 128,
142, 144, 153, 132, 138, 141, 165, 167,
129, 130, 135, 136, 148, 151, 153, 159,
161, 163, 170, 171, 173, 185, 187, 189,
134, 128, 132, 136, 141, 144, 153, 156,
159, 128, 181, 183, 185, 152, 153, 160,
169, 190, 191, 128, 135, 137, 172, 177,
191, 128, 132, 134, 151, 153, 188, 134,
128, 129, 130, 131, 137, 138, 139, 140,
141, 142, 143, 144, 153, 154, 155, 156,
157, 158, 159, 160, 161, 162, 163, 164,
165, 166, 167, 168, 169, 170, 173, 175,
176, 177, 178, 179, 181, 182, 183, 188,
189, 190, 191, 132, 152, 172, 184, 185,
187, 128, 191, 128, 137, 144, 255, 158,
159, 134, 187, 136, 140, 142, 143, 137,
151, 153, 142, 143, 158, 159, 137, 177,
142, 143, 182, 183, 191, 255, 128, 130,
133, 136, 150, 152, 255, 145, 150, 151,
155, 156, 160, 168, 178, 255, 128, 143,
160, 255, 182, 183, 190, 255, 129, 255,
173, 174, 192, 255, 129, 154, 160, 255,
171, 173, 185, 255, 128, 140, 142, 148,
160, 180, 128, 147, 160, 172, 174, 176,
178, 179, 148, 150, 152, 155, 158, 159,
170, 255, 139, 141, 144, 153, 160, 255,
184, 255, 128, 170, 176, 255, 182, 255,
128, 158, 160, 171, 176, 187, 134, 173,
176, 180, 128, 171, 176, 255, 138, 143,
155, 255, 128, 155, 160, 255, 159, 189,
190, 192, 255, 167, 128, 137, 144, 153,
176, 189, 140, 143, 154, 170, 180, 255,
180, 255, 128, 183, 128, 137, 141, 189,
128, 136, 144, 146, 148, 182, 184, 185,
128, 181, 187, 191, 150, 151, 158, 159,
152, 154, 156, 158, 134, 135, 142, 143,
190, 255, 190, 128, 180, 182, 188, 130,
132, 134, 140, 144, 147, 150, 155, 160,
172, 178, 180, 182, 188, 128, 129, 130,
131, 132, 133, 134, 176, 177, 178, 179,
180, 181, 182, 183, 191, 255, 129, 147,
149, 176, 178, 190, 192, 255, 144, 156,
161, 144, 156, 165, 176, 130, 135, 149,
164, 166, 168, 138, 147, 152, 157, 170,
185, 188, 191, 142, 133, 137, 160, 255,
137, 255, 128, 174, 176, 255, 159, 165,
170, 180, 255, 167, 173, 128, 165, 176,
255, 168, 174, 176, 190, 192, 255, 128,
150, 160, 166, 168, 174, 176, 182, 184,
190, 128, 134, 136, 142, 144, 150, 152,
158, 160, 191, 128, 129, 130, 131, 132,
133, 134, 135, 144, 145, 255, 133, 135,
161, 175, 177, 181, 184, 188, 160, 151,
152, 187, 192, 255, 133, 173, 177, 255,
143, 159, 187, 255, 176, 191, 182, 183,
184, 191, 192, 255, 150, 255, 128, 146,
147, 148, 152, 153, 154, 155, 156, 158,
159, 160, 161, 162, 163, 164, 165, 166,
167, 168, 169, 170, 171, 172, 173, 174,
175, 176, 129, 255, 141, 255, 144, 189,
141, 143, 172, 255, 191, 128, 175, 180,
189, 151, 159, 162, 255, 175, 137, 138,
184, 255, 183, 255, 168, 255, 128, 179,
188, 134, 143, 154, 159, 184, 186, 190,
255, 128, 173, 176, 255, 148, 159, 189,
255, 129, 142, 154, 159, 191, 255, 128,
182, 128, 141, 144, 153, 160, 182, 186,
255, 128, 130, 155, 157, 160, 175, 178,
182, 129, 134, 137, 142, 145, 150, 160,
166, 168, 174, 176, 255, 155, 166, 175,
128, 170, 172, 173, 176, 185, 158, 159,
160, 255, 164, 175, 135, 138, 188, 255,
164, 169, 171, 172, 173, 174, 175, 180,
181, 182, 183, 184, 185, 187, 188, 189,
190, 191, 165, 186, 174, 175, 154, 255,
190, 128, 134, 147, 151, 157, 168, 170,
182, 184, 188, 128, 129, 131, 132, 134,
255, 147, 255, 190, 255, 144, 145, 136,
175, 188, 255, 128, 143, 160, 175, 179,
180, 141, 143, 176, 180, 182, 255, 189,
255, 191, 144, 153, 161, 186, 129, 154,
166, 255, 191, 255, 130, 135, 138, 143,
146, 151, 154, 156, 144, 145, 146, 147,
148, 150, 151, 152, 155, 157, 158, 160,
170, 171, 172, 175, 161, 169, 128, 129,
130, 131, 133, 135, 138, 139, 140, 141,
142, 143, 144, 145, 146, 147, 148, 149,
152, 156, 157, 160, 161, 162, 163, 164,
166, 168, 169, 170, 171, 172, 173, 174,
176, 177, 153, 155, 178, 179, 128, 139,
141, 166, 168, 186, 188, 189, 191, 255,
142, 143, 158, 255, 187, 255, 128, 180,
189, 128, 156, 160, 255, 145, 159, 161,
255, 128, 159, 176, 255, 139, 143, 187,
255, 128, 157, 160, 255, 144, 132, 135,
150, 255, 158, 159, 170, 175, 148, 151,
188, 255, 128, 167, 176, 255, 164, 255,
183, 255, 128, 149, 160, 167, 136, 188,
128, 133, 138, 181, 183, 184, 191, 255,
150, 159, 183, 255, 128, 158, 160, 178,
180, 181, 128, 149, 160, 185, 128, 183,
190, 191, 191, 128, 131, 133, 134, 140,
147, 149, 151, 153, 179, 184, 186, 160,
188, 128, 156, 128, 135, 137, 166, 128,
181, 128, 149, 160, 178, 128, 145, 128,
178, 129, 130, 131, 132, 133, 135, 136,
138, 139, 140, 141, 144, 145, 146, 147,
150, 151, 152, 153, 154, 155, 156, 162,
163, 171, 176, 177, 178, 128, 134, 135,
165, 176, 190, 144, 168, 176, 185, 128,
180, 182, 191, 182, 144, 179, 155, 133,
137, 141, 143, 157, 255, 190, 128, 145,
147, 183, 136, 128, 134, 138, 141, 143,
157, 159, 168, 176, 255, 171, 175, 186,
255, 128, 131, 133, 140, 143, 144, 147,
168, 170, 176, 178, 179, 181, 185, 188,
191, 144, 151, 128, 132, 135, 136, 139,
141, 157, 163, 166, 172, 176, 180, 128,
138, 144, 153, 134, 136, 143, 154, 255,
128, 181, 184, 255, 129, 151, 158, 255,
129, 131, 133, 143, 154, 255, 128, 137,
128, 153, 157, 171, 176, 185, 160, 255,
170, 190, 192, 255, 128, 184, 128, 136,
138, 182, 184, 191, 128, 144, 153, 178,
255, 168, 144, 145, 183, 255, 128, 142,
145, 149, 129, 141, 144, 146, 147, 148,
175, 255, 132, 255, 128, 144, 129, 143,
144, 153, 145, 152, 135, 255, 160, 168,
169, 171, 172, 173, 174, 188, 189, 190,
191, 161, 167, 185, 255, 128, 158, 160,
169, 144, 173, 176, 180, 128, 131, 144,
153, 163, 183, 189, 255, 144, 255, 133,
143, 191, 255, 143, 159, 160, 128, 129,
255, 159, 160, 171, 172, 255, 173, 255,
179, 255, 128, 176, 177, 178, 128, 129,
171, 175, 189, 255, 128, 136, 144, 153,
157, 158, 133, 134, 137, 144, 145, 146,
147, 148, 149, 154, 155, 156, 157, 158,
159, 168, 169, 170, 150, 153, 165, 169,
173, 178, 187, 255, 131, 132, 140, 169,
174, 255, 130, 132, 149, 157, 173, 186,
188, 160, 161, 163, 164, 167, 168, 132,
134, 149, 157, 186, 139, 140, 191, 255,
134, 128, 132, 138, 144, 146, 255, 166,
167, 129, 155, 187, 149, 181, 143, 175,
137, 169, 131, 140, 141, 192, 255, 128,
182, 187, 255, 173, 180, 182, 255, 132,
155, 159, 161, 175, 128, 160, 163, 164,
165, 184, 185, 186, 161, 162, 128, 134,
136, 152, 155, 161, 163, 164, 166, 170,
133, 143, 151, 255, 139, 143, 154, 255,
164, 167, 185, 187, 128, 131, 133, 159,
161, 162, 169, 178, 180, 183, 130, 135,
137, 139, 148, 151, 153, 155, 157, 159,
164, 190, 141, 143, 145, 146, 161, 162,
167, 170, 172, 178, 180, 183, 185, 188,
128, 137, 139, 155, 161, 163, 165, 169,
171, 187, 155, 156, 151, 255, 156, 157,
160, 181, 255, 186, 187, 255, 162, 255,
160, 168, 161, 167, 158, 255, 160, 132,
135, 133, 134, 176, 255, 170, 181, 186,
191, 176, 180, 182, 183, 186, 189, 134,
140, 136, 138, 142, 161, 163, 255, 130,
137, 136, 255, 144, 170, 176, 178, 160,
191, 128, 138, 174, 175, 177, 255, 148,
150, 164, 167, 173, 176, 185, 189, 190,
192, 255, 144, 146, 175, 141, 255, 166,
176, 178, 255, 186, 138, 170, 180, 181,
160, 161, 162, 164, 165, 166, 167, 168,
169, 170, 171, 172, 173, 174, 175, 176,
177, 178, 179, 180, 181, 182, 184, 186,
187, 188, 189, 190, 183, 185, 154, 164,
168, 128, 149, 128, 152, 189, 132, 185,
144, 152, 161, 177, 255, 169, 177, 129,
132, 141, 142, 145, 146, 179, 181, 186,
188, 190, 255, 142, 156, 157, 159, 161,
176, 177, 133, 138, 143, 144, 147, 168,
zclsyntax: heredoc support in the scanner
2017-05-29 15:55:53 +00:00
170, 176, 178, 179, 181, 182, 184, 185,
zclsyntax: scanning of comments
2017-05-29 16:13:35 +00:00
158, 153, 156, 178, 180, 189, 133, 141,
143, 145, 147, 168, 170, 176, 178, 179,
181, 185, 144, 185, 160, 161, 189, 133,
140, 143, 144, 147, 168, 170, 176, 178,
179, 181, 185, 177, 156, 157, 159, 161,
131, 156, 133, 138, 142, 144, 146, 149,
153, 154, 158, 159, 163, 164, 168, 170,
174, 185, 144, 189, 133, 140, 142, 144,
146, 168, 170, 185, 152, 154, 160, 161,
128, 189, 133, 140, 142, 144, 146, 168,
170, 179, 181, 185, 158, 160, 161, 177,
178, 189, 133, 140, 142, 144, 146, 186,
142, 148, 150, 159, 161, 186, 191, 189,
133, 150, 154, 177, 179, 187, 128, 134,
129, 176, 178, 179, 132, 138, 141, 165,
167, 189, 129, 130, 135, 136, 148, 151,
153, 159, 161, 163, 170, 171, 173, 176,
178, 179, 134, 128, 132, 156, 159, 128,
128, 135, 137, 172, 136, 140, 128, 129,
130, 131, 137, 138, 139, 140, 141, 142,
143, 144, 153, 154, 155, 156, 157, 158,
159, 160, 161, 162, 163, 164, 165, 166,
167, 168, 169, 170, 172, 173, 174, 175,
176, 177, 178, 179, 180, 181, 182, 184,
188, 189, 190, 191, 132, 152, 185, 187,
191, 128, 170, 161, 144, 149, 154, 157,
165, 166, 174, 176, 181, 255, 130, 141,
143, 159, 155, 255, 128, 140, 142, 145,
160, 177, 128, 145, 160, 172, 174, 176,
151, 156, 170, 128, 168, 176, 255, 138,
255, 128, 150, 160, 255, 149, 255, 167,
133, 179, 133, 139, 131, 160, 174, 175,
186, 255, 166, 255, 128, 163, 141, 143,
154, 189, 169, 172, 174, 177, 181, 182,
129, 130, 132, 133, 134, 176, 177, 178,
179, 180, 181, 182, 183, 177, 191, 165,
170, 175, 177, 180, 255, 168, 174, 176,
255, 128, 134, 136, 142, 144, 150, 152,
158, 128, 129, 130, 131, 132, 133, 134,
135, 144, 145, 255, 133, 135, 161, 169,
177, 181, 184, 188, 160, 151, 154, 128,
146, 147, 148, 152, 153, 154, 155, 156,
158, 159, 160, 161, 162, 163, 164, 165,
166, 167, 168, 169, 170, 171, 172, 173,
174, 175, 176, 129, 255, 141, 143, 160,
169, 172, 255, 191, 128, 174, 130, 134,
139, 163, 255, 130, 179, 187, 189, 178,
183, 138, 165, 176, 255, 135, 159, 189,
255, 132, 178, 143, 160, 164, 166, 175,
186, 190, 128, 168, 186, 128, 130, 132,
139, 160, 182, 190, 255, 176, 178, 180,
183, 184, 190, 255, 128, 130, 155, 157,
160, 170, 178, 180, 128, 162, 164, 169,
171, 172, 173, 174, 175, 180, 181, 182,
183, 185, 186, 187, 188, 189, 190, 191,
165, 179, 157, 190, 128, 134, 147, 151,
159, 168, 170, 182, 184, 188, 176, 180,
182, 255, 161, 186, 144, 145, 146, 147,
148, 150, 151, 152, 155, 157, 158, 160,
170, 171, 172, 175, 161, 169, 128, 129,
130, 131, 133, 138, 139, 140, 141, 142,
143, 144, 145, 146, 147, 148, 149, 152,
156, 157, 160, 161, 162, 163, 164, 166,
168, 169, 170, 171, 172, 173, 174, 176,
177, 153, 155, 178, 179, 145, 255, 139,
143, 182, 255, 158, 175, 128, 144, 147,
149, 151, 153, 179, 128, 135, 137, 164,
128, 130, 131, 132, 133, 134, 135, 136,
138, 139, 140, 141, 144, 145, 146, 147,
150, 151, 152, 153, 154, 156, 162, 163,
171, 176, 177, 178, 131, 183, 131, 175,
144, 168, 131, 166, 182, 144, 178, 131,
178, 154, 156, 129, 132, 128, 145, 147,
171, 159, 255, 144, 157, 161, 135, 138,
128, 175, 135, 132, 133, 128, 174, 152,
155, 132, 128, 170, 128, 153, 160, 190,
192, 255, 128, 136, 138, 174, 128, 178,
zclsyntax: identifiers in the scanner
2017-05-28 16:16:53 +00:00
255, 160, 168, 169, 171, 172, 173, 174,
zclsyntax: scanning of comments
2017-05-29 16:13:35 +00:00
188, 189, 190, 191, 161, 167, 144, 173,
128, 131, 163, 183, 189, 255, 133, 143,
145, 255, 147, 159, 128, 176, 177, 178,
128, 136, 144, 153, 144, 145, 146, 147,
148, 149, 154, 155, 156, 157, 158, 159,
150, 153, 131, 140, 255, 160, 163, 164,
165, 184, 185, 186, 161, 162, 133, 255,
170, 181, 183, 186, 128, 150, 152, 182,
184, 255, 192, 255, 128, 255, 173, 130,
133, 146, 159, 165, 171, 175, 255, 181,
190, 184, 185, 192, 255, 140, 134, 138,
142, 161, 163, 255, 182, 130, 136, 137,
176, 151, 152, 154, 160, 190, 136, 144,
192, 255, 135, 129, 130, 132, 133, 144,
170, 176, 178, 144, 154, 160, 191, 128,
169, 174, 255, 148, 169, 157, 158, 189,
190, 192, 255, 144, 255, 139, 140, 178,
255, 186, 128, 181, 160, 161, 162, 163,
zclsyntax: heredoc support in the scanner
2017-05-29 15:55:53 +00:00
164, 165, 166, 167, 168, 169, 170, 171,
172, 173, 174, 175, 176, 177, 178, 179,
180, 181, 182, 183, 184, 185, 186, 187,
zclsyntax: scanning of comments
2017-05-29 16:13:35 +00:00
188, 189, 190, 191, 128, 173, 128, 155,
160, 180, 182, 189, 148, 161, 163, 255,
176, 164, 165, 132, 169, 177, 141, 142,
145, 146, 179, 181, 186, 187, 158, 133,
134, 137, 138, 143, 150, 152, 155, 164,
165, 178, 255, 188, 129, 131, 133, 138,
143, 144, 147, 168, 170, 176, 178, 179,
181, 182, 184, 185, 190, 255, 157, 131,
134, 137, 138, 142, 144, 146, 152, 159,
165, 182, 255, 129, 131, 133, 141, 143,
145, 147, 168, 170, 176, 178, 179, 181,
185, 188, 255, 134, 138, 142, 143, 145,
159, 164, 165, 176, 184, 186, 255, 129,
131, 133, 140, 143, 144, 147, 168, 170,
176, 178, 179, 181, 185, 188, 191, 177,
128, 132, 135, 136, 139, 141, 150, 151,
156, 157, 159, 163, 166, 175, 156, 130,
131, 133, 138, 142, 144, 146, 149, 153,
154, 158, 159, 163, 164, 168, 170, 174,
185, 190, 191, 144, 151, 128, 130, 134,
136, 138, 141, 166, 175, 128, 131, 133,
140, 142, 144, 146, 168, 170, 185, 189,
255, 133, 137, 151, 142, 148, 155, 159,
164, 165, 176, 255, 128, 131, 133, 140,
142, 144, 146, 168, 170, 179, 181, 185,
188, 191, 158, 128, 132, 134, 136, 138,
141, 149, 150, 160, 163, 166, 175, 177,
178, 129, 131, 133, 140, 142, 144, 146,
186, 189, 255, 133, 137, 143, 147, 152,
158, 164, 165, 176, 185, 192, 255, 189,
130, 131, 133, 150, 154, 177, 179, 187,
138, 150, 128, 134, 143, 148, 152, 159,
166, 175, 178, 179, 129, 186, 128, 142,
144, 153, 132, 138, 141, 165, 167, 129,
130, 135, 136, 148, 151, 153, 159, 161,
163, 170, 171, 173, 185, 187, 189, 134,
128, 132, 136, 141, 144, 153, 156, 159,
128, 181, 183, 185, 152, 153, 160, 169,
190, 191, 128, 135, 137, 172, 177, 191,
128, 132, 134, 151, 153, 188, 134, 128,
129, 130, 131, 137, 138, 139, 140, 141,
142, 143, 144, 153, 154, 155, 156, 157,
158, 159, 160, 161, 162, 163, 164, 165,
166, 167, 168, 169, 170, 173, 175, 176,
177, 178, 179, 181, 182, 183, 188, 189,
190, 191, 132, 152, 172, 184, 185, 187,
128, 191, 128, 137, 144, 255, 158, 159,
134, 187, 136, 140, 142, 143, 137, 151,
153, 142, 143, 158, 159, 137, 177, 142,
143, 182, 183, 191, 255, 128, 130, 133,
136, 150, 152, 255, 145, 150, 151, 155,
156, 160, 168, 178, 255, 128, 143, 160,
255, 182, 183, 190, 255, 129, 255, 173,
174, 192, 255, 129, 154, 160, 255, 171,
173, 185, 255, 128, 140, 142, 148, 160,
180, 128, 147, 160, 172, 174, 176, 178,
179, 148, 150, 152, 155, 158, 159, 170,
255, 139, 141, 144, 153, 160, 255, 184,
255, 128, 170, 176, 255, 182, 255, 128,
158, 160, 171, 176, 187, 134, 173, 176,
180, 128, 171, 176, 255, 138, 143, 155,
255, 128, 155, 160, 255, 159, 189, 190,
192, 255, 167, 128, 137, 144, 153, 176,
189, 140, 143, 154, 170, 180, 255, 180,
255, 128, 183, 128, 137, 141, 189, 128,
136, 144, 146, 148, 182, 184, 185, 128,
181, 187, 191, 150, 151, 158, 159, 152,
154, 156, 158, 134, 135, 142, 143, 190,
255, 190, 128, 180, 182, 188, 130, 132,
134, 140, 144, 147, 150, 155, 160, 172,
178, 180, 182, 188, 128, 129, 130, 131,
132, 133, 134, 176, 177, 178, 179, 180,
181, 182, 183, 191, 255, 129, 147, 149,
176, 178, 190, 192, 255, 144, 156, 161,
144, 156, 165, 176, 130, 135, 149, 164,
166, 168, 138, 147, 152, 157, 170, 185,
188, 191, 142, 133, 137, 160, 255, 137,
255, 128, 174, 176, 255, 159, 165, 170,
180, 255, 167, 173, 128, 165, 176, 255,
168, 174, 176, 190, 192, 255, 128, 150,
160, 166, 168, 174, 176, 182, 184, 190,
128, 134, 136, 142, 144, 150, 152, 158,
160, 191, 128, 129, 130, 131, 132, 133,
134, 135, 144, 145, 255, 133, 135, 161,
175, 177, 181, 184, 188, 160, 151, 152,
187, 192, 255, 133, 173, 177, 255, 143,
159, 187, 255, 176, 191, 182, 183, 184,
191, 192, 255, 150, 255, 128, 146, 147,
148, 152, 153, 154, 155, 156, 158, 159,
zclsyntax: heredoc support in the scanner
2017-05-29 15:55:53 +00:00
160, 161, 162, 163, 164, 165, 166, 167,
168, 169, 170, 171, 172, 173, 174, 175,
zclsyntax: scanning of comments
2017-05-29 16:13:35 +00:00
176, 129, 255, 141, 255, 144, 189, 141,
143, 172, 255, 191, 128, 175, 180, 189,
151, 159, 162, 255, 175, 137, 138, 184,
255, 183, 255, 168, 255, 128, 179, 188,
134, 143, 154, 159, 184, 186, 190, 255,
128, 173, 176, 255, 148, 159, 189, 255,
129, 142, 154, 159, 191, 255, 128, 182,
128, 141, 144, 153, 160, 182, 186, 255,
128, 130, 155, 157, 160, 175, 178, 182,
129, 134, 137, 142, 145, 150, 160, 166,
168, 174, 176, 255, 155, 166, 175, 128,
170, 172, 173, 176, 185, 158, 159, 160,
255, 164, 175, 135, 138, 188, 255, 164,
169, 171, 172, 173, 174, 175, 180, 181,
182, 183, 184, 185, 187, 188, 189, 190,
191, 165, 186, 174, 175, 154, 255, 190,
128, 134, 147, 151, 157, 168, 170, 182,
184, 188, 128, 129, 131, 132, 134, 255,
147, 255, 190, 255, 144, 145, 136, 175,
188, 255, 128, 143, 160, 175, 179, 180,
141, 143, 176, 180, 182, 255, 189, 255,
191, 144, 153, 161, 186, 129, 154, 166,
255, 191, 255, 130, 135, 138, 143, 146,
151, 154, 156, 144, 145, 146, 147, 148,
150, 151, 152, 155, 157, 158, 160, 170,
171, 172, 175, 161, 169, 128, 129, 130,
131, 133, 135, 138, 139, 140, 141, 142,
143, 144, 145, 146, 147, 148, 149, 152,
156, 157, 160, 161, 162, 163, 164, 166,
168, 169, 170, 171, 172, 173, 174, 176,
177, 153, 155, 178, 179, 128, 139, 141,
166, 168, 186, 188, 189, 191, 255, 142,
143, 158, 255, 187, 255, 128, 180, 189,
128, 156, 160, 255, 145, 159, 161, 255,
128, 159, 176, 255, 139, 143, 187, 255,
128, 157, 160, 255, 144, 132, 135, 150,
255, 158, 159, 170, 175, 148, 151, 188,
255, 128, 167, 176, 255, 164, 255, 183,
255, 128, 149, 160, 167, 136, 188, 128,
133, 138, 181, 183, 184, 191, 255, 150,
159, 183, 255, 128, 158, 160, 178, 180,
181, 128, 149, 160, 185, 128, 183, 190,
191, 191, 128, 131, 133, 134, 140, 147,
149, 151, 153, 179, 184, 186, 160, 188,
128, 156, 128, 135, 137, 166, 128, 181,
128, 149, 160, 178, 128, 145, 128, 178,
129, 130, 131, 132, 133, 135, 136, 138,
139, 140, 141, 144, 145, 146, 147, 150,
151, 152, 153, 154, 155, 156, 162, 163,
171, 176, 177, 178, 128, 134, 135, 165,
176, 190, 144, 168, 176, 185, 128, 180,
182, 191, 182, 144, 179, 155, 133, 137,
141, 143, 157, 255, 190, 128, 145, 147,
183, 136, 128, 134, 138, 141, 143, 157,
159, 168, 176, 255, 171, 175, 186, 255,
128, 131, 133, 140, 143, 144, 147, 168,
170, 176, 178, 179, 181, 185, 188, 191,
144, 151, 128, 132, 135, 136, 139, 141,
157, 163, 166, 172, 176, 180, 128, 138,
144, 153, 134, 136, 143, 154, 255, 128,
181, 184, 255, 129, 151, 158, 255, 129,
131, 133, 143, 154, 255, 128, 137, 128,
153, 157, 171, 176, 185, 160, 255, 170,
190, 192, 255, 128, 184, 128, 136, 138,
182, 184, 191, 128, 144, 153, 178, 255,
168, 144, 145, 183, 255, 128, 142, 145,
149, 129, 141, 144, 146, 147, 148, 175,
255, 132, 255, 128, 144, 129, 143, 144,
153, 145, 152, 135, 255, 160, 168, 169,
171, 172, 173, 174, 188, 189, 190, 191,
161, 167, 185, 255, 128, 158, 160, 169,
144, 173, 176, 180, 128, 131, 144, 153,
163, 183, 189, 255, 144, 255, 133, 143,
191, 255, 143, 159, 160, 128, 129, 255,
159, 160, 171, 172, 255, 173, 255, 179,
255, 128, 176, 177, 178, 128, 129, 171,
175, 189, 255, 128, 136, 144, 153, 157,
158, 133, 134, 137, 144, 145, 146, 147,
148, 149, 154, 155, 156, 157, 158, 159,
168, 169, 170, 150, 153, 165, 169, 173,
178, 187, 255, 131, 132, 140, 169, 174,
255, 130, 132, 149, 157, 173, 186, 188,
160, 161, 163, 164, 167, 168, 132, 134,
149, 157, 186, 139, 140, 191, 255, 134,
128, 132, 138, 144, 146, 255, 166, 167,
129, 155, 187, 149, 181, 143, 175, 137,
169, 131, 140, 141, 192, 255, 128, 182,
187, 255, 173, 180, 182, 255, 132, 155,
159, 161, 175, 128, 160, 163, 164, 165,
184, 185, 186, 161, 162, 128, 134, 136,
152, 155, 161, 163, 164, 166, 170, 133,
143, 151, 255, 139, 143, 154, 255, 164,
167, 185, 187, 128, 131, 133, 159, 161,
162, 169, 178, 180, 183, 130, 135, 137,
139, 148, 151, 153, 155, 157, 159, 164,
190, 141, 143, 145, 146, 161, 162, 167,
170, 172, 178, 180, 183, 185, 188, 128,
137, 139, 155, 161, 163, 165, 169, 171,
187, 155, 156, 151, 255, 156, 157, 160,
181, 255, 186, 187, 255, 162, 255, 160,
168, 161, 167, 158, 255, 160, 132, 135,
133, 134, 176, 255, 128, 191, 154, 164,
168, 128, 149, 150, 191, 128, 152, 153,
191, 181, 128, 159, 160, 189, 190, 191,
189, 128, 131, 132, 185, 186, 191, 144,
128, 151, 152, 161, 162, 176, 177, 255,
169, 177, 129, 132, 141, 142, 145, 146,
179, 181, 186, 188, 190, 191, 192, 255,
142, 158, 128, 155, 156, 161, 162, 175,
176, 177, 178, 191, 169, 177, 180, 183,
128, 132, 133, 138, 139, 142, 143, 144,
145, 146, 147, 185, 186, 191, 157, 128,
152, 153, 158, 159, 177, 178, 180, 181,
191, 142, 146, 169, 177, 180, 189, 128,
132, 133, 185, 186, 191, 144, 185, 128,
159, 160, 161, 162, 191, 169, 177, 180,
189, 128, 132, 133, 140, 141, 142, 143,
144, 145, 146, 147, 185, 186, 191, 158,
177, 128, 155, 156, 161, 162, 191, 131,
145, 155, 157, 128, 132, 133, 138, 139,
141, 142, 149, 150, 152, 153, 159, 160,
162, 163, 164, 165, 167, 168, 170, 171,
173, 174, 185, 186, 191, 144, 128, 191,
141, 145, 169, 189, 128, 132, 133, 185,
186, 191, 128, 151, 152, 154, 155, 159,
160, 161, 162, 191, 128, 141, 145, 169,
180, 189, 129, 132, 133, 185, 186, 191,
158, 128, 159, 160, 161, 162, 176, 177,
178, 179, 191, 141, 145, 189, 128, 132,
133, 186, 187, 191, 142, 128, 147, 148,
150, 151, 158, 159, 161, 162, 185, 186,
191, 178, 188, 128, 132, 133, 150, 151,
153, 154, 189, 190, 191, 128, 134, 135,
191, 128, 177, 129, 179, 180, 191, 128,
131, 137, 141, 152, 160, 164, 166, 172,
177, 189, 129, 132, 133, 134, 135, 138,
139, 147, 148, 167, 168, 169, 170, 179,
180, 191, 133, 128, 134, 135, 155, 156,
159, 160, 191, 128, 129, 191, 136, 128,
172, 173, 191, 128, 135, 136, 140, 141,
191, 191, 128, 170, 171, 190, 161, 128,
143, 144, 149, 150, 153, 154, 157, 158,
164, 165, 166, 167, 173, 174, 176, 177,
180, 181, 255, 130, 141, 143, 159, 134,
187, 136, 140, 142, 143, 137, 151, 153,
142, 143, 158, 159, 137, 177, 191, 142,
143, 182, 183, 192, 255, 129, 151, 128,
133, 134, 135, 136, 255, 145, 150, 151,
155, 191, 192, 255, 128, 143, 144, 159,
160, 255, 182, 183, 190, 191, 192, 255,
128, 129, 255, 173, 174, 192, 255, 128,
129, 154, 155, 159, 160, 255, 171, 173,
185, 191, 192, 255, 141, 128, 145, 146,
159, 160, 177, 178, 191, 173, 128, 145,
146, 159, 160, 176, 177, 191, 128, 179,
180, 191, 151, 156, 128, 191, 128, 159,
160, 255, 184, 191, 192, 255, 169, 128,
170, 171, 175, 176, 255, 182, 191, 192,
255, 128, 158, 159, 191, 128, 143, 144,
173, 174, 175, 176, 180, 181, 191, 128,
171, 172, 175, 176, 255, 138, 191, 192,
255, 128, 150, 151, 159, 160, 255, 149,
191, 192, 255, 167, 128, 191, 128, 132,
133, 179, 180, 191, 128, 132, 133, 139,
140, 191, 128, 130, 131, 160, 161, 173,
174, 175, 176, 185, 186, 255, 166, 191,
192, 255, 128, 163, 164, 191, 128, 140,
141, 143, 144, 153, 154, 189, 190, 191,
128, 136, 137, 191, 173, 128, 168, 169,
177, 178, 180, 181, 182, 183, 191, 0,
127, 192, 255, 150, 151, 158, 159, 152,
154, 156, 158, 134, 135, 142, 143, 190,
191, 192, 255, 181, 189, 191, 128, 190,
133, 181, 128, 129, 130, 140, 141, 143,
144, 147, 148, 149, 150, 155, 156, 159,
160, 172, 173, 177, 178, 188, 189, 191,
177, 191, 128, 190, 128, 143, 144, 156,
157, 191, 130, 135, 148, 164, 166, 168,
128, 137, 138, 149, 150, 151, 152, 157,
158, 169, 170, 185, 186, 187, 188, 191,
142, 128, 132, 133, 137, 138, 159, 160,
255, 137, 191, 192, 255, 175, 128, 255,
159, 165, 170, 175, 177, 180, 191, 192,
255, 166, 173, 128, 167, 168, 175, 176,
255, 168, 174, 176, 191, 192, 255, 167,
175, 183, 191, 128, 150, 151, 159, 160,
190, 135, 143, 151, 128, 158, 159, 191,
128, 132, 133, 135, 136, 160, 161, 169,
170, 176, 177, 181, 182, 183, 184, 188,
189, 191, 160, 151, 154, 187, 192, 255,
128, 132, 133, 173, 174, 176, 177, 255,
143, 159, 187, 191, 192, 255, 128, 175,
176, 191, 150, 191, 192, 255, 141, 191,
192, 255, 128, 143, 144, 189, 190, 191,
141, 143, 160, 169, 172, 191, 192, 255,
191, 128, 174, 175, 190, 128, 157, 158,
159, 160, 255, 176, 191, 192, 255, 128,
150, 151, 159, 160, 161, 162, 255, 175,
137, 138, 184, 191, 192, 255, 128, 182,
183, 255, 130, 134, 139, 163, 191, 192,
255, 128, 129, 130, 179, 180, 191, 187,
189, 128, 177, 178, 183, 184, 191, 128,
137, 138, 165, 166, 175, 176, 255, 135,
159, 189, 191, 192, 255, 128, 131, 132,
178, 179, 191, 143, 165, 191, 128, 159,
160, 175, 176, 185, 186, 190, 128, 168,
169, 191, 131, 186, 128, 139, 140, 159,
160, 182, 183, 189, 190, 255, 176, 178,
180, 183, 184, 190, 191, 192, 255, 129,
128, 130, 131, 154, 155, 157, 158, 159,
160, 170, 171, 177, 178, 180, 181, 191,
128, 167, 175, 129, 134, 135, 136, 137,
142, 143, 144, 145, 150, 151, 159, 160,
255, 155, 166, 175, 128, 162, 163, 191,
164, 175, 135, 138, 188, 191, 192, 255,
174, 175, 154, 191, 192, 255, 157, 169,
183, 189, 191, 128, 134, 135, 146, 147,
151, 152, 158, 159, 190, 130, 133, 128,
255, 178, 191, 192, 255, 128, 146, 147,
255, 190, 191, 192, 255, 128, 143, 144,
255, 144, 145, 136, 175, 188, 191, 192,
255, 181, 128, 175, 176, 255, 189, 191,
192, 255, 128, 160, 161, 186, 187, 191,
128, 129, 154, 155, 165, 166, 255, 191,
192, 255, 128, 129, 130, 135, 136, 137,
138, 143, 144, 145, 146, 151, 152, 153,
154, 156, 157, 191, 128, 191, 128, 129,
130, 131, 133, 138, 139, 140, 141, 142,
143, 144, 145, 146, 147, 148, 149, 152,
156, 157, 160, 161, 162, 163, 164, 166,
168, 169, 170, 171, 172, 173, 174, 176,
177, 132, 151, 153, 155, 158, 175, 178,
179, 180, 191, 140, 167, 187, 190, 128,
255, 142, 143, 158, 191, 192, 255, 187,
191, 192, 255, 128, 180, 181, 191, 128,
156, 157, 159, 160, 255, 145, 191, 192,
255, 128, 159, 160, 175, 176, 255, 139,
143, 182, 191, 192, 255, 144, 132, 135,
150, 191, 192, 255, 158, 175, 148, 151,
188, 191, 192, 255, 128, 167, 168, 175,
176, 255, 164, 191, 192, 255, 183, 191,
192, 255, 128, 149, 150, 159, 160, 167,
168, 191, 136, 182, 188, 128, 133, 134,
137, 138, 184, 185, 190, 191, 255, 150,
159, 183, 191, 192, 255, 179, 128, 159,
160, 181, 182, 191, 128, 149, 150, 159,
160, 185, 186, 191, 128, 183, 184, 189,
190, 191, 128, 148, 152, 129, 143, 144,
179, 180, 191, 128, 159, 160, 188, 189,
191, 128, 156, 157, 191, 136, 128, 164,
165, 191, 128, 181, 182, 191, 128, 149,
150, 159, 160, 178, 179, 191, 128, 145,
146, 191, 128, 178, 179, 191, 128, 130,
131, 132, 133, 134, 135, 136, 138, 139,
140, 141, 144, 145, 146, 147, 150, 151,
152, 153, 154, 156, 162, 163, 171, 176,
177, 178, 129, 191, 128, 130, 131, 183,
184, 191, 128, 130, 131, 175, 176, 191,
128, 143, 144, 168, 169, 191, 128, 130,
131, 166, 167, 191, 182, 128, 143, 144,
178, 179, 191, 128, 130, 131, 178, 179,
191, 128, 154, 156, 129, 132, 133, 191,
146, 128, 171, 172, 191, 135, 137, 142,
158, 128, 168, 169, 175, 176, 255, 159,
191, 192, 255, 144, 128, 156, 157, 161,
162, 191, 128, 134, 135, 138, 139, 191,
128, 175, 176, 191, 134, 128, 131, 132,
135, 136, 191, 128, 174, 175, 191, 128,
151, 152, 155, 156, 191, 132, 128, 191,
128, 170, 171, 191, 128, 153, 154, 191,
160, 190, 192, 255, 128, 184, 185, 191,
137, 128, 174, 175, 191, 128, 129, 177,
178, 255, 144, 191, 192, 255, 128, 142,
143, 144, 145, 146, 149, 129, 148, 150,
191, 175, 191, 192, 255, 132, 191, 192,
255, 128, 144, 129, 143, 145, 191, 144,
153, 128, 143, 145, 152, 154, 191, 135,
191, 192, 255, 160, 168, 169, 171, 172,
173, 174, 188, 189, 190, 191, 128, 159,
161, 167, 170, 187, 185, 191, 192, 255,
128, 143, 144, 173, 174, 191, 128, 131,
132, 162, 163, 183, 184, 188, 189, 255,
133, 143, 145, 191, 192, 255, 128, 146,
147, 159, 160, 191, 160, 128, 191, 128,
129, 191, 192, 255, 159, 160, 171, 128,
170, 172, 191, 192, 255, 173, 191, 192,
255, 179, 191, 192, 255, 128, 176, 177,
178, 129, 191, 128, 129, 130, 191, 171,
175, 189, 191, 192, 255, 128, 136, 137,
143, 144, 153, 154, 191, 144, 145, 146,
147, 148, 149, 154, 155, 156, 157, 158,
159, 128, 143, 150, 153, 160, 191, 149,
157, 173, 186, 188, 160, 161, 163, 164,
167, 168, 132, 134, 149, 157, 186, 191,
139, 140, 192, 255, 133, 145, 128, 134,
135, 137, 138, 255, 166, 167, 129, 155,
187, 149, 181, 143, 175, 137, 169, 131,
140, 191, 192, 255, 160, 163, 164, 165,
184, 185, 186, 128, 159, 161, 162, 166,
191, 133, 191, 192, 255, 132, 160, 163,
167, 179, 184, 186, 128, 164, 165, 168,
169, 187, 188, 191, 130, 135, 137, 139,
144, 147, 151, 153, 155, 157, 159, 163,
171, 179, 184, 189, 191, 128, 140, 141,
148, 149, 160, 161, 164, 165, 166, 167,
190, 138, 164, 170, 128, 155, 156, 160,
161, 187, 188, 191, 128, 191, 155, 156,
128, 191, 151, 191, 192, 255, 156, 157,
160, 128, 191, 181, 191, 192, 255, 158,
159, 186, 128, 185, 187, 191, 192, 255,
162, 191, 192, 255, 160, 168, 128, 159,
161, 167, 169, 191, 158, 191, 192, 255,
123, 128, 191, 128, 191, 128, 191, 128,
191, 128, 191, 10, 123, 128, 191, 128,
zclsyntax: scanning of bare (top-level) templates This alternative scanning mode makes the scanner start in template context rather than normal context. This will be later used by the parser to allow parsing of standalone templates that aren't embedded inside a zcl configuration file.
2017-05-29 16:42:20 +00:00
191, 128, 191, 123, 123, 10, 123, 128,
191, 128, 191, 128, 191, 123, 123, 9,
zclsyntax: create comma tokens in the scanner
2017-06-04 21:22:27 +00:00
10, 13, 32, 33, 34, 35, 38, 47,
zclsyntax: separate tokens for assign = and equality test ==
2017-06-04 23:00:40 +00:00
60, 61, 62, 64, 92, 95, 123, 124,
125, 126, 127, 194, 195, 198, 199, 203,
204, 205, 206, 207, 210, 212, 213, 214,
215, 216, 217, 219, 220, 221, 222, 223,
224, 225, 226, 227, 228, 233, 234, 237,
238, 239, 240, 0, 39, 40, 46, 48,
57, 58, 63, 65, 90, 91, 96, 97,
122, 192, 193, 196, 218, 229, 236, 241,
247, 9, 10, 32, 61, 10, 38, 42,
47, 42, 46, 69, 101, 48, 57, 60,
61, 61, 61, 95, 194, 195, 198, 199,
203, 204, 205, 206, 207, 210, 212, 213,
214, 215, 216, 217, 219, 220, 221, 222,
223, 224, 225, 226, 227, 228, 233, 234,
237, 239, 240, 243, 48, 57, 65, 90,
97, 122, 196, 218, 229, 236, 124, 125,
128, 191, 170, 181, 186, 128, 191, 151,
183, 128, 255, 192, 255, 0, 127, 173,
130, 133, 146, 159, 165, 171, 175, 191,
192, 255, 181, 190, 128, 175, 176, 183,
184, 185, 186, 191, 134, 139, 141, 162,
128, 135, 136, 255, 182, 130, 137, 176,
151, 152, 154, 160, 136, 191, 192, 255,
128, 143, 144, 170, 171, 175, 176, 178,
179, 191, 128, 159, 160, 191, 176, 128,
138, 139, 173, 174, 255, 148, 150, 164,
167, 173, 176, 185, 189, 190, 192, 255,
144, 128, 145, 146, 175, 176, 191, 128,
140, 141, 255, 166, 176, 178, 191, 192,
255, 186, 128, 137, 138, 170, 171, 179,
180, 181, 182, 191, 160, 161, 162, 164,
165, 166, 167, 168, 169, 170, 171, 172,
173, 174, 175, 176, 177, 178, 179, 180,
181, 182, 183, 184, 185, 186, 187, 188,
189, 190, 128, 191, 128, 129, 130, 131,
137, 138, 139, 140, 141, 142, 143, 144,
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, 182, 183, 184, 188,
189, 190, 191, 132, 187, 129, 130, 132,
133, 134, 176, 177, 178, 179, 180, 181,
182, 183, 128, 191, 128, 129, 130, 131,
132, 133, 134, 135, 144, 136, 143, 145,
191, 192, 255, 182, 183, 184, 128, 191,
128, 191, 191, 128, 190, 192, 255, 128,
146, 147, 148, 152, 153, 154, 155, 156,
158, 159, 160, 161, 162, 163, 164, 165,
166, 167, 168, 169, 170, 171, 172, 173,
174, 175, 176, 129, 191, 192, 255, 158,
159, 128, 157, 160, 191, 192, 255, 128,
191, 164, 169, 171, 172, 173, 174, 175,
180, 181, 182, 183, 184, 185, 187, 188,
189, 190, 191, 128, 163, 165, 186, 144,
145, 146, 147, 148, 150, 151, 152, 155,
157, 158, 160, 170, 171, 172, 175, 128,
159, 161, 169, 173, 191, 128, 191, 10,
13, 33, 34, 36, 92, 128, 191, 192,
223, 224, 239, 240, 247, 248, 255, 10,
13, 33, 34, 36, 92, 128, 191, 192,
223, 224, 239, 240, 247, 248, 255, 10,
13, 33, 36, 92, 128, 191, 192, 223,
224, 239, 240, 247, 248, 255, 33, 36,
92, 192, 223, 224, 239, 240, 247, 10,
13, 33, 34, 36, 92, 192, 223, 224,
zclsyntax: create comma tokens in the scanner
2017-06-04 21:22:27 +00:00
239, 240, 247, 248, 255, 10, 13, 33,
zclsyntax: separate tokens for assign = and equality test ==
2017-06-04 23:00:40 +00:00
34, 36, 92, 128, 223, 224, 239, 240,
zclsyntax: create comma tokens in the scanner
2017-06-04 21:22:27 +00:00
247, 248, 255, 10, 13, 33, 34, 36,
zclsyntax: separate tokens for assign = and equality test ==
2017-06-04 23:00:40 +00:00
92, 128, 191, 192, 223, 224, 239, 240,
247, 248, 255, 123, 126, 123, 126, 128,
191, 128, 191, 128, 191, 10, 13, 33,
36, 128, 191, 192, 223, 224, 239, 240,
247, 248, 255, 10, 13, 33, 36, 128,
zclsyntax: create comma tokens in the scanner
2017-06-04 21:22:27 +00:00
191, 192, 223, 224, 239, 240, 247, 248,
zclsyntax: separate tokens for assign = and equality test ==
2017-06-04 23:00:40 +00:00
255, 126, 126, 128, 191, 128, 191, 128,
191, 10, 13, 33, 36, 128, 191, 192,
223, 224, 239, 240, 247, 248, 255, 10,
zclsyntax: create comma tokens in the scanner
2017-06-04 21:22:27 +00:00
13, 33, 36, 128, 191, 192, 223, 224,
zclsyntax: separate tokens for assign = and equality test ==
2017-06-04 23:00:40 +00:00
239, 240, 247, 248, 255, 126, 126, 128,
191, 128, 191, 128, 191,
zclsyntax: start of a ragel-based scanner Using Ragel here because the scanner is going to be somewhat complex due to the need to switch back and forth between normal and template states, etc. This should be easier to maintain than a hand-written scanner, while ragel gives us the extra features we need to implement things that would normally be too complex for a "regular" scanner generator.
2017-05-28 02:01:43 +00:00
}
var _zcltok_single_lengths []byte = []byte{
zclsyntax: scanning of comments
2017-05-29 16:13:35 +00:00
0, 1, 1, 2, 2, 0, 31, 30,
35, 1, 4, 0, 0, 0, 0, 1,
2, 1, 1, 1, 1, 0, 1, 1,
0, 0, 2, 0, 0, 0, 1, 32,
0, 0, 0, 0, 1, 3, 1, 1,
1, 0, 2, 0, 1, 1, 2, 0,
3, 0, 1, 0, 2, 1, 2, 0,
0, 5, 1, 4, 0, 0, 1, 43,
0, 0, 0, 2, 3, 2, 1, 1,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 1, 1, 0, 0, 0,
0, 0, 0, 0, 0, 4, 1, 0,
15, 0, 0, 0, 1, 6, 1, 0,
0, 1, 0, 2, 0, 0, 0, 9,
0, 1, 1, 0, 0, 0, 3, 0,
1, 0, 28, 0, 0, 0, 1, 0,
1, 0, 0, 0, 1, 0, 0, 0,
0, 0, 0, 0, 1, 0, 2, 0,
0, 18, 0, 0, 1, 0, 0, 0,
0, 0, 0, 0, 0, 1, 0, 0,
0, 16, 36, 0, 0, 0, 0, 1,
0, 0, 0, 0, 0, 1, 0, 0,
0, 0, 0, 0, 2, 0, 0, 0,
zclsyntax: heredoc support in the scanner
2017-05-29 15:55:53 +00:00
0, 0, 1, 0, 0, 0, 0, 0,
zclsyntax: scanning of comments
2017-05-29 16:13:35 +00:00
0, 0, 28, 0, 0, 0, 1, 1,
1, 1, 0, 0, 2, 0, 1, 0,
0, 0, 0, 0, 0, 0, 0, 0,
1, 1, 4, 0, 0, 2, 2, 0,
11, 0, 0, 0, 0, 0, 0, 0,
1, 1, 3, 0, 0, 4, 0, 0,
0, 18, 0, 0, 0, 1, 4, 1,
4, 1, 0, 3, 2, 2, 2, 1,
0, 0, 1, 8, 0, 0, 0, 4,
12, 0, 2, 0, 3, 0, 1, 0,
2, 0, 1, 2, 0, 3, 1, 2,
0, 0, 0, 0, 0, 1, 1, 0,
0, 1, 28, 3, 0, 1, 1, 2,
1, 0, 1, 1, 2, 1, 1, 2,
1, 1, 0, 2, 1, 1, 1, 1,
0, 0, 6, 1, 1, 0, 0, 46,
1, 1, 0, 0, 0, 0, 2, 1,
0, 0, 0, 1, 0, 0, 0, 0,
0, 0, 0, 13, 2, 0, 0, 0,
9, 0, 1, 28, 0, 1, 3, 0,
2, 0, 0, 0, 1, 0, 1, 1,
2, 0, 18, 2, 0, 0, 16, 35,
0, 0, 0, 1, 0, 28, 0, 0,
0, 0, 1, 0, 2, 0, 0, 1,
0, 0, 1, 0, 0, 1, 0, 0,
0, 0, 1, 11, 0, 0, 0, 0,
4, 0, 12, 1, 7, 0, 4, 0,
0, 0, 0, 1, 2, 1, 1, 1,
1, 0, 1, 1, 0, 0, 2, 0,
0, 0, 1, 32, 0, 0, 0, 0,
1, 3, 1, 1, 1, 0, 2, 0,
1, 1, 2, 0, 3, 0, 1, 0,
2, 1, 2, 0, 0, 5, 1, 4,
0, 0, 1, 43, 0, 0, 0, 2,
3, 2, 1, 1, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 1,
zclsyntax: heredoc support in the scanner
2017-05-29 15:55:53 +00:00
1, 0, 0, 0, 0, 0, 0, 0,
zclsyntax: scanning of comments
2017-05-29 16:13:35 +00:00
0, 4, 1, 0, 15, 0, 0, 0,
1, 6, 1, 0, 0, 1, 0, 2,
0, 0, 0, 9, 0, 1, 1, 0,
0, 0, 3, 0, 1, 0, 28, 0,
0, 0, 1, 0, 1, 0, 0, 0,
zclsyntax: heredoc support in the scanner
2017-05-29 15:55:53 +00:00
1, 0, 0, 0, 0, 0, 0, 0,
zclsyntax: scanning of comments
2017-05-29 16:13:35 +00:00
1, 0, 2, 0, 0, 18, 0, 0,
1, 0, 0, 0, 0, 0, 0, 0,
0, 1, 0, 0, 0, 16, 36, 0,
zclsyntax: heredoc support in the scanner
2017-05-29 15:55:53 +00:00
0, 0, 0, 1, 0, 0, 0, 0,
zclsyntax: scanning of comments
2017-05-29 16:13:35 +00:00
0, 1, 0, 0, 0, 0, 0, 0,
2, 0, 0, 0, 0, 0, 1, 0,
0, 0, 0, 0, 0, 0, 28, 0,
0, 0, 1, 1, 1, 1, 0, 0,
2, 0, 1, 0, 0, 0, 0, 0,
0, 0, 0, 0, 1, 1, 4, 0,
0, 2, 2, 0, 11, 0, 0, 0,
0, 0, 0, 0, 1, 1, 3, 0,
0, 4, 0, 0, 0, 18, 0, 0,
0, 1, 4, 1, 4, 1, 0, 3,
2, 2, 2, 1, 0, 0, 1, 8,
0, 0, 0, 4, 12, 0, 2, 0,
3, 0, 1, 0, 2, 0, 1, 2,
0, 0, 3, 0, 1, 1, 1, 2,
2, 4, 1, 6, 2, 4, 2, 4,
1, 4, 0, 6, 1, 3, 1, 2,
0, 2, 11, 1, 1, 1, 0, 1,
1, 0, 2, 0, 3, 3, 2, 1,
0, 0, 0, 1, 0, 1, 0, 1,
1, 0, 2, 0, 0, 1, 0, 0,
0, 0, 0, 0, 0, 1, 0, 0,
0, 0, 0, 0, 0, 1, 0, 0,
0, 4, 3, 2, 2, 0, 6, 1,
0, 1, 1, 0, 2, 0, 4, 3,
0, 1, 1, 0, 0, 0, 0, 0,
0, 0, 1, 0, 0, 0, 1, 0,
3, 0, 2, 0, 0, 0, 3, 0,
2, 1, 1, 3, 1, 0, 0, 0,
0, 0, 5, 2, 0, 0, 0, 0,
0, 0, 1, 0, 0, 1, 1, 0,
0, 35, 4, 0, 0, 0, 0, 0,
zclsyntax: heredoc support in the scanner
2017-05-29 15:55:53 +00:00
0, 0, 1, 0, 0, 0, 0, 0,
zclsyntax: scanning of comments
2017-05-29 16:13:35 +00:00
0, 3, 0, 1, 0, 0, 3, 0,
0, 1, 0, 0, 0, 0, 28, 0,
0, 0, 0, 1, 0, 3, 1, 4,
0, 1, 0, 0, 1, 0, 0, 1,
0, 0, 0, 0, 1, 1, 0, 7,
0, 0, 2, 2, 0, 11, 0, 0,
0, 0, 0, 1, 1, 3, 0, 0,
4, 0, 0, 0, 12, 1, 4, 1,
5, 2, 0, 3, 2, 2, 2, 1,
7, 0, 7, 17, 3, 0, 2, 0,
3, 0, 0, 1, 0, 2, 0, 1,
0, 0, 0, 0, 0, 1, 1, 0,
zclsyntax: scanning of bare (top-level) templates This alternative scanning mode makes the scanner start in template context rather than normal context. This will be later used by the parser to allow parsing of standalone templates that aren't embedded inside a zcl configuration file.
2017-05-29 16:42:20 +00:00
0, 0, 1, 1, 1, 1, 0, 0,
zclsyntax: separate tokens for assign = and equality test ==
2017-06-04 23:00:40 +00:00
0, 1, 1, 52, 1, 1, 1, 1,
1, 1, 2, 1, 3, 2, 1, 1,
33, 1, 1, 0, 3, 2, 0, 0,
0, 1, 2, 4, 1, 0, 1, 0,
0, 0, 0, 1, 1, 1, 0, 0,
1, 30, 47, 13, 9, 3, 0, 1,
28, 2, 0, 18, 16, 0, 6, 6,
5, 3, 6, 6, 6, 1, 1, 1,
1, 0, 0, 0, 4, 4, 1, 1,
zclsyntax: scanning of bare (top-level) templates This alternative scanning mode makes the scanner start in template context rather than normal context. This will be later used by the parser to allow parsing of standalone templates that aren't embedded inside a zcl configuration file.
2017-05-29 16:42:20 +00:00
0, 0, 0, 4, 4, 1, 1, 0,
zclsyntax: separate tokens for assign = and equality test ==
2017-06-04 23:00:40 +00:00
0, 0,
zclsyntax: start of a ragel-based scanner Using Ragel here because the scanner is going to be somewhat complex due to the need to switch back and forth between normal and template states, etc. This should be easier to maintain than a hand-written scanner, while ragel gives us the extra features we need to implement things that would normally be too complex for a "regular" scanner generator.
2017-05-28 02:01:43 +00:00
}
var _zcltok_range_lengths []byte = []byte{
zclsyntax: scanning of comments
2017-05-29 16:13:35 +00:00
0, 0, 0, 0, 1, 1, 5, 5,
5, 0, 0, 3, 0, 1, 1, 4,
2, 3, 0, 1, 0, 2, 2, 4,
2, 2, 3, 1, 1, 1, 1, 0,
1, 1, 2, 2, 1, 4, 6, 9,
6, 8, 5, 8, 7, 10, 4, 6,
4, 7, 7, 5, 5, 4, 5, 1,
2, 8, 4, 3, 3, 3, 0, 3,
1, 2, 1, 2, 2, 3, 3, 1,
3, 2, 2, 1, 2, 2, 2, 3,
4, 4, 3, 1, 2, 1, 3, 2,
2, 2, 2, 2, 3, 3, 1, 1,
2, 1, 3, 2, 2, 3, 2, 7,
0, 1, 4, 1, 2, 4, 2, 1,
2, 0, 2, 2, 3, 5, 5, 1,
4, 1, 1, 2, 2, 1, 0, 0,
1, 1, 1, 1, 1, 2, 2, 2,
2, 1, 1, 1, 4, 2, 2, 3,
1, 4, 4, 6, 1, 3, 1, 1,
2, 1, 1, 1, 5, 3, 1, 1,
1, 2, 3, 3, 1, 2, 2, 1,
4, 1, 2, 5, 2, 1, 1, 0,
zclsyntax: identifiers in the scanner
2017-05-28 16:16:53 +00:00
2, 2, 2, 2, 2, 2, 2, 2,
zclsyntax: scanning of comments
2017-05-29 16:13:35 +00:00
2, 1, 1, 2, 4, 2, 1, 2,
2, 2, 6, 1, 1, 2, 1, 2,
1, 1, 1, 2, 2, 2, 1, 3,
2, 5, 2, 8, 6, 2, 2, 2,
2, 3, 1, 3, 1, 2, 1, 3,
2, 2, 3, 1, 1, 1, 1, 1,
1, 1, 2, 2, 4, 1, 2, 1,
0, 1, 1, 1, 1, 0, 1, 2,
3, 1, 3, 3, 1, 0, 3, 0,
2, 3, 1, 0, 0, 0, 0, 2,
2, 2, 2, 1, 5, 2, 2, 5,
7, 5, 0, 1, 0, 1, 1, 1,
1, 1, 0, 1, 1, 0, 3, 3,
1, 1, 2, 1, 3, 5, 1, 1,
2, 2, 1, 1, 1, 1, 2, 6,
3, 7, 2, 6, 1, 6, 2, 8,
0, 4, 2, 5, 2, 3, 3, 3,
1, 2, 8, 2, 0, 2, 1, 2,
1, 5, 2, 1, 3, 3, 0, 2,
1, 2, 1, 0, 1, 1, 3, 1,
1, 2, 3, 0, 0, 3, 2, 4,
1, 4, 1, 1, 3, 1, 1, 1,
1, 2, 2, 1, 3, 1, 4, 3,
3, 1, 1, 5, 2, 1, 1, 2,
1, 2, 1, 3, 2, 0, 1, 1,
1, 1, 1, 1, 1, 2, 1, 1,
1, 1, 1, 1, 1, 0, 1, 1,
2, 2, 1, 1, 1, 3, 2, 1,
0, 2, 1, 1, 1, 1, 0, 3,
0, 1, 1, 4, 2, 3, 0, 1,
0, 2, 2, 4, 2, 2, 3, 1,
1, 1, 1, 0, 1, 1, 2, 2,
1, 4, 6, 9, 6, 8, 5, 8,
7, 10, 4, 6, 4, 7, 7, 5,
5, 4, 5, 1, 2, 8, 4, 3,
3, 3, 0, 3, 1, 2, 1, 2,
2, 3, 3, 1, 3, 2, 2, 1,
2, 2, 2, 3, 4, 4, 3, 1,
2, 1, 3, 2, 2, 2, 2, 2,
3, 3, 1, 1, 2, 1, 3, 2,
2, 3, 2, 7, 0, 1, 4, 1,
2, 4, 2, 1, 2, 0, 2, 2,
3, 5, 5, 1, 4, 1, 1, 2,
2, 1, 0, 0, 1, 1, 1, 1,
1, 2, 2, 2, 2, 1, 1, 1,
4, 2, 2, 3, 1, 4, 4, 6,
1, 3, 1, 1, 2, 1, 1, 1,
5, 3, 1, 1, 1, 2, 3, 3,
1, 2, 2, 1, 4, 1, 2, 5,
2, 1, 1, 0, 2, 2, 2, 2,
2, 2, 2, 2, 2, 1, 1, 2,
4, 2, 1, 2, 2, 2, 6, 1,
1, 2, 1, 2, 1, 1, 1, 2,
2, 2, 1, 3, 2, 5, 2, 8,
6, 2, 2, 2, 2, 3, 1, 3,
1, 2, 1, 3, 2, 2, 3, 1,
1, 1, 1, 1, 1, 1, 2, 2,
4, 1, 2, 1, 0, 1, 1, 1,
1, 0, 1, 2, 3, 1, 3, 3,
1, 0, 3, 0, 2, 3, 1, 0,
0, 0, 0, 2, 2, 2, 2, 1,
5, 2, 2, 5, 7, 5, 0, 1,
0, 1, 1, 1, 1, 1, 0, 1,
1, 1, 2, 2, 3, 3, 4, 7,
5, 7, 5, 3, 3, 7, 3, 13,
1, 3, 5, 3, 5, 3, 6, 5,
2, 2, 8, 4, 1, 2, 3, 2,
10, 2, 2, 0, 2, 3, 3, 1,
2, 3, 3, 1, 2, 3, 3, 4,
4, 2, 1, 2, 2, 3, 2, 2,
5, 3, 2, 3, 2, 1, 3, 3,
6, 2, 2, 5, 2, 5, 1, 1,
2, 4, 1, 11, 1, 3, 8, 4,
2, 1, 0, 4, 3, 3, 3, 2,
9, 1, 1, 4, 3, 2, 2, 2,
3, 4, 2, 3, 2, 4, 3, 2,
2, 3, 3, 4, 3, 3, 4, 2,
5, 4, 8, 7, 1, 2, 1, 3,
1, 2, 5, 1, 2, 2, 2, 2,
1, 3, 2, 2, 3, 3, 1, 9,
1, 5, 1, 3, 2, 2, 3, 2,
3, 3, 3, 1, 3, 3, 2, 2,
4, 5, 3, 3, 4, 3, 3, 3,
2, 2, 2, 4, 2, 2, 1, 3,
3, 3, 3, 3, 3, 2, 2, 3,
2, 3, 3, 2, 3, 2, 3, 1,
2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 3, 2, 3, 2, 3,
5, 3, 3, 1, 2, 3, 2, 2,
1, 2, 3, 4, 3, 0, 3, 0,
2, 3, 1, 0, 0, 0, 0, 2,
3, 2, 4, 6, 4, 1, 1, 2,
1, 2, 1, 3, 2, 3, 2, 0,
1, 1, 1, 1, 1, 0, 0, 1,
zclsyntax: scanning of bare (top-level) templates This alternative scanning mode makes the scanner start in template context rather than normal context. This will be later used by the parser to allow parsing of standalone templates that aren't embedded inside a zcl configuration file.
2017-05-29 16:42:20 +00:00
1, 1, 0, 0, 0, 0, 1, 1,
1, 0, 0, 11, 0, 0, 0, 0,
zclsyntax: separate tokens for assign = and equality test ==
2017-06-04 23:00:40 +00:00
0, 0, 0, 0, 1, 0, 0, 0,
5, 0, 0, 1, 1, 1, 0, 1,
1, 5, 4, 2, 0, 1, 0, 2,
2, 5, 2, 3, 5, 3, 2, 3,
5, 1, 1, 1, 3, 1, 1, 2,
2, 3, 1, 2, 3, 1, 5, 5,
5, 3, 4, 4, 5, 0, 0, 0,
0, 1, 1, 1, 5, 5, 0, 0,
zclsyntax: scanning of bare (top-level) templates This alternative scanning mode makes the scanner start in template context rather than normal context. This will be later used by the parser to allow parsing of standalone templates that aren't embedded inside a zcl configuration file.
2017-05-29 16:42:20 +00:00
1, 1, 1, 5, 5, 0, 0, 1,
zclsyntax: separate tokens for assign = and equality test ==
2017-06-04 23:00:40 +00:00
1, 1,
zclsyntax: start of a ragel-based scanner Using Ragel here because the scanner is going to be somewhat complex due to the need to switch back and forth between normal and template states, etc. This should be easier to maintain than a hand-written scanner, while ragel gives us the extra features we need to implement things that would normally be too complex for a "regular" scanner generator.
2017-05-28 02:01:43 +00:00
}
zclsyntax: identifiers in the scanner
2017-05-28 16:16:53 +00:00
var _zcltok_index_offsets []int16 = []int16{
zclsyntax: scanning of comments
2017-05-29 16:13:35 +00:00
0, 0, 2, 4, 7, 11, 13, 50,
86, 127, 129, 134, 138, 139, 141, 143,
149, 154, 159, 161, 164, 166, 169, 173,
179, 182, 185, 191, 193, 195, 197, 200,
233, 235, 237, 240, 243, 246, 254, 262,
273, 281, 290, 298, 307, 316, 328, 335,
342, 350, 358, 367, 373, 381, 387, 395,
397, 400, 414, 420, 428, 432, 436, 438,
485, 487, 490, 492, 497, 503, 509, 514,
517, 521, 524, 527, 529, 532, 535, 538,
542, 547, 552, 556, 558, 561, 563, 567,
570, 573, 576, 579, 583, 588, 592, 594,
596, 599, 601, 605, 608, 611, 619, 623,
631, 647, 649, 654, 656, 660, 671, 675,
677, 680, 682, 685, 690, 694, 700, 706,
717, 722, 725, 728, 731, 734, 736, 740,
741, 744, 746, 776, 778, 780, 783, 787,
790, 794, 796, 798, 800, 806, 809, 812,
816, 818, 823, 828, 835, 838, 842, 846,
848, 851, 871, 873, 875, 882, 886, 888,
890, 892, 895, 899, 903, 905, 909, 912,
914, 919, 937, 976, 982, 985, 987, 989,
991, 994, 997, 1000, 1003, 1006, 1010, 1013,
1016, 1019, 1021, 1023, 1026, 1033, 1036, 1038,
1041, 1044, 1047, 1055, 1057, 1059, 1062, 1064,
1067, 1069, 1071, 1101, 1104, 1107, 1110, 1113,
1118, 1122, 1129, 1132, 1141, 1150, 1153, 1157,
1160, 1163, 1167, 1169, 1173, 1175, 1178, 1180,
1184, 1188, 1192, 1200, 1202, 1204, 1208, 1212,
1214, 1227, 1229, 1232, 1235, 1240, 1242, 1245,
1247, 1249, 1252, 1257, 1259, 1261, 1266, 1268,
1271, 1275, 1295, 1299, 1303, 1305, 1307, 1315,
1317, 1324, 1329, 1331, 1335, 1338, 1341, 1344,
1348, 1351, 1354, 1358, 1368, 1374, 1377, 1380,
1390, 1410, 1416, 1419, 1421, 1425, 1427, 1430,
1432, 1436, 1438, 1440, 1444, 1446, 1450, 1455,
1461, 1463, 1465, 1468, 1470, 1474, 1481, 1484,
1486, 1489, 1493, 1523, 1528, 1530, 1533, 1537,
1546, 1551, 1559, 1563, 1571, 1575, 1583, 1587,
1598, 1600, 1606, 1609, 1617, 1621, 1626, 1631,
1636, 1638, 1641, 1656, 1660, 1662, 1665, 1667,
1716, 1719, 1726, 1729, 1731, 1735, 1739, 1742,
1746, 1748, 1751, 1753, 1755, 1757, 1759, 1763,
1765, 1767, 1770, 1774, 1788, 1791, 1795, 1798,
1803, 1814, 1819, 1822, 1852, 1856, 1859, 1864,
1866, 1870, 1873, 1876, 1878, 1883, 1885, 1891,
1896, 1902, 1904, 1924, 1932, 1935, 1937, 1955,
1993, 1995, 1998, 2000, 2005, 2008, 2037, 2039,
2041, 2043, 2045, 2048, 2050, 2054, 2057, 2059,
2062, 2064, 2066, 2069, 2071, 2073, 2075, 2077,
2079, 2082, 2085, 2088, 2101, 2103, 2107, 2110,
2112, 2117, 2120, 2134, 2137, 2146, 2148, 2153,
2157, 2158, 2160, 2162, 2168, 2173, 2178, 2180,
2183, 2185, 2188, 2192, 2198, 2201, 2204, 2210,
2212, 2214, 2216, 2219, 2252, 2254, 2256, 2259,
2262, 2265, 2273, 2281, 2292, 2300, 2309, 2317,
2326, 2335, 2347, 2354, 2361, 2369, 2377, 2386,
2392, 2400, 2406, 2414, 2416, 2419, 2433, 2439,
2447, 2451, 2455, 2457, 2504, 2506, 2509, 2511,
2516, 2522, 2528, 2533, 2536, 2540, 2543, 2546,
2548, 2551, 2554, 2557, 2561, 2566, 2571, 2575,
2577, 2580, 2582, 2586, 2589, 2592, 2595, 2598,
2602, 2607, 2611, 2613, 2615, 2618, 2620, 2624,
2627, 2630, 2638, 2642, 2650, 2666, 2668, 2673,
2675, 2679, 2690, 2694, 2696, 2699, 2701, 2704,
2709, 2713, 2719, 2725, 2736, 2741, 2744, 2747,
2750, 2753, 2755, 2759, 2760, 2763, 2765, 2795,
2797, 2799, 2802, 2806, 2809, 2813, 2815, 2817,
2819, 2825, 2828, 2831, 2835, 2837, 2842, 2847,
2854, 2857, 2861, 2865, 2867, 2870, 2890, 2892,
2894, 2901, 2905, 2907, 2909, 2911, 2914, 2918,
2922, 2924, 2928, 2931, 2933, 2938, 2956, 2995,
3001, 3004, 3006, 3008, 3010, 3013, 3016, 3019,
3022, 3025, 3029, 3032, 3035, 3038, 3040, 3042,
3045, 3052, 3055, 3057, 3060, 3063, 3066, 3074,
3076, 3078, 3081, 3083, 3086, 3088, 3090, 3120,
3123, 3126, 3129, 3132, 3137, 3141, 3148, 3151,
3160, 3169, 3172, 3176, 3179, 3182, 3186, 3188,
3192, 3194, 3197, 3199, 3203, 3207, 3211, 3219,
3221, 3223, 3227, 3231, 3233, 3246, 3248, 3251,
3254, 3259, 3261, 3264, 3266, 3268, 3271, 3276,
3278, 3280, 3285, 3287, 3290, 3294, 3314, 3318,
3322, 3324, 3326, 3334, 3336, 3343, 3348, 3350,
3354, 3357, 3360, 3363, 3367, 3370, 3373, 3377,
3387, 3393, 3396, 3399, 3409, 3429, 3435, 3438,
3440, 3444, 3446, 3449, 3451, 3455, 3457, 3459,
3463, 3465, 3467, 3473, 3476, 3481, 3486, 3492,
3502, 3510, 3522, 3529, 3539, 3545, 3557, 3563,
3581, 3584, 3592, 3598, 3608, 3615, 3622, 3630,
3638, 3641, 3646, 3666, 3672, 3675, 3679, 3683,
3687, 3699, 3702, 3707, 3708, 3714, 3721, 3727,
3730, 3733, 3737, 3741, 3744, 3747, 3752, 3756,
3762, 3768, 3771, 3775, 3778, 3781, 3786, 3789,
3792, 3798, 3802, 3805, 3809, 3812, 3815, 3819,
3823, 3830, 3833, 3836, 3842, 3845, 3852, 3854,
3856, 3859, 3868, 3873, 3887, 3891, 3895, 3910,
3916, 3919, 3922, 3924, 3929, 3935, 3939, 3947,
3953, 3963, 3966, 3969, 3974, 3978, 3981, 3984,
3987, 3991, 3996, 4000, 4004, 4007, 4012, 4017,
4020, 4026, 4030, 4036, 4041, 4045, 4049, 4057,
4060, 4068, 4074, 4084, 4095, 4098, 4101, 4103,
4107, 4109, 4112, 4123, 4127, 4130, 4133, 4136,
4139, 4141, 4145, 4149, 4152, 4156, 4161, 4164,
4174, 4176, 4217, 4223, 4227, 4230, 4233, 4237,
4240, 4244, 4248, 4253, 4255, 4259, 4263, 4266,
4269, 4274, 4283, 4287, 4292, 4297, 4301, 4308,
4312, 4315, 4319, 4322, 4327, 4330, 4333, 4363,
4367, 4371, 4375, 4379, 4384, 4388, 4394, 4398,
4406, 4409, 4414, 4418, 4421, 4426, 4429, 4433,
4436, 4439, 4442, 4445, 4448, 4452, 4456, 4459,
4469, 4472, 4475, 4480, 4486, 4489, 4504, 4507,
4511, 4517, 4521, 4525, 4528, 4532, 4539, 4542,
4545, 4551, 4554, 4558, 4563, 4579, 4581, 4589,
4591, 4599, 4605, 4607, 4611, 4614, 4617, 4620,
4624, 4635, 4638, 4650, 4674, 4682, 4684, 4688,
4691, 4696, 4699, 4701, 4706, 4709, 4715, 4718,
4720, 4722, 4724, 4726, 4728, 4730, 4732, 4734,
zclsyntax: scanning of bare (top-level) templates This alternative scanning mode makes the scanner start in template context rather than normal context. This will be later used by the parser to allow parsing of standalone templates that aren't embedded inside a zcl configuration file.
2017-05-29 16:42:20 +00:00
4736, 4738, 4740, 4742, 4744, 4746, 4748, 4750,
zclsyntax: separate tokens for assign = and equality test ==
2017-06-04 23:00:40 +00:00
4752, 4754, 4756, 4758, 4822, 4824, 4826, 4828,
4830, 4832, 4834, 4837, 4839, 4844, 4847, 4849,
4851, 4890, 4892, 4894, 4896, 4901, 4905, 4906,
4908, 4910, 4917, 4924, 4931, 4933, 4935, 4937,
4940, 4943, 4949, 4952, 4957, 4964, 4969, 4972,
4976, 4983, 5015, 5064, 5079, 5092, 5097, 5099,
5103, 5134, 5140, 5142, 5163, 5183, 5185, 5197,
5209, 5220, 5227, 5238, 5249, 5261, 5263, 5265,
5267, 5269, 5271, 5273, 5275, 5285, 5295, 5297,
5299, 5301, 5303, 5305, 5315, 5325, 5327, 5329,
5331, 5333,
zclsyntax: start of a ragel-based scanner Using Ragel here because the scanner is going to be somewhat complex due to the need to switch back and forth between normal and template states, etc. This should be easier to maintain than a hand-written scanner, while ragel gives us the extra features we need to implement things that would normally be too complex for a "regular" scanner generator.
2017-05-28 02:01:43 +00:00
}
zclsyntax: identifiers in the scanner
2017-05-28 16:16:53 +00:00
var _zcltok_indicies []int16 = []int16{
zclsyntax: scanning of comments
2017-05-29 16:13:35 +00:00
2, 1, 4, 3, 4, 5, 3, 7,
7, 8, 6, 8, 6, 10, 12, 13,
15, 16, 17, 18, 19, 20, 21, 22,
23, 24, 25, 26, 27, 28, 29, 30,
31, 32, 33, 34, 35, 36, 37, 39,
40, 41, 42, 43, 11, 11, 14, 14,
38, 9, 12, 13, 15, 16, 17, 18,
19, 20, 21, 22, 23, 24, 25, 26,
27, 28, 29, 30, 31, 32, 33, 34,
35, 36, 37, 39, 40, 41, 42, 43,
11, 11, 14, 14, 38, 9, 44, 45,
11, 46, 13, 15, 16, 17, 16, 47,
48, 20, 49, 22, 23, 50, 51, 52,
53, 54, 55, 56, 57, 58, 59, 60,
61, 62, 37, 39, 63, 41, 64, 65,
66, 11, 11, 11, 14, 38, 9, 44,
9, 11, 11, 11, 11, 9, 11, 11,
zclwrite: absorb lead comments into attributes The native parser's ranges don't include any surrounding comments, so we need to do a little more work to pick them out of the surrounding token sequences. This just takes care of _lead_ comments, which are those that appear as whole line comments above the item in question. Line comments, which appear after the item on the same line, will follow in a later commit.
2017-06-08 16:04:27 +00:00
11, 9, 11, 9, 11, 9, 11, 9,
zclsyntax: scanning of comments
2017-05-29 16:13:35 +00:00
9, 9, 9, 9, 11, 9, 9, 9,
9, 11, 11, 11, 11, 11, 9, 9,
11, 9, 9, 11, 9, 11, 9, 9,
11, 9, 9, 9, 11, 11, 11, 11,
11, 11, 9, 11, 11, 9, 11, 11,
9, 9, 9, 9, 9, 9, 11, 11,
9, 9, 11, 9, 11, 11, 11, 9,
67, 68, 69, 70, 14, 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,
9, 11, 9, 11, 9, 11, 11, 9,
11, 11, 9, 9, 9, 11, 9, 9,
9, 9, 9, 9, 9, 11, 9, 9,
9, 9, 9, 9, 9, 11, 11, 11,
11, 11, 11, 11, 11, 11, 11, 11,
9, 9, 9, 9, 9, 9, 9, 9,
11, 11, 11, 11, 11, 11, 11, 11,
11, 9, 9, 9, 9, 9, 9, 9,
9, 11, 11, 11, 11, 11, 11, 11,
11, 11, 9, 11, 11, 11, 11, 11,
11, 11, 11, 9, 11, 11, 11, 11,
11, 11, 11, 11, 11, 11, 11, 9,
11, 11, 11, 11, 11, 11, 9, 11,
11, 11, 11, 11, 11, 9, 9, 9,
9, 9, 9, 9, 9, 11, 11, 11,
11, 11, 11, 11, 11, 9, 11, 11,
11, 11, 11, 11, 11, 11, 9, 11,
11, 11, 11, 11, 9, 9, 9, 9,
9, 9, 9, 9, 11, 11, 11, 11,
11, 11, 9, 11, 11, 11, 11, 11,
11, 11, 9, 11, 9, 11, 11, 9,
11, 11, 11, 11, 11, 11, 11, 11,
11, 11, 11, 11, 11, 9, 11, 11,
11, 11, 11, 9, 11, 11, 11, 11,
11, 11, 11, 9, 11, 11, 11, 9,
11, 11, 11, 9, 11, 9, 98, 99,
100, 101, 102, 103, 104, 105, 106, 107,
108, 109, 110, 111, 112, 113, 114, 16,
115, 116, 117, 118, 119, 120, 121, 122,
123, 124, 125, 126, 127, 128, 129, 130,
131, 132, 14, 15, 133, 134, 135, 136,
137, 14, 16, 14, 9, 11, 9, 11,
11, 9, 9, 11, 9, 9, 9, 9,
11, 9, 9, 9, 9, 9, 11, 9,
9, 9, 9, 9, 11, 11, 11, 11,
11, 9, 9, 9, 11, 9, 9, 9,
11, 11, 11, 9, 9, 9, 11, 11,
9, 9, 9, 11, 11, 11, 9, 9,
9, 11, 11, 11, 11, 9, 11, 11,
11, 11, 9, 9, 9, 9, 9, 11,
11, 11, 11, 9, 9, 11, 11, 11,
9, 9, 11, 11, 11, 11, 9, 11,
11, 9, 11, 11, 9, 9, 9, 11,
11, 11, 9, 9, 9, 9, 11, 11,
11, 11, 11, 9, 9, 9, 9, 11,
9, 11, 11, 9, 11, 11, 9, 11,
9, 11, 11, 11, 9, 11, 11, 9,
9, 9, 11, 9, 9, 9, 9, 9,
9, 9, 11, 11, 11, 11, 9, 11,
11, 11, 11, 11, 11, 11, 9, 138,
139, 140, 141, 142, 143, 144, 145, 146,
14, 147, 148, 149, 150, 151, 9, 11,
9, 9, 9, 9, 9, 11, 11, 9,
11, 11, 11, 9, 11, 11, 11, 11,
11, 11, 11, 11, 11, 11, 9, 11,
11, 11, 9, 9, 11, 11, 11, 9,
9, 11, 9, 9, 11, 11, 11, 11,
11, 9, 9, 9, 9, 11, 11, 11,
11, 11, 11, 9, 11, 11, 11, 11,
11, 9, 152, 109, 153, 154, 155, 14,
156, 157, 16, 14, 9, 11, 11, 11,
11, 9, 9, 9, 11, 9, 9, 11,
11, 11, 9, 9, 9, 11, 11, 9,
119, 9, 16, 14, 14, 158, 9, 14,
9, 11, 16, 159, 160, 16, 161, 162,
16, 57, 163, 164, 165, 166, 167, 16,
168, 169, 170, 16, 171, 172, 173, 15,
174, 175, 176, 15, 177, 16, 14, 9,
9, 11, 11, 9, 9, 9, 11, 11,
11, 11, 9, 11, 11, 9, 9, 9,
9, 11, 11, 9, 9, 11, 11, 9,
9, 9, 9, 9, 9, 11, 11, 11,
9, 9, 9, 11, 9, 9, 9, 11,
11, 9, 11, 11, 11, 11, 9, 11,
11, 11, 11, 9, 11, 11, 11, 11,
11, 11, 9, 9, 9, 11, 11, 11,
11, 9, 178, 179, 9, 14, 9, 11,
9, 9, 11, 16, 180, 181, 182, 183,
57, 184, 185, 55, 186, 187, 188, 189,
190, 191, 192, 193, 194, 14, 9, 9,
11, 9, 11, 11, 11, 11, 11, 11,
11, 9, 11, 11, 11, 9, 11, 9,
9, 11, 9, 11, 9, 9, 11, 11,
11, 11, 9, 11, 11, 11, 9, 9,
11, 11, 11, 11, 9, 11, 11, 9,
9, 11, 11, 11, 11, 11, 9, 195,
196, 197, 198, 199, 200, 201, 202, 203,
204, 205, 201, 206, 207, 208, 209, 38,
9, 210, 211, 16, 212, 213, 214, 215,
216, 217, 218, 219, 220, 16, 14, 221,
222, 223, 224, 16, 225, 226, 227, 228,
229, 230, 231, 232, 233, 234, 235, 236,
237, 238, 239, 16, 144, 14, 240, 9,
11, 11, 11, 11, 11, 9, 9, 9,
11, 9, 11, 11, 9, 11, 9, 11,
11, 9, 9, 9, 11, 11, 11, 9,
9, 9, 11, 11, 11, 9, 9, 9,
9, 11, 9, 9, 11, 9, 9, 11,
11, 11, 9, 9, 11, 9, 11, 11,
11, 9, 11, 11, 11, 11, 11, 11,
9, 9, 9, 11, 11, 9, 11, 11,
9, 11, 11, 9, 11, 11, 9, 11,
11, 11, 11, 11, 11, 11, 9, 11,
9, 11, 9, 11, 11, 9, 11, 9,
11, 11, 9, 11, 9, 11, 9, 241,
212, 242, 243, 244, 245, 246, 247, 248,
249, 250, 98, 251, 16, 252, 253, 254,
16, 255, 129, 256, 257, 258, 259, 260,
261, 262, 263, 16, 9, 9, 9, 11,
11, 11, 9, 11, 11, 9, 11, 11,
9, 9, 9, 9, 9, 11, 11, 11,
11, 9, 11, 11, 11, 11, 11, 11,
9, 9, 9, 11, 11, 11, 11, 11,
11, 11, 11, 11, 9, 11, 11, 11,
11, 11, 11, 11, 11, 9, 11, 11,
9, 9, 9, 9, 11, 11, 11, 9,
9, 9, 11, 9, 9, 9, 11, 11,
9, 11, 11, 11, 9, 11, 9, 9,
9, 11, 11, 9, 11, 11, 11, 9,
11, 11, 11, 9, 9, 9, 9, 11,
16, 181, 264, 265, 14, 16, 14, 9,
9, 11, 9, 11, 16, 264, 14, 9,
16, 266, 14, 9, 9, 11, 16, 267,
268, 269, 172, 270, 271, 16, 272, 273,
274, 14, 9, 9, 11, 11, 11, 9,
11, 11, 9, 11, 11, 11, 11, 9,
9, 11, 9, 9, 11, 11, 9, 11,
9, 16, 14, 9, 275, 16, 276, 9,
14, 9, 11, 9, 11, 277, 16, 278,
279, 9, 11, 9, 9, 9, 11, 11,
11, 11, 9, 280, 281, 282, 16, 283,
284, 285, 286, 287, 288, 289, 290, 291,
292, 293, 294, 295, 296, 14, 9, 11,
11, 11, 9, 9, 9, 9, 11, 11,
9, 9, 11, 9, 9, 9, 9, 9,
9, 9, 11, 9, 11, 9, 9, 9,
9, 9, 9, 11, 11, 11, 11, 11,
9, 9, 11, 9, 9, 9, 11, 9,
9, 11, 9, 9, 11, 9, 9, 11,
9, 9, 9, 11, 11, 11, 9, 9,
9, 11, 11, 11, 11, 9, 297, 16,
298, 16, 299, 300, 301, 302, 14, 9,
11, 11, 11, 11, 11, 9, 9, 9,
11, 9, 9, 11, 11, 11, 11, 11,
11, 11, 11, 11, 11, 9, 11, 11,
11, 11, 11, 11, 11, 11, 11, 11,
11, 11, 11, 11, 11, 11, 11, 11,
11, 9, 11, 11, 11, 11, 11, 9,
303, 16, 14, 9, 11, 304, 16, 100,
14, 9, 11, 305, 9, 14, 9, 11,
16, 306, 14, 9, 9, 11, 307, 9,
16, 308, 14, 9, 9, 11, 11, 11,
11, 9, 11, 11, 11, 11, 9, 11,
11, 11, 11, 11, 9, 9, 11, 9,
11, 11, 11, 9, 11, 9, 11, 11,
11, 9, 9, 9, 9, 9, 9, 9,
11, 11, 11, 9, 11, 9, 9, 9,
11, 11, 11, 11, 9, 309, 310, 69,
311, 312, 313, 314, 315, 316, 317, 318,
319, 320, 321, 322, 323, 324, 325, 326,
327, 328, 329, 331, 332, 333, 334, 335,
336, 330, 9, 11, 11, 11, 11, 9,
11, 9, 11, 11, 9, 11, 11, 11,
9, 9, 9, 9, 9, 9, 9, 9,
9, 11, 11, 11, 11, 11, 9, 11,
11, 11, 11, 11, 11, 11, 9, 11,
11, 11, 9, 11, 11, 11, 11, 11,
11, 11, 9, 11, 11, 11, 9, 11,
11, 11, 11, 11, 11, 11, 9, 11,
11, 11, 9, 11, 11, 11, 11, 11,
11, 11, 11, 11, 11, 9, 11, 9,
11, 11, 11, 11, 11, 9, 11, 11,
9, 11, 11, 11, 11, 11, 11, 11,
9, 11, 11, 11, 9, 11, 11, 11,
11, 9, 11, 11, 11, 11, 9, 11,
11, 11, 11, 9, 11, 9, 11, 11,
9, 11, 11, 11, 11, 11, 11, 11,
11, 11, 11, 11, 11, 11, 11, 9,
11, 11, 11, 9, 11, 9, 11, 11,
9, 11, 9, 337, 338, 339, 101, 102,
103, 104, 105, 340, 107, 108, 109, 110,
111, 112, 341, 342, 167, 343, 258, 117,
344, 119, 229, 269, 122, 345, 346, 347,
348, 349, 350, 351, 352, 353, 354, 131,
355, 16, 14, 15, 16, 134, 135, 136,
137, 14, 14, 9, 11, 11, 9, 11,
11, 11, 11, 11, 11, 9, 9, 9,
11, 9, 11, 11, 11, 11, 9, 11,
11, 11, 9, 11, 11, 9, 11, 11,
11, 9, 9, 11, 11, 11, 9, 9,
11, 11, 9, 11, 9, 11, 9, 11,
11, 11, 9, 9, 11, 11, 9, 11,
11, 9, 11, 11, 11, 9, 356, 140,
142, 143, 144, 145, 146, 14, 357, 148,
358, 150, 359, 9, 11, 11, 9, 9,
9, 9, 11, 9, 9, 11, 11, 11,
11, 11, 9, 360, 109, 361, 154, 155,
14, 156, 157, 16, 14, 9, 11, 11,
11, 11, 9, 9, 9, 11, 16, 159,
160, 16, 362, 363, 219, 308, 163, 164,
165, 364, 167, 365, 366, 367, 368, 369,
370, 371, 372, 373, 374, 175, 176, 15,
375, 16, 14, 9, 9, 9, 9, 11,
11, 11, 9, 9, 9, 9, 9, 11,
11, 9, 11, 11, 11, 9, 11, 11,
9, 9, 9, 11, 11, 9, 11, 11,
11, 11, 9, 11, 9, 11, 11, 11,
11, 11, 9, 9, 9, 9, 9, 11,
11, 11, 11, 11, 11, 9, 11, 9,
16, 180, 181, 376, 183, 57, 184, 185,
55, 186, 187, 377, 14, 190, 378, 192,
193, 194, 14, 9, 11, 11, 11, 11,
11, 11, 11, 9, 11, 11, 9, 11,
9, 379, 380, 197, 198, 199, 381, 201,
202, 382, 383, 384, 201, 206, 207, 208,
209, 38, 9, 210, 211, 16, 212, 213,
215, 385, 217, 386, 219, 220, 16, 14,
387, 222, 223, 224, 16, 225, 226, 227,
228, 229, 230, 231, 232, 388, 234, 235,
389, 237, 238, 239, 16, 144, 14, 240,
9, 9, 11, 9, 9, 11, 9, 11,
11, 11, 11, 11, 9, 11, 11, 9,
390, 391, 392, 393, 394, 395, 396, 397,
247, 398, 319, 399, 213, 400, 401, 402,
403, 404, 401, 405, 406, 407, 258, 408,
260, 409, 410, 271, 9, 11, 9, 11,
9, 11, 9, 11, 9, 11, 11, 9,
11, 9, 11, 11, 11, 9, 11, 11,
9, 9, 11, 11, 11, 9, 11, 9,
11, 9, 11, 11, 9, 11, 9, 11,
9, 11, 9, 11, 9, 11, 9, 9,
9, 11, 11, 11, 9, 11, 11, 9,
16, 267, 229, 411, 401, 412, 271, 16,
413, 414, 274, 14, 9, 11, 9, 11,
11, 11, 9, 9, 9, 11, 11, 9,
277, 16, 278, 415, 9, 11, 11, 9,
16, 283, 284, 285, 286, 287, 288, 289,
290, 291, 292, 416, 14, 9, 9, 9,
11, 16, 417, 16, 265, 300, 301, 302,
14, 9, 9, 11, 419, 419, 419, 419,
418, 419, 419, 419, 418, 419, 418, 419,
419, 418, 418, 418, 418, 418, 418, 419,
418, 418, 418, 418, 419, 419, 419, 419,
419, 418, 418, 419, 418, 418, 419, 418,
419, 418, 418, 419, 418, 418, 418, 419,
419, 419, 419, 419, 419, 418, 419, 419,
418, 419, 419, 418, 418, 418, 418, 418,
418, 419, 419, 418, 418, 419, 418, 419,
419, 419, 418, 420, 421, 422, 423, 424,
425, 426, 427, 428, 429, 430, 431, 432,
433, 434, 435, 436, 437, 438, 439, 440,
441, 442, 443, 444, 445, 446, 447, 448,
449, 450, 451, 418, 419, 418, 419, 418,
419, 419, 418, 419, 419, 418, 418, 418,
419, 418, 418, 418, 418, 418, 418, 418,
419, 418, 418, 418, 418, 418, 418, 418,
419, 419, 419, 419, 419, 419, 419, 419,
419, 419, 419, 418, 418, 418, 418, 418,
418, 418, 418, 419, 419, 419, 419, 419,
419, 419, 419, 419, 418, 418, 418, 418,
418, 418, 418, 418, 419, 419, 419, 419,
419, 419, 419, 419, 419, 418, 419, 419,
419, 419, 419, 419, 419, 419, 418, 419,
419, 419, 419, 419, 419, 419, 419, 419,
419, 419, 418, 419, 419, 419, 419, 419,
419, 418, 419, 419, 419, 419, 419, 419,
418, 418, 418, 418, 418, 418, 418, 418,
419, 419, 419, 419, 419, 419, 419, 419,
418, 419, 419, 419, 419, 419, 419, 419,
419, 418, 419, 419, 419, 419, 419, 418,
418, 418, 418, 418, 418, 418, 418, 419,
419, 419, 419, 419, 419, 418, 419, 419,
419, 419, 419, 419, 419, 418, 419, 418,
419, 419, 418, 419, 419, 419, 419, 419,
419, 419, 419, 419, 419, 419, 419, 419,
418, 419, 419, 419, 419, 419, 418, 419,
419, 419, 419, 419, 419, 419, 418, 419,
419, 419, 418, 419, 419, 419, 418, 419,
418, 452, 453, 454, 455, 456, 457, 458,
459, 460, 461, 462, 463, 464, 465, 466,
467, 468, 469, 470, 471, 472, 473, 474,
475, 476, 477, 478, 479, 480, 481, 482,
483, 484, 485, 486, 487, 424, 488, 489,
490, 491, 492, 493, 424, 469, 424, 418,
419, 418, 419, 419, 418, 418, 419, 418,
418, 418, 418, 419, 418, 418, 418, 418,
418, 419, 418, 418, 418, 418, 418, 419,
419, 419, 419, 419, 418, 418, 418, 419,
418, 418, 418, 419, 419, 419, 418, 418,
418, 419, 419, 418, 418, 418, 419, 419,
419, 418, 418, 418, 419, 419, 419, 419,
418, 419, 419, 419, 419, 418, 418, 418,
418, 418, 419, 419, 419, 419, 418, 418,
419, 419, 419, 418, 418, 419, 419, 419,
419, 418, 419, 419, 418, 419, 419, 418,
418, 418, 419, 419, 419, 418, 418, 418,
418, 419, 419, 419, 419, 419, 418, 418,
418, 418, 419, 418, 419, 419, 418, 419,
419, 418, 419, 418, 419, 419, 419, 418,
419, 419, 418, 418, 418, 419, 418, 418,
418, 418, 418, 418, 418, 419, 419, 419,
419, 418, 419, 419, 419, 419, 419, 419,
419, 418, 494, 495, 496, 497, 498, 499,
500, 501, 502, 424, 503, 504, 505, 506,
507, 418, 419, 418, 418, 418, 418, 418,
419, 419, 418, 419, 419, 419, 418, 419,
419, 419, 419, 419, 419, 419, 419, 419,
419, 418, 419, 419, 419, 418, 418, 419,
419, 419, 418, 418, 419, 418, 418, 419,
419, 419, 419, 419, 418, 418, 418, 418,
419, 419, 419, 419, 419, 419, 418, 419,
419, 419, 419, 419, 418, 508, 463, 509,
510, 511, 424, 512, 513, 469, 424, 418,
419, 419, 419, 419, 418, 418, 418, 419,
418, 418, 419, 419, 419, 418, 418, 418,
419, 419, 418, 474, 418, 469, 424, 424,
514, 418, 424, 418, 419, 469, 515, 516,
469, 517, 518, 469, 519, 520, 521, 522,
523, 524, 469, 525, 526, 527, 469, 528,
529, 530, 488, 531, 532, 533, 488, 534,
469, 424, 418, 418, 419, 419, 418, 418,
418, 419, 419, 419, 419, 418, 419, 419,
418, 418, 418, 418, 419, 419, 418, 418,
419, 419, 418, 418, 418, 418, 418, 418,
419, 419, 419, 418, 418, 418, 419, 418,
418, 418, 419, 419, 418, 419, 419, 419,
419, 418, 419, 419, 419, 419, 418, 419,
419, 419, 419, 419, 419, 418, 418, 418,
419, 419, 419, 419, 418, 535, 536, 418,
424, 418, 419, 418, 418, 419, 469, 537,
538, 539, 540, 519, 541, 542, 543, 544,
545, 546, 547, 548, 549, 550, 551, 552,
424, 418, 418, 419, 418, 419, 419, 419,
419, 419, 419, 419, 418, 419, 419, 419,
418, 419, 418, 418, 419, 418, 419, 418,
418, 419, 419, 419, 419, 418, 419, 419,
419, 418, 418, 419, 419, 419, 419, 418,
419, 419, 418, 418, 419, 419, 419, 419,
419, 418, 553, 554, 555, 556, 557, 558,
559, 560, 561, 562, 563, 559, 565, 566,
567, 568, 564, 418, 569, 570, 469, 571,
572, 573, 574, 575, 576, 577, 578, 579,
469, 424, 580, 581, 582, 583, 469, 584,
585, 586, 587, 588, 589, 590, 591, 592,
593, 594, 595, 596, 597, 598, 469, 500,
424, 599, 418, 419, 419, 419, 419, 419,
418, 418, 418, 419, 418, 419, 419, 418,
419, 418, 419, 419, 418, 418, 418, 419,
419, 419, 418, 418, 418, 419, 419, 419,
418, 418, 418, 418, 419, 418, 418, 419,
418, 418, 419, 419, 419, 418, 418, 419,
418, 419, 419, 419, 418, 419, 419, 419,
419, 419, 419, 418, 418, 418, 419, 419,
418, 419, 419, 418, 419, 419, 418, 419,
419, 418, 419, 419, 419, 419, 419, 419,
419, 418, 419, 418, 419, 418, 419, 419,
418, 419, 418, 419, 419, 418, 419, 418,
419, 418, 600, 571, 601, 602, 603, 604,
605, 606, 607, 608, 609, 452, 610, 469,
611, 612, 613, 469, 614, 484, 615, 616,
617, 618, 619, 620, 621, 622, 469, 418,
418, 418, 419, 419, 419, 418, 419, 419,
418, 419, 419, 418, 418, 418, 418, 418,
419, 419, 419, 419, 418, 419, 419, 419,
419, 419, 419, 418, 418, 418, 419, 419,
419, 419, 419, 419, 419, 419, 419, 418,
419, 419, 419, 419, 419, 419, 419, 419,
418, 419, 419, 418, 418, 418, 418, 419,
419, 419, 418, 418, 418, 419, 418, 418,
418, 419, 419, 418, 419, 419, 419, 418,
419, 418, 418, 418, 419, 419, 418, 419,
419, 419, 418, 419, 419, 419, 418, 418,
418, 418, 419, 469, 538, 623, 624, 424,
469, 424, 418, 418, 419, 418, 419, 469,
623, 424, 418, 469, 625, 424, 418, 418,
419, 469, 626, 627, 628, 529, 629, 630,
469, 631, 632, 633, 424, 418, 418, 419,
419, 419, 418, 419, 419, 418, 419, 419,
419, 419, 418, 418, 419, 418, 418, 419,
419, 418, 419, 418, 469, 424, 418, 634,
469, 635, 418, 424, 418, 419, 418, 419,
636, 469, 637, 638, 418, 419, 418, 418,
418, 419, 419, 419, 419, 418, 639, 640,
641, 469, 642, 643, 644, 645, 646, 647,
648, 649, 650, 651, 652, 653, 654, 655,
424, 418, 419, 419, 419, 418, 418, 418,
418, 419, 419, 418, 418, 419, 418, 418,
418, 418, 418, 418, 418, 419, 418, 419,
418, 418, 418, 418, 418, 418, 419, 419,
419, 419, 419, 418, 418, 419, 418, 418,
418, 419, 418, 418, 419, 418, 418, 419,
418, 418, 419, 418, 418, 418, 419, 419,
419, 418, 418, 418, 419, 419, 419, 419,
418, 656, 469, 657, 469, 658, 659, 660,
661, 424, 418, 419, 419, 419, 419, 419,
418, 418, 418, 419, 418, 418, 419, 419,
419, 419, 419, 419, 419, 419, 419, 419,
418, 419, 419, 419, 419, 419, 419, 419,
419, 419, 419, 419, 419, 419, 419, 419,
419, 419, 419, 419, 418, 419, 419, 419,
419, 419, 418, 662, 469, 424, 418, 419,
663, 469, 454, 424, 418, 419, 664, 418,
424, 418, 419, 469, 665, 424, 418, 418,
419, 666, 418, 469, 667, 424, 418, 418,
419, 669, 668, 419, 419, 419, 419, 669,
668, 419, 669, 668, 669, 669, 419, 669,
668, 419, 669, 419, 669, 668, 419, 669,
419, 669, 419, 668, 669, 669, 669, 669,
669, 669, 669, 669, 668, 419, 419, 669,
669, 419, 669, 419, 669, 668, 669, 669,
669, 669, 669, 419, 669, 419, 669, 419,
669, 668, 669, 669, 419, 669, 419, 669,
668, 669, 669, 669, 669, 669, 419, 669,
419, 669, 668, 419, 419, 669, 419, 669,
668, 669, 669, 669, 419, 669, 419, 669,
419, 669, 419, 669, 668, 669, 419, 669,
419, 669, 668, 419, 669, 669, 669, 669,
419, 669, 419, 669, 419, 669, 419, 669,
419, 669, 419, 669, 668, 419, 669, 668,
669, 669, 669, 419, 669, 419, 669, 668,
669, 419, 669, 419, 669, 668, 419, 669,
669, 669, 669, 419, 669, 419, 669, 668,
419, 669, 419, 669, 419, 669, 668, 669,
669, 419, 669, 419, 669, 668, 419, 669,
419, 669, 419, 669, 419, 668, 669, 669,
669, 419, 669, 419, 669, 668, 419, 669,
668, 669, 669, 419, 669, 668, 669, 669,
669, 419, 669, 669, 669, 669, 669, 669,
419, 419, 669, 419, 669, 419, 669, 419,
669, 668, 669, 419, 669, 419, 669, 668,
419, 669, 668, 669, 419, 669, 668, 669,
419, 669, 668, 419, 419, 669, 668, 419,
669, 419, 669, 419, 669, 419, 669, 419,
669, 419, 668, 669, 669, 419, 669, 669,
669, 669, 419, 419, 669, 669, 669, 669,
669, 419, 669, 669, 669, 669, 669, 668,
419, 669, 669, 419, 669, 419, 668, 669,
669, 419, 669, 668, 419, 419, 669, 419,
668, 669, 669, 668, 419, 669, 419, 668,
669, 668, 419, 669, 419, 669, 419, 668,
669, 669, 668, 419, 669, 419, 669, 419,
669, 668, 669, 419, 669, 419, 669, 668,
419, 669, 668, 419, 419, 669, 668, 669,
419, 668, 669, 668, 419, 669, 419, 669,
419, 668, 669, 668, 419, 419, 669, 668,
669, 419, 669, 419, 669, 668, 419, 669,
419, 668, 669, 668, 419, 419, 669, 419,
668, 669, 668, 419, 419, 669, 668, 669,
419, 669, 668, 669, 419, 669, 668, 669,
419, 669, 419, 669, 419, 668, 669, 668,
419, 419, 669, 668, 669, 419, 669, 419,
669, 668, 419, 669, 668, 669, 669, 419,
669, 419, 669, 668, 668, 419, 668, 419,
669, 669, 419, 669, 669, 669, 669, 669,
669, 669, 668, 419, 669, 669, 669, 419,
668, 669, 669, 669, 419, 669, 419, 669,
419, 669, 419, 669, 419, 669, 668, 419,
419, 669, 668, 669, 419, 669, 668, 419,
419, 669, 419, 419, 419, 669, 419, 669,
419, 669, 419, 669, 419, 668, 419, 669,
419, 669, 419, 668, 669, 668, 419, 669,
419, 668, 669, 419, 669, 669, 669, 668,
419, 669, 419, 419, 669, 419, 668, 669,
669, 668, 419, 669, 669, 669, 669, 419,
669, 419, 668, 669, 669, 669, 419, 669,
668, 669, 419, 669, 419, 669, 419, 669,
419, 669, 668, 669, 669, 419, 669, 668,
419, 669, 419, 669, 419, 668, 669, 669,
668, 419, 669, 419, 668, 669, 668, 419,
669, 668, 419, 669, 419, 669, 668, 669,
669, 669, 668, 419, 419, 419, 669, 668,
419, 669, 419, 668, 669, 668, 419, 669,
419, 669, 419, 668, 669, 669, 669, 668,
419, 669, 419, 668, 669, 669, 669, 669,
668, 419, 669, 419, 669, 668, 419, 419,
669, 419, 669, 668, 669, 419, 669, 419,
668, 669, 669, 668, 419, 669, 419, 669,
668, 419, 669, 669, 669, 419, 669, 419,
668, 419, 669, 668, 669, 419, 419, 669,
419, 669, 419, 668, 669, 669, 669, 669,
668, 419, 669, 419, 669, 419, 669, 419,
669, 419, 669, 668, 669, 669, 669, 419,
669, 419, 669, 419, 669, 419, 668, 669,
669, 419, 419, 669, 668, 669, 419, 669,
669, 668, 419, 669, 419, 669, 668, 419,
419, 669, 669, 669, 669, 419, 669, 419,
669, 419, 668, 669, 669, 419, 668, 669,
668, 419, 669, 419, 668, 669, 668, 419,
669, 419, 668, 669, 419, 669, 669, 668,
419, 669, 669, 419, 668, 669, 668, 419,
669, 419, 669, 668, 669, 419, 669, 419,
668, 669, 668, 419, 669, 419, 669, 419,
669, 419, 669, 419, 669, 668, 670, 668,
671, 672, 673, 674, 675, 676, 677, 678,
679, 680, 681, 673, 682, 683, 684, 685,
686, 673, 687, 688, 689, 690, 691, 692,
693, 694, 695, 696, 697, 698, 699, 700,
701, 673, 702, 670, 682, 670, 703, 670,
668, 669, 669, 669, 669, 419, 668, 669,
669, 668, 419, 669, 668, 419, 419, 669,
668, 419, 669, 419, 668, 669, 668, 419,
419, 669, 419, 668, 669, 669, 668, 419,
669, 669, 669, 668, 419, 669, 419, 669,
669, 668, 419, 419, 669, 419, 668, 669,
668, 419, 669, 668, 419, 419, 669, 419,
669, 668, 419, 669, 419, 419, 669, 419,
669, 419, 668, 669, 669, 668, 419, 669,
669, 419, 669, 668, 419, 669, 419, 669,
668, 419, 669, 419, 668, 419, 669, 669,
669, 419, 669, 668, 669, 419, 669, 668,
419, 669, 668, 669, 419, 669, 668, 419,
669, 668, 419, 669, 419, 669, 668, 419,
669, 668, 419, 669, 668, 704, 705, 706,
707, 708, 709, 710, 711, 712, 713, 714,
715, 675, 716, 717, 718, 719, 720, 717,
721, 722, 723, 724, 725, 726, 727, 728,
729, 670, 668, 669, 419, 669, 668, 669,
419, 669, 668, 669, 419, 669, 668, 669,
419, 669, 668, 419, 669, 419, 669, 668,
669, 419, 669, 668, 669, 419, 419, 419,
669, 668, 669, 419, 669, 668, 669, 669,
669, 669, 419, 669, 419, 668, 669, 668,
419, 419, 669, 419, 669, 668, 669, 419,
669, 668, 419, 669, 668, 669, 669, 419,
669, 668, 419, 669, 668, 669, 419, 669,
668, 419, 669, 668, 419, 669, 668, 419,
669, 668, 669, 668, 419, 419, 669, 668,
669, 419, 669, 668, 419, 669, 419, 668,
669, 668, 419, 673, 730, 670, 673, 731,
673, 732, 682, 670, 668, 669, 668, 419,
669, 668, 419, 673, 731, 682, 670, 668,
673, 733, 670, 682, 670, 668, 669, 668,
419, 673, 734, 691, 735, 717, 736, 729,
673, 737, 738, 739, 670, 682, 670, 668,
669, 668, 419, 669, 419, 669, 668, 419,
669, 419, 669, 419, 668, 669, 669, 668,
419, 669, 419, 669, 668, 419, 669, 668,
673, 682, 424, 668, 740, 673, 741, 682,
670, 668, 424, 669, 668, 419, 669, 668,
419, 742, 673, 743, 744, 670, 668, 419,
669, 668, 669, 669, 668, 419, 419, 669,
419, 669, 668, 673, 745, 746, 747, 748,
749, 750, 751, 752, 753, 754, 755, 670,
682, 670, 668, 669, 419, 669, 669, 669,
669, 669, 669, 669, 419, 669, 419, 669,
669, 669, 669, 669, 669, 668, 419, 669,
669, 419, 669, 419, 668, 669, 419, 669,
669, 669, 419, 669, 669, 419, 669, 669,
419, 669, 669, 419, 669, 669, 668, 419,
673, 756, 673, 732, 757, 758, 759, 670,
682, 670, 668, 669, 668, 419, 669, 669,
669, 419, 669, 669, 669, 419, 669, 419,
669, 668, 419, 419, 419, 419, 669, 669,
419, 419, 419, 419, 419, 669, 669, 669,
669, 669, 669, 669, 419, 669, 419, 669,
419, 668, 669, 669, 669, 419, 669, 419,
669, 668, 682, 424, 760, 673, 682, 424,
669, 668, 419, 761, 673, 762, 682, 424,
669, 668, 419, 669, 419, 763, 682, 670,
668, 424, 669, 668, 419, 673, 764, 670,
682, 670, 668, 669, 668, 419, 765, 766,
766, 765, 767, 765, 768, 765, 766, 769,
770, 769, 772, 771, 773, 774, 774, 771,
775, 771, 776, 773, 777, 774, 778, 774,
zclsyntax: scanning of bare (top-level) templates This alternative scanning mode makes the scanner start in template context rather than normal context. This will be later used by the parser to allow parsing of standalone templates that aren't embedded inside a zcl configuration file.
2017-05-29 16:42:20 +00:00
780, 779, 781, 782, 782, 779, 783, 779,
784, 781, 785, 782, 786, 782, 787, 788,
zclsyntax: create comma tokens in the scanner
2017-06-04 21:22:27 +00:00
789, 790, 791, 792, 793, 794, 796, 797,
zclsyntax: separate tokens for assign = and equality test ==
2017-06-04 23:00:40 +00:00
798, 799, 669, 669, 669, 800, 801, 802,
803, 669, 806, 807, 809, 810, 811, 805,
zclsyntax: create comma tokens in the scanner
2017-06-04 21:22:27 +00:00
812, 813, 814, 815, 816, 817, 818, 819,
820, 821, 822, 823, 824, 825, 826, 827,
zclsyntax: separate tokens for assign = and equality test ==
2017-06-04 23:00:40 +00:00
828, 829, 830, 831, 833, 834, 835, 836,
837, 838, 669, 795, 8, 795, 419, 795,
419, 805, 808, 832, 839, 804, 787, 840,
788, 841, 790, 842, 844, 843, 2, 1,
845, 843, 3, 1, 843, 4, 3, 8,
848, 848, 8, 847, 849, 850, 843, 851,
843, 852, 843, 419, 854, 855, 488, 469,
856, 469, 857, 858, 859, 860, 861, 862,
863, 864, 865, 866, 867, 543, 868, 519,
869, 870, 871, 872, 873, 874, 875, 876,
877, 878, 879, 880, 419, 419, 419, 424,
564, 853, 881, 843, 882, 843, 669, 883,
419, 419, 419, 669, 883, 669, 669, 419,
883, 419, 883, 419, 883, 419, 669, 669,
669, 669, 669, 883, 419, 669, 669, 669,
419, 669, 419, 883, 419, 669, 669, 669,
669, 419, 883, 669, 419, 669, 419, 669,
419, 669, 669, 419, 669, 883, 419, 669,
419, 669, 419, 669, 883, 669, 419, 883,
669, 419, 669, 419, 883, 669, 669, 669,
669, 669, 883, 419, 419, 669, 419, 669,
883, 669, 419, 883, 669, 669, 883, 419,
419, 669, 419, 669, 419, 669, 883, 884,
885, 886, 887, 888, 889, 890, 891, 892,
893, 894, 714, 895, 896, 897, 898, 899,
900, 901, 902, 903, 904, 905, 906, 905,
907, 908, 909, 910, 911, 670, 883, 912,
913, 914, 915, 916, 917, 918, 919, 920,
921, 922, 923, 924, 925, 926, 927, 928,
929, 930, 724, 931, 932, 933, 691, 934,
935, 936, 937, 938, 939, 670, 940, 941,
942, 943, 944, 945, 946, 947, 673, 948,
670, 673, 949, 950, 951, 952, 682, 883,
953, 954, 955, 956, 702, 957, 958, 682,
959, 960, 961, 962, 963, 670, 883, 964,
923, 965, 966, 967, 682, 968, 969, 673,
670, 682, 424, 883, 933, 670, 673, 682,
424, 682, 424, 970, 682, 883, 424, 673,
971, 972, 673, 973, 974, 680, 975, 976,
977, 978, 979, 929, 980, 981, 982, 983,
984, 985, 986, 987, 988, 989, 990, 991,
948, 992, 673, 682, 424, 883, 993, 994,
682, 670, 883, 424, 670, 883, 673, 995,
730, 996, 997, 998, 999, 1000, 1001, 1002,
1003, 670, 1004, 1005, 1006, 1007, 1008, 1009,
670, 682, 883, 1011, 1012, 1013, 1014, 1015,
1016, 1017, 1018, 1019, 1020, 1021, 1017, 1023,
1024, 1025, 1026, 1010, 1022, 1010, 883, 1010,
883, 1027, 1027, 1028, 1029, 1030, 1031, 1032,
1033, 1034, 1035, 1032, 766, 1036, 1036, 1037,
1036, 1037, 1031, 1036, 767, 768, 1038, 1036,
766, 1036, 1036, 1039, 1039, 1031, 1036, 767,
768, 1038, 1036, 766, 1039, 1039, 1031, 1040,
1041, 1042, 766, 1036, 1036, 1037, 1036, 1037,
1031, 767, 768, 1038, 1036, 766, 1036, 1036,
1037, 1036, 1037, 1031, 767, 768, 1038, 1036,
766, 1036, 1036, 1037, 1036, 1037, 1031, 768,
767, 768, 1038, 1036, 766, 1044, 766, 1046,
1045, 1047, 766, 1049, 1048, 766, 1050, 770,
1050, 1051, 1050, 772, 1052, 1053, 1054, 1055,
1056, 1057, 1058, 1055, 774, 772, 1052, 1060,
1060, 1059, 775, 776, 1061, 1059, 774, 1063,
1062, 1065, 1064, 774, 1066, 775, 1066, 776,
1066, 780, 1067, 1068, 1069, 1070, 1071, 1072,
1073, 1070, 782, 780, 1067, 1075, 1075, 1074,
783, 784, 1076, 1074, 782, 1078, 1077, 1080,
1079, 782, 1081, 783, 1081, 784, 1081,
zclsyntax: identifiers in the scanner
2017-05-28 16:16:53 +00:00
}
var _zcltok_trans_targs []int16 = []int16{
zclwrite: absorb lead comments into attributes The native parser's ranges don't include any surrounding comments, so we need to do a little more work to pick them out of the surrounding token sequences. This just takes care of _lead_ comments, which are those that appear as whole line comments above the item in question. Line comments, which appear after the item on the same line, will follow in a later commit.
2017-06-08 16:04:27 +00:00
947, 1, 947, 2, 3, 955, 947, 5,
zclsyntax: scanning of bare (top-level) templates This alternative scanning mode makes the scanner start in template context rather than normal context. This will be later used by the parser to allow parsing of standalone templates that aren't embedded inside a zcl configuration file.
2017-05-29 16:42:20 +00:00
956, 947, 7, 8, 285, 11, 12, 13,
zclsyntax: scanning of comments
2017-05-29 16:13:35 +00:00
14, 15, 286, 287, 18, 288, 20, 21,
289, 290, 291, 292, 293, 294, 295, 296,
297, 298, 327, 347, 352, 126, 127, 128,
zclsyntax: scanning of bare (top-level) templates This alternative scanning mode makes the scanner start in template context rather than normal context. This will be later used by the parser to allow parsing of standalone templates that aren't embedded inside a zcl configuration file.
2017-05-29 16:42:20 +00:00
355, 150, 370, 374, 947, 9, 10, 16,
zclsyntax: scanning of comments
2017-05-29 16:13:35 +00:00
17, 19, 22, 23, 24, 25, 26, 27,
28, 29, 30, 31, 63, 104, 119, 130,
153, 169, 282, 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, 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, 105, 106, 107, 108, 109, 110,
111, 112, 113, 114, 115, 116, 117, 118,
120, 121, 122, 123, 124, 125, 129, 131,
132, 133, 134, 135, 136, 137, 138, 139,
140, 141, 142, 143, 144, 145, 146, 147,
148, 149, 151, 152, 154, 155, 156, 157,
158, 159, 160, 161, 162, 163, 164, 165,
166, 167, 168, 170, 202, 226, 229, 230,
232, 241, 242, 245, 249, 267, 274, 276,
278, 280, 171, 172, 173, 174, 175, 176,
177, 178, 179, 180, 181, 182, 183, 184,
185, 186, 187, 188, 189, 190, 191, 192,
193, 194, 195, 196, 197, 198, 199, 200,
201, 203, 204, 205, 206, 207, 208, 209,
210, 211, 212, 213, 214, 215, 216, 217,
218, 219, 220, 221, 222, 223, 224, 225,
227, 228, 231, 233, 234, 235, 236, 237,
238, 239, 240, 243, 244, 246, 247, 248,
250, 251, 252, 253, 254, 255, 256, 257,
258, 259, 260, 261, 262, 263, 264, 265,
266, 268, 269, 270, 271, 272, 273, 275,
277, 279, 281, 283, 284, 299, 300, 301,
302, 303, 304, 305, 306, 307, 308, 309,
310, 311, 312, 313, 314, 315, 316, 317,
318, 319, 320, 321, 322, 323, 324, 325,
326, 328, 329, 330, 331, 332, 333, 334,
335, 336, 337, 338, 339, 340, 341, 342,
343, 344, 345, 346, 348, 349, 350, 351,
353, 354, 356, 357, 358, 359, 360, 361,
362, 363, 364, 365, 366, 367, 368, 369,
371, 372, 373, 375, 381, 403, 408, 410,
412, 376, 377, 378, 379, 380, 382, 383,
384, 385, 386, 387, 388, 389, 390, 391,
392, 393, 394, 395, 396, 397, 398, 399,
400, 401, 402, 404, 405, 406, 407, 409,
zclsyntax: separate tokens for assign = and equality test ==
2017-06-04 23:00:40 +00:00
411, 413, 947, 960, 436, 437, 438, 439,
zclsyntax: scanning of comments
2017-05-29 16:13:35 +00:00
416, 440, 441, 442, 443, 444, 445, 446,
447, 448, 449, 450, 451, 452, 453, 454,
455, 456, 457, 458, 459, 460, 461, 462,
463, 464, 465, 466, 468, 469, 470, 471,
472, 473, 474, 475, 476, 477, 478, 479,
480, 481, 482, 483, 484, 418, 485, 486,
487, 488, 489, 490, 491, 492, 493, 494,
495, 496, 497, 498, 499, 500, 501, 502,
417, 503, 504, 505, 506, 507, 509, 510,
511, 512, 513, 514, 515, 516, 517, 518,
519, 520, 521, 522, 524, 525, 526, 527,
528, 529, 533, 535, 536, 537, 538, 433,
539, 540, 541, 542, 543, 544, 545, 546,
547, 548, 549, 550, 551, 552, 553, 555,
556, 558, 559, 560, 561, 562, 563, 431,
564, 565, 566, 567, 568, 569, 570, 571,
572, 574, 606, 630, 633, 634, 636, 645,
646, 649, 653, 671, 531, 678, 680, 682,
684, 575, 576, 577, 578, 579, 580, 581,
582, 583, 584, 585, 586, 587, 588, 589,
590, 591, 592, 593, 594, 595, 596, 597,
598, 599, 600, 601, 602, 603, 604, 605,
607, 608, 609, 610, 611, 612, 613, 614,
615, 616, 617, 618, 619, 620, 621, 622,
623, 624, 625, 626, 627, 628, 629, 631,
632, 635, 637, 638, 639, 640, 641, 642,
643, 644, 647, 648, 650, 651, 652, 654,
655, 656, 657, 658, 659, 660, 661, 662,
663, 664, 665, 666, 667, 668, 669, 670,
672, 673, 674, 675, 676, 677, 679, 681,
zclsyntax: scanning of bare (top-level) templates This alternative scanning mode makes the scanner start in template context rather than normal context. This will be later used by the parser to allow parsing of standalone templates that aren't embedded inside a zcl configuration file.
2017-05-29 16:42:20 +00:00
683, 685, 687, 688, 947, 947, 689, 826,
zclsyntax: scanning of comments
2017-05-29 16:13:35 +00:00
827, 758, 828, 829, 830, 831, 832, 833,
787, 834, 723, 835, 836, 837, 838, 839,
840, 841, 842, 743, 843, 844, 845, 846,
847, 848, 849, 850, 851, 852, 768, 853,
855, 856, 857, 858, 859, 860, 861, 862,
863, 864, 701, 865, 866, 867, 868, 869,
870, 871, 872, 873, 739, 874, 875, 876,
877, 878, 809, 880, 881, 884, 886, 887,
888, 889, 890, 891, 894, 895, 897, 898,
899, 901, 902, 903, 904, 905, 906, 907,
908, 909, 910, 911, 913, 914, 915, 916,
zclsyntax: separate tokens for assign = and equality test ==
2017-06-04 23:00:40 +00:00
919, 921, 922, 924, 926, 998, 999, 928,
929, 998, 931, 1012, 1012, 1012, 1013, 935,
936, 1014, 1015, 1019, 1019, 1019, 1020, 942,
943, 1021, 1022, 948, 947, 949, 950, 951,
947, 952, 953, 947, 954, 957, 958, 959,
947, 961, 947, 962, 947, 963, 964, 965,
zclsyntax: scanning of bare (top-level) templates This alternative scanning mode makes the scanner start in template context rather than normal context. This will be later used by the parser to allow parsing of standalone templates that aren't embedded inside a zcl configuration file.
2017-05-29 16:42:20 +00:00
966, 967, 968, 969, 970, 971, 972, 973,
974, 975, 976, 977, 978, 979, 980, 981,
982, 983, 984, 985, 986, 987, 988, 989,
zclsyntax: separate tokens for assign = and equality test ==
2017-06-04 23:00:40 +00:00
990, 991, 992, 993, 994, 995, 996, 997,
947, 947, 947, 947, 947, 947, 947, 947,
4, 6, 947, 947, 947, 947, 414, 415,
419, 420, 421, 422, 423, 424, 425, 426,
427, 428, 429, 430, 432, 434, 435, 467,
508, 523, 530, 532, 534, 554, 557, 573,
686, 947, 947, 947, 690, 691, 692, 693,
694, 695, 696, 697, 698, 699, 700, 702,
703, 704, 705, 706, 707, 708, 709, 710,
711, 712, 713, 714, 715, 716, 717, 718,
719, 720, 721, 722, 724, 725, 726, 727,
728, 729, 730, 731, 732, 733, 734, 735,
736, 737, 738, 740, 741, 742, 744, 745,
746, 747, 748, 749, 750, 751, 752, 753,
754, 755, 756, 757, 759, 760, 761, 762,
763, 764, 765, 766, 767, 769, 770, 771,
772, 773, 774, 775, 776, 777, 778, 779,
780, 781, 782, 783, 784, 785, 786, 788,
789, 790, 791, 792, 793, 794, 795, 796,
797, 798, 799, 800, 801, 802, 803, 804,
805, 806, 807, 808, 810, 811, 812, 813,
814, 815, 816, 817, 818, 819, 820, 821,
822, 823, 824, 825, 854, 879, 882, 883,
885, 892, 893, 896, 900, 912, 917, 918,
920, 923, 925, 998, 1005, 998, 1007, 1000,
998, 1009, 1010, 1011, 998, 927, 930, 1001,
1002, 1003, 1004, 998, 1006, 998, 998, 1008,
998, 998, 998, 932, 933, 938, 939, 1012,
1016, 1017, 1018, 1012, 934, 937, 1012, 1012,
1012, 1012, 1012, 940, 945, 946, 1019, 1023,
1024, 1025, 1019, 941, 944, 1019, 1019, 1019,
1019, 1019,
zclsyntax: start of a ragel-based scanner Using Ragel here because the scanner is going to be somewhat complex due to the need to switch back and forth between normal and template states, etc. This should be easier to maintain than a hand-written scanner, while ragel gives us the extra features we need to implement things that would normally be too complex for a "regular" scanner generator.
2017-05-28 02:01:43 +00:00
}
var _zcltok_trans_actions []byte = []byte{
zclwrite: absorb lead comments into attributes The native parser's ranges don't include any surrounding comments, so we need to do a little more work to pick them out of the surrounding token sequences. This just takes care of _lead_ comments, which are those that appear as whole line comments above the item in question. Line comments, which appear after the item on the same line, will follow in a later commit.
2017-06-08 16:04:27 +00:00
127, 0, 71, 0, 0, 147, 119, 0,
5, 123, 0, 0, 0, 0, 0, 0,
zclsyntax: heredoc support in the scanner
2017-05-29 15:55:53 +00:00
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
zclwrite: absorb lead comments into attributes The native parser's ranges don't include any surrounding comments, so we need to do a little more work to pick them out of the surrounding token sequences. This just takes care of _lead_ comments, which are those that appear as whole line comments above the item in question. Line comments, which appear after the item on the same line, will follow in a later commit.
2017-06-08 16:04:27 +00:00
0, 0, 0, 0, 97, 0, 0, 0,
zclsyntax: heredoc support in the scanner
2017-05-29 15:55:53 +00:00
0, 0, 0, 0, 0, 0, 0, 0,
zclsyntax: identifiers in the scanner
2017-05-28 16:16:53 +00:00
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
zclwrite: absorb lead comments into attributes The native parser's ranges don't include any surrounding comments, so we need to do a little more work to pick them out of the surrounding token sequences. This just takes care of _lead_ comments, which are those that appear as whole line comments above the item in question. Line comments, which appear after the item on the same line, will follow in a later commit.
2017-06-08 16:04:27 +00:00
0, 0, 121, 144, 0, 0, 0, 0,
zclsyntax: identifiers in the scanner
2017-05-28 16:16:53 +00:00
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
zclsyntax: scan multi-character punctuation tokens
2017-05-28 16:40:58 +00:00
0, 0, 0, 0, 0, 0, 0, 0,
zclsyntax: heredoc support in the scanner
2017-05-29 15:55:53 +00:00
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
zclwrite: absorb lead comments into attributes The native parser's ranges don't include any surrounding comments, so we need to do a little more work to pick them out of the surrounding token sequences. This just takes care of _lead_ comments, which are those that appear as whole line comments above the item in question. Line comments, which appear after the item on the same line, will follow in a later commit.
2017-06-08 16:04:27 +00:00
0, 0, 0, 0, 125, 101, 0, 0,
zclsyntax: heredoc support in the scanner
2017-05-29 15:55:53 +00:00
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
zclsyntax: scanning of comments
2017-05-29 16:13:35 +00:00
0, 0, 0, 0, 0, 27, 5, 0,
zclwrite: absorb lead comments into attributes The native parser's ranges don't include any surrounding comments, so we need to do a little more work to pick them out of the surrounding token sequences. This just takes care of _lead_ comments, which are those that appear as whole line comments above the item in question. Line comments, which appear after the item on the same line, will follow in a later commit.
2017-06-08 16:04:27 +00:00
0, 29, 0, 49, 35, 47, 132, 0,
0, 0, 0, 69, 55, 67, 138, 0,
0, 0, 0, 0, 73, 0, 0, 0,
95, 156, 0, 87, 150, 5, 0, 0,
89, 0, 91, 0, 99, 0, 0, 0,
zclsyntax: separate tokens for assign = and equality test ==
2017-06-04 23:00:40 +00:00
0, 0, 0, 0, 0, 0, 0, 0,
zclsyntax: heredoc support in the scanner
2017-05-29 15:55:53 +00:00
0, 0, 0, 0, 0, 0, 0, 0,
zclwrite: absorb lead comments into attributes The native parser's ranges don't include any surrounding comments, so we need to do a little more work to pick them out of the surrounding token sequences. This just takes care of _lead_ comments, which are those that appear as whole line comments above the item in question. Line comments, which appear after the item on the same line, will follow in a later commit.
2017-06-08 16:04:27 +00:00
0, 0, 0, 5, 5, 5, 153, 153,
153, 153, 153, 153, 5, 5, 153, 5,
113, 117, 103, 111, 77, 83, 109, 105,
0, 0, 81, 75, 79, 107, 0, 0,
zclsyntax: heredoc support in the scanner
2017-05-29 15:55:53 +00:00
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
zclwrite: absorb lead comments into attributes The native parser's ranges don't include any surrounding comments, so we need to do a little more work to pick them out of the surrounding token sequences. This just takes care of _lead_ comments, which are those that appear as whole line comments above the item in question. Line comments, which appear after the item on the same line, will follow in a later commit.
2017-06-08 16:04:27 +00:00
0, 85, 93, 115, 0, 0, 0, 0,
zclsyntax: heredoc support in the scanner
2017-05-29 15:55:53 +00:00
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
zclsyntax: separate tokens for assign = and equality test ==
2017-06-04 23:00:40 +00:00
0, 0, 0, 13, 0, 11, 0, 5,
15, 0, 5, 5, 21, 0, 0, 0,
5, 5, 5, 23, 0, 19, 9, 0,
17, 7, 25, 0, 0, 0, 0, 37,
zclwrite: absorb lead comments into attributes The native parser's ranges don't include any surrounding comments, so we need to do a little more work to pick them out of the surrounding token sequences. This just takes care of _lead_ comments, which are those that appear as whole line comments above the item in question. Line comments, which appear after the item on the same line, will follow in a later commit.
2017-06-08 16:04:27 +00:00
0, 135, 135, 43, 0, 0, 41, 33,
zclsyntax: separate tokens for assign = and equality test ==
2017-06-04 23:00:40 +00:00
39, 31, 45, 0, 0, 0, 57, 0,
zclwrite: absorb lead comments into attributes The native parser's ranges don't include any surrounding comments, so we need to do a little more work to pick them out of the surrounding token sequences. This just takes care of _lead_ comments, which are those that appear as whole line comments above the item in question. Line comments, which appear after the item on the same line, will follow in a later commit.
2017-06-08 16:04:27 +00:00
141, 141, 63, 0, 0, 61, 53, 59,
zclsyntax: separate tokens for assign = and equality test ==
2017-06-04 23:00:40 +00:00
51, 65,
zclsyntax: start of a ragel-based scanner Using Ragel here because the scanner is going to be somewhat complex due to the need to switch back and forth between normal and template states, etc. This should be easier to maintain than a hand-written scanner, while ragel gives us the extra features we need to implement things that would normally be too complex for a "regular" scanner generator.
2017-05-28 02:01:43 +00:00
}
var _zcltok_to_state_actions []byte = []byte{
zclsyntax: identifiers in the scanner
2017-05-28 16:16:53 +00:00
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
zclsyntax: scanner support of string templates This requires some extra state-keeping because we allow templates to be nested inside templates. This takes us outside of the world of regular languages, but we accept that here because it makes things easier to deal with down the line in the parser. The methodology is to keep track of how many braces are open at a given time and then, when a nested template interpolation begins, record the current brace level. Then, when a closing brace is encountered, if its nesting level is at the top of the stack then we pop off the stack and return to "main" parsing mode. Ragel's existing idea of calling and returning from machines is important here too. As this currently stands this is not actually needed, but once heredocs are in play we will have two possible places to return to at the end of an interpolation sequence, so the state return stack maintained by Ragel will determine whether to return to string mode or heredoc mode.
2017-05-28 22:33:01 +00:00
0, 0, 0, 0, 0, 0, 0, 0,
zclsyntax: heredoc support in the scanner
2017-05-29 15:55:53 +00:00
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
zclsyntax: identifiers in the scanner
2017-05-28 16:16:53 +00:00
0, 0, 0, 0, 0, 0, 0, 0,
zclsyntax: scanning of bare (top-level) templates This alternative scanning mode makes the scanner start in template context rather than normal context. This will be later used by the parser to allow parsing of standalone templates that aren't embedded inside a zcl configuration file.
2017-05-29 16:42:20 +00:00
0, 0, 0, 1, 0, 0, 0, 0,
zclsyntax: identifiers in the scanner
2017-05-28 16:16:53 +00:00
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
zclsyntax: scan multi-character punctuation tokens
2017-05-28 16:40:58 +00:00
0, 0, 0, 0, 0, 0, 0, 0,
zclsyntax: scanning of comments
2017-05-29 16:13:35 +00:00
0, 0, 0, 0, 0, 0, 0, 0,
zclsyntax: separate tokens for assign = and equality test ==
2017-06-04 23:00:40 +00:00
0, 0, 0, 0, 0, 0, 1, 0,
zclsyntax: scanning of bare (top-level) templates This alternative scanning mode makes the scanner start in template context rather than normal context. This will be later used by the parser to allow parsing of standalone templates that aren't embedded inside a zcl configuration file.
2017-05-29 16:42:20 +00:00
0, 0, 0, 0, 0, 0, 0, 0,
zclwrite: absorb lead comments into attributes The native parser's ranges don't include any surrounding comments, so we need to do a little more work to pick them out of the surrounding token sequences. This just takes care of _lead_ comments, which are those that appear as whole line comments above the item in question. Line comments, which appear after the item on the same line, will follow in a later commit.
2017-06-08 16:04:27 +00:00
0, 0, 0, 0, 129, 0, 0, 0,
0, 0, 0, 129, 0, 0, 0, 0,
zclsyntax: separate tokens for assign = and equality test ==
2017-06-04 23:00:40 +00:00
0, 0,
zclsyntax: start of a ragel-based scanner Using Ragel here because the scanner is going to be somewhat complex due to the need to switch back and forth between normal and template states, etc. This should be easier to maintain than a hand-written scanner, while ragel gives us the extra features we need to implement things that would normally be too complex for a "regular" scanner generator.
2017-05-28 02:01:43 +00:00
}
var _zcltok_from_state_actions []byte = []byte{
zclsyntax: identifiers in the scanner
2017-05-28 16:16:53 +00:00
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
zclsyntax: heredoc support in the scanner
2017-05-29 15:55:53 +00:00
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
zclsyntax: scanning of bare (top-level) templates This alternative scanning mode makes the scanner start in template context rather than normal context. This will be later used by the parser to allow parsing of standalone templates that aren't embedded inside a zcl configuration file.
2017-05-29 16:42:20 +00:00
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 3, 0, 0, 0, 0,
zclsyntax: identifiers in the scanner
2017-05-28 16:16:53 +00:00
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
zclsyntax: scan multi-character punctuation tokens
2017-05-28 16:40:58 +00:00
0, 0, 0, 0, 0, 0, 0, 0,
zclsyntax: scanner support of string templates This requires some extra state-keeping because we allow templates to be nested inside templates. This takes us outside of the world of regular languages, but we accept that here because it makes things easier to deal with down the line in the parser. The methodology is to keep track of how many braces are open at a given time and then, when a nested template interpolation begins, record the current brace level. Then, when a closing brace is encountered, if its nesting level is at the top of the stack then we pop off the stack and return to "main" parsing mode. Ragel's existing idea of calling and returning from machines is important here too. As this currently stands this is not actually needed, but once heredocs are in play we will have two possible places to return to at the end of an interpolation sequence, so the state return stack maintained by Ragel will determine whether to return to string mode or heredoc mode.
2017-05-28 22:33:01 +00:00
0, 0, 0, 0, 0, 0, 0, 0,
zclsyntax: separate tokens for assign = and equality test ==
2017-06-04 23:00:40 +00:00
0, 0, 0, 0, 0, 0, 3, 0,
zclsyntax: scanning of comments
2017-05-29 16:13:35 +00:00
0, 0, 0, 0, 0, 0, 0, 0,
zclsyntax: separate tokens for assign = and equality test ==
2017-06-04 23:00:40 +00:00
0, 0, 0, 0, 3, 0, 0, 0,
zclsyntax: scanning of bare (top-level) templates This alternative scanning mode makes the scanner start in template context rather than normal context. This will be later used by the parser to allow parsing of standalone templates that aren't embedded inside a zcl configuration file.
2017-05-29 16:42:20 +00:00
0, 0, 0, 3, 0, 0, 0, 0,
zclsyntax: separate tokens for assign = and equality test ==
2017-06-04 23:00:40 +00:00
0, 0,
zclsyntax: start of a ragel-based scanner Using Ragel here because the scanner is going to be somewhat complex due to the need to switch back and forth between normal and template states, etc. This should be easier to maintain than a hand-written scanner, while ragel gives us the extra features we need to implement things that would normally be too complex for a "regular" scanner generator.
2017-05-28 02:01:43 +00:00
}
zclsyntax: identifiers in the scanner
2017-05-28 16:16:53 +00:00
var _zcltok_eof_trans []int16 = []int16{
zclsyntax: scanning of comments
2017-05-29 16:13:35 +00:00
0, 1, 1, 1, 7, 7, 10, 10,
10, 10, 10, 10, 10, 10, 10, 10,
10, 10, 10, 10, 10, 10, 10, 10,
10, 10, 10, 10, 10, 10, 10, 10,
10, 10, 10, 10, 10, 10, 10, 10,
10, 10, 10, 10, 10, 10, 10, 10,
10, 10, 10, 10, 10, 10, 10, 10,
10, 10, 10, 10, 10, 10, 10, 10,
10, 10, 10, 10, 10, 10, 10, 10,
10, 10, 10, 10, 10, 10, 10, 10,
10, 10, 10, 10, 10, 10, 10, 10,
10, 10, 10, 10, 10, 10, 10, 10,
10, 10, 10, 10, 10, 10, 10, 10,
10, 10, 10, 10, 10, 10, 10, 10,
10, 10, 10, 10, 10, 10, 10, 10,
10, 10, 10, 10, 10, 10, 10, 10,
10, 10, 10, 10, 10, 10, 10, 10,
10, 10, 10, 10, 10, 10, 10, 10,
10, 10, 10, 10, 10, 10, 10, 10,
10, 10, 10, 10, 10, 10, 10, 10,
10, 10, 10, 10, 10, 10, 10, 10,
10, 10, 10, 10, 10, 10, 10, 10,
10, 10, 10, 10, 10, 10, 10, 10,
10, 10, 10, 10, 10, 10, 10, 10,
10, 10, 10, 10, 10, 10, 10, 10,
10, 10, 10, 10, 10, 10, 10, 10,
10, 10, 10, 10, 10, 10, 10, 10,
10, 10, 10, 10, 10, 10, 10, 10,
10, 10, 10, 10, 10, 10, 10, 10,
10, 10, 10, 10, 10, 10, 10, 10,
10, 10, 10, 10, 10, 10, 10, 10,
10, 10, 10, 10, 10, 10, 10, 10,
10, 10, 10, 10, 10, 10, 10, 10,
10, 10, 10, 10, 10, 10, 10, 10,
10, 10, 10, 10, 10, 10, 10, 10,
10, 10, 10, 10, 10, 10, 10, 10,
10, 10, 10, 10, 10, 10, 10, 10,
10, 10, 10, 10, 10, 10, 10, 10,
10, 10, 10, 10, 10, 10, 10, 10,
10, 10, 10, 10, 10, 10, 10, 10,
10, 10, 10, 10, 10, 10, 10, 10,
10, 10, 10, 10, 10, 10, 10, 10,
10, 10, 10, 10, 10, 10, 10, 10,
10, 10, 10, 10, 10, 10, 10, 10,
10, 10, 10, 10, 10, 10, 10, 10,
10, 10, 10, 10, 10, 10, 10, 10,
10, 10, 10, 10, 10, 10, 10, 10,
10, 10, 10, 10, 10, 10, 10, 10,
10, 10, 10, 10, 10, 10, 10, 10,
10, 10, 10, 10, 10, 10, 10, 10,
10, 10, 10, 10, 10, 10, 10, 10,
10, 10, 10, 10, 10, 10, 419, 419,
1, 419, 419, 419, 419, 419, 419, 419,
419, 419, 419, 419, 419, 419, 419, 419,
419, 419, 419, 419, 419, 419, 419, 419,
419, 419, 419, 419, 419, 419, 419, 419,
419, 419, 419, 419, 419, 419, 419, 419,
419, 419, 419, 419, 419, 419, 419, 419,
419, 419, 419, 419, 419, 419, 419, 419,
419, 419, 419, 419, 419, 419, 419, 419,
419, 419, 419, 419, 419, 419, 419, 419,
419, 419, 419, 419, 419, 419, 419, 419,
419, 419, 419, 419, 419, 419, 419, 419,
419, 419, 419, 419, 419, 419, 419, 419,
419, 419, 419, 419, 419, 419, 419, 419,
419, 419, 419, 419, 419, 419, 419, 419,
419, 419, 419, 419, 419, 419, 419, 419,
419, 419, 419, 419, 419, 419, 419, 419,
419, 419, 419, 419, 419, 419, 419, 419,
419, 419, 419, 419, 419, 419, 419, 419,
419, 419, 419, 419, 419, 419, 419, 419,
419, 419, 419, 419, 419, 419, 419, 419,
419, 419, 419, 419, 419, 419, 419, 419,
419, 419, 419, 419, 419, 419, 419, 419,
419, 419, 419, 419, 419, 419, 419, 419,
419, 419, 419, 419, 419, 419, 419, 419,
419, 419, 419, 419, 419, 419, 419, 419,
419, 419, 419, 419, 419, 419, 419, 419,
419, 419, 419, 419, 419, 419, 419, 419,
419, 419, 419, 419, 419, 419, 419, 419,
419, 419, 419, 419, 419, 419, 419, 419,
419, 419, 419, 419, 419, 419, 419, 419,
419, 419, 419, 419, 419, 419, 419, 419,
419, 419, 419, 419, 419, 419, 419, 419,
419, 419, 419, 419, 419, 419, 419, 419,
419, 419, 419, 419, 419, 419, 419, 419,
419, 669, 669, 669, 669, 669, 669, 669,
669, 669, 669, 669, 669, 669, 669, 669,
669, 669, 669, 669, 669, 669, 669, 669,
669, 669, 669, 669, 669, 669, 669, 669,
669, 669, 669, 669, 669, 669, 669, 669,
669, 669, 669, 669, 669, 669, 669, 669,
669, 669, 669, 669, 669, 669, 669, 669,
669, 669, 669, 669, 669, 669, 669, 669,
669, 669, 669, 669, 669, 669, 669, 669,
669, 669, 669, 669, 669, 669, 669, 669,
669, 669, 669, 669, 669, 669, 669, 669,
669, 669, 669, 669, 669, 669, 669, 669,
669, 669, 669, 669, 669, 669, 669, 669,
669, 669, 669, 669, 669, 669, 669, 669,
669, 669, 669, 669, 669, 669, 669, 669,
669, 669, 669, 669, 669, 669, 669, 669,
669, 669, 669, 669, 669, 669, 669, 669,
669, 669, 669, 669, 669, 669, 669, 669,
669, 669, 669, 669, 669, 669, 669, 669,
669, 669, 669, 669, 669, 669, 669, 669,
669, 669, 669, 669, 669, 669, 669, 669,
669, 669, 669, 669, 669, 669, 669, 669,
669, 669, 669, 669, 669, 669, 669, 669,
669, 669, 669, 669, 669, 669, 669, 669,
669, 669, 669, 669, 669, 669, 669, 669,
669, 669, 669, 669, 669, 669, 669, 669,
669, 669, 669, 669, 669, 669, 669, 669,
669, 669, 669, 669, 669, 669, 669, 669,
669, 669, 669, 669, 669, 669, 669, 669,
669, 669, 669, 669, 669, 669, 669, 766,
766, 766, 766, 770, 770, 772, 774, 772,
zclsyntax: scanning of bare (top-level) templates This alternative scanning mode makes the scanner start in template context rather than normal context. This will be later used by the parser to allow parsing of standalone templates that aren't embedded inside a zcl configuration file.
2017-05-29 16:42:20 +00:00
772, 774, 0, 0, 780, 782, 780, 780,
zclsyntax: separate tokens for assign = and equality test ==
2017-06-04 23:00:40 +00:00
782, 0, 0, 0, 841, 842, 843, 844,
zclwrite: absorb lead comments into attributes The native parser's ranges don't include any surrounding comments, so we need to do a little more work to pick them out of the surrounding token sequences. This just takes care of _lead_ comments, which are those that appear as whole line comments above the item in question. Line comments, which appear after the item on the same line, will follow in a later commit.
2017-06-08 16:04:27 +00:00
842, 844, 844, 847, 848, 844, 844, 844,
zclsyntax: separate tokens for assign = and equality test ==
2017-06-04 23:00:40 +00:00
854, 844, 844, 884, 884, 884, 884, 884,
884, 884, 884, 884, 884, 884, 884, 884,
884, 884, 884, 884, 884, 884, 884, 884,
884, 884, 884, 884, 884, 884, 884, 884,
884, 884, 884, 884, 884, 884, 0, 1037,
1037, 1037, 1037, 1037, 1037, 1044, 1046, 1044,
1049, 1051, 1051, 1051, 0, 1060, 1063, 1065,
1067, 1067, 1067, 0, 1075, 1078, 1080, 1082,
1082, 1082,
zclsyntax: start of a ragel-based scanner Using Ragel here because the scanner is going to be somewhat complex due to the need to switch back and forth between normal and template states, etc. This should be easier to maintain than a hand-written scanner, while ragel gives us the extra features we need to implement things that would normally be too complex for a "regular" scanner generator.
2017-05-28 02:01:43 +00:00
}
zclsyntax: scanning of bare (top-level) templates This alternative scanning mode makes the scanner start in template context rather than normal context. This will be later used by the parser to allow parsing of standalone templates that aren't embedded inside a zcl configuration file.
2017-05-29 16:42:20 +00:00
const zcltok_start int = 947
const zcltok_first_final int = 947
zclsyntax: heredoc support in the scanner
2017-05-29 15:55:53 +00:00
const zcltok_error int = 0
zclsyntax: start of a ragel-based scanner Using Ragel here because the scanner is going to be somewhat complex due to the need to switch back and forth between normal and template states, etc. This should be easier to maintain than a hand-written scanner, while ragel gives us the extra features we need to implement things that would normally be too complex for a "regular" scanner generator.
2017-05-28 02:01:43 +00:00
zclsyntax: separate tokens for assign = and equality test ==
2017-06-04 23:00:40 +00:00
const zcltok_en_stringTemplate int = 998
const zcltok_en_heredocTemplate int = 1012
const zcltok_en_bareTemplate int = 1019
zclsyntax: scanning of bare (top-level) templates This alternative scanning mode makes the scanner start in template context rather than normal context. This will be later used by the parser to allow parsing of standalone templates that aren't embedded inside a zcl configuration file.
2017-05-29 16:42:20 +00:00
const zcltok_en_main int = 947
zclsyntax: start of a ragel-based scanner Using Ragel here because the scanner is going to be somewhat complex due to the need to switch back and forth between normal and template states, etc. This should be easier to maintain than a hand-written scanner, while ragel gives us the extra features we need to implement things that would normally be too complex for a "regular" scanner generator.
2017-05-28 02:01:43 +00:00
zclsyntax: heredoc support in the scanner
2017-05-29 15:55:53 +00:00
// line 15 "scan_tokens.rl"
zclsyntax: start of a ragel-based scanner Using Ragel here because the scanner is going to be somewhat complex due to the need to switch back and forth between normal and template states, etc. This should be easier to maintain than a hand-written scanner, while ragel gives us the extra features we need to implement things that would normally be too complex for a "regular" scanner generator.
2017-05-28 02:01:43 +00:00
zclsyntax: allow scanner to support multiple modes A scanner "mode" decides which state it starts in, allowing us to start in template mode for parsing top-level templates. However, currently the only mode implemented is "normal" mode, which is the behavior we had before.
2017-05-28 22:44:22 +00:00
func scanTokens(data []byte, filename string, start zcl.Pos, mode scanMode) []Token {
zclsyntax: scanner to return whole token slice at once On reflection, it seems easier to maintain the necessary state we need by doing all of the scanning in a single pass, since we can then just use local variables within the scanner function.
2017-05-28 14:11:24 +00:00
f := &tokenAccum{
zclsyntax: start of a ragel-based scanner Using Ragel here because the scanner is going to be somewhat complex due to the need to switch back and forth between normal and template states, etc. This should be easier to maintain than a hand-written scanner, while ragel gives us the extra features we need to implement things that would normally be too complex for a "regular" scanner generator.
2017-05-28 02:01:43 +00:00
Filename: filename,
Bytes: data,
zclsyntax: re-organize and simplify the scanner
2017-05-28 15:38:13 +00:00
Pos: start,
zclsyntax: start of a ragel-based scanner Using Ragel here because the scanner is going to be somewhat complex due to the need to switch back and forth between normal and template states, etc. This should be easier to maintain than a hand-written scanner, while ragel gives us the extra features we need to implement things that would normally be too complex for a "regular" scanner generator.
2017-05-28 02:01:43 +00:00
}
zclsyntax: separate tokens for assign = and equality test ==
2017-06-04 23:00:40 +00:00
// line 266 "scan_tokens.rl"
zclsyntax: start of a ragel-based scanner Using Ragel here because the scanner is going to be somewhat complex due to the need to switch back and forth between normal and template states, etc. This should be easier to maintain than a hand-written scanner, while ragel gives us the extra features we need to implement things that would normally be too complex for a "regular" scanner generator.
2017-05-28 02:01:43 +00:00
// Ragel state
p := 0 // "Pointer" into data
pe := len(data) // End-of-data "pointer"
ts := 0
te := 0
act := 0
eof := pe
zclsyntax: scanner support of string templates This requires some extra state-keeping because we allow templates to be nested inside templates. This takes us outside of the world of regular languages, but we accept that here because it makes things easier to deal with down the line in the parser. The methodology is to keep track of how many braces are open at a given time and then, when a nested template interpolation begins, record the current brace level. Then, when a closing brace is encountered, if its nesting level is at the top of the stack then we pop off the stack and return to "main" parsing mode. Ragel's existing idea of calling and returning from machines is important here too. As this currently stands this is not actually needed, but once heredocs are in play we will have two possible places to return to at the end of an interpolation sequence, so the state return stack maintained by Ragel will determine whether to return to string mode or heredoc mode.
2017-05-28 22:33:01 +00:00
var stack []int
var top int
zclsyntax: allow scanner to support multiple modes A scanner "mode" decides which state it starts in, allowing us to start in template mode for parsing top-level templates. However, currently the only mode implemented is "normal" mode, which is the behavior we had before.
2017-05-28 22:44:22 +00:00
var cs int // current state
switch mode {
case scanNormal:
cs = zcltok_en_main
case scanTemplate:
zclsyntax: scanning of bare (top-level) templates This alternative scanning mode makes the scanner start in template context rather than normal context. This will be later used by the parser to allow parsing of standalone templates that aren't embedded inside a zcl configuration file.
2017-05-29 16:42:20 +00:00
cs = zcltok_en_bareTemplate
zclsyntax: allow scanner to support multiple modes A scanner "mode" decides which state it starts in, allowing us to start in template mode for parsing top-level templates. However, currently the only mode implemented is "normal" mode, which is the behavior we had before.
2017-05-28 22:44:22 +00:00
default:
panic("invalid scanMode")
}
zclsyntax: scanner support of string templates This requires some extra state-keeping because we allow templates to be nested inside templates. This takes us outside of the world of regular languages, but we accept that here because it makes things easier to deal with down the line in the parser. The methodology is to keep track of how many braces are open at a given time and then, when a nested template interpolation begins, record the current brace level. Then, when a closing brace is encountered, if its nesting level is at the top of the stack then we pop off the stack and return to "main" parsing mode. Ragel's existing idea of calling and returning from machines is important here too. As this currently stands this is not actually needed, but once heredocs are in play we will have two possible places to return to at the end of an interpolation sequence, so the state return stack maintained by Ragel will determine whether to return to string mode or heredoc mode.
2017-05-28 22:33:01 +00:00
braces := 0
zclsyntax: heredoc support in the scanner
2017-05-29 15:55:53 +00:00
var retBraces []int // stack of brace levels that cause us to use fret
var heredocs []heredocInProgress // stack of heredocs we're currently processing
zclsyntax: scanner support of string templates This requires some extra state-keeping because we allow templates to be nested inside templates. This takes us outside of the world of regular languages, but we accept that here because it makes things easier to deal with down the line in the parser. The methodology is to keep track of how many braces are open at a given time and then, when a nested template interpolation begins, record the current brace level. Then, when a closing brace is encountered, if its nesting level is at the top of the stack then we pop off the stack and return to "main" parsing mode. Ragel's existing idea of calling and returning from machines is important here too. As this currently stands this is not actually needed, but once heredocs are in play we will have two possible places to return to at the end of an interpolation sequence, so the state return stack maintained by Ragel will determine whether to return to string mode or heredoc mode.
2017-05-28 22:33:01 +00:00
zclsyntax: separate tokens for assign = and equality test ==
2017-06-04 23:00:40 +00:00
// line 299 "scan_tokens.rl"
zclsyntax: start of a ragel-based scanner Using Ragel here because the scanner is going to be somewhat complex due to the need to switch back and forth between normal and template states, etc. This should be easier to maintain than a hand-written scanner, while ragel gives us the extra features we need to implement things that would normally be too complex for a "regular" scanner generator.
2017-05-28 02:01:43 +00:00
// Make Go compiler happy
_ = ts
_ = te
_ = act
_ = eof
zclsyntax: re-organize and simplify the scanner
2017-05-28 15:38:13 +00:00
token := func(ty TokenType) {
f.emitToken(ty, ts, te)
}
zclsyntax: scan single-character tokens that represent themselves For convenience we use the rune values of these tokens as their token enum values, so we can handle them all via a single rule.
2017-05-28 16:34:20 +00:00
selfToken := func() {
b := data[ts:te]
if len(b) != 1 {
// should never happen
panic("selfToken only works for single-character tokens")
}
f.emitToken(TokenType(b[0]), ts, te)
}
zclsyntax: re-organize and simplify the scanner
2017-05-28 15:38:13 +00:00
zclsyntax: separate tokens for assign = and equality test ==
2017-06-04 23:00:40 +00:00
// line 2812 "scan_tokens.go"
zclsyntax: start of a ragel-based scanner Using Ragel here because the scanner is going to be somewhat complex due to the need to switch back and forth between normal and template states, etc. This should be easier to maintain than a hand-written scanner, while ragel gives us the extra features we need to implement things that would normally be too complex for a "regular" scanner generator.
2017-05-28 02:01:43 +00:00
{
zclsyntax: scanner support of string templates This requires some extra state-keeping because we allow templates to be nested inside templates. This takes us outside of the world of regular languages, but we accept that here because it makes things easier to deal with down the line in the parser. The methodology is to keep track of how many braces are open at a given time and then, when a nested template interpolation begins, record the current brace level. Then, when a closing brace is encountered, if its nesting level is at the top of the stack then we pop off the stack and return to "main" parsing mode. Ragel's existing idea of calling and returning from machines is important here too. As this currently stands this is not actually needed, but once heredocs are in play we will have two possible places to return to at the end of an interpolation sequence, so the state return stack maintained by Ragel will determine whether to return to string mode or heredoc mode.
2017-05-28 22:33:01 +00:00
top = 0
zclsyntax: start of a ragel-based scanner Using Ragel here because the scanner is going to be somewhat complex due to the need to switch back and forth between normal and template states, etc. This should be easier to maintain than a hand-written scanner, while ragel gives us the extra features we need to implement things that would normally be too complex for a "regular" scanner generator.
2017-05-28 02:01:43 +00:00
ts = 0
te = 0
act = 0
}
zclsyntax: separate tokens for assign = and equality test ==
2017-06-04 23:00:40 +00:00
// line 2820 "scan_tokens.go"
zclsyntax: start of a ragel-based scanner Using Ragel here because the scanner is going to be somewhat complex due to the need to switch back and forth between normal and template states, etc. This should be easier to maintain than a hand-written scanner, while ragel gives us the extra features we need to implement things that would normally be too complex for a "regular" scanner generator.
2017-05-28 02:01:43 +00:00
{
var _klen int
var _trans int
var _acts int
var _nacts uint
var _keys int
if p == pe {
goto _test_eof
}
zclsyntax: heredoc support in the scanner
2017-05-29 15:55:53 +00:00
if cs == 0 {
goto _out
}
zclsyntax: start of a ragel-based scanner Using Ragel here because the scanner is going to be somewhat complex due to the need to switch back and forth between normal and template states, etc. This should be easier to maintain than a hand-written scanner, while ragel gives us the extra features we need to implement things that would normally be too complex for a "regular" scanner generator.
2017-05-28 02:01:43 +00:00
_resume:
_acts = int(_zcltok_from_state_actions[cs])
_nacts = uint(_zcltok_actions[_acts])
_acts++
for ; _nacts > 0; _nacts-- {
_acts++
switch _zcltok_actions[_acts-1] {
zclsyntax: heredoc support in the scanner
2017-05-29 15:55:53 +00:00
case 2:
zclsyntax: start of a ragel-based scanner Using Ragel here because the scanner is going to be somewhat complex due to the need to switch back and forth between normal and template states, etc. This should be easier to maintain than a hand-written scanner, while ragel gives us the extra features we need to implement things that would normally be too complex for a "regular" scanner generator.
2017-05-28 02:01:43 +00:00
// line 1 "NONE"
ts = p
zclsyntax: separate tokens for assign = and equality test ==
2017-06-04 23:00:40 +00:00
// line 2844 "scan_tokens.go"
zclsyntax: start of a ragel-based scanner Using Ragel here because the scanner is going to be somewhat complex due to the need to switch back and forth between normal and template states, etc. This should be easier to maintain than a hand-written scanner, while ragel gives us the extra features we need to implement things that would normally be too complex for a "regular" scanner generator.
2017-05-28 02:01:43 +00:00
}
}
_keys = int(_zcltok_key_offsets[cs])
_trans = int(_zcltok_index_offsets[cs])
_klen = int(_zcltok_single_lengths[cs])
if _klen > 0 {
_lower := int(_keys)
var _mid int
_upper := int(_keys + _klen - 1)
for {
if _upper < _lower {
break
}
_mid = _lower + ((_upper - _lower) >> 1)
switch {
case data[p] < _zcltok_trans_keys[_mid]:
_upper = _mid - 1
case data[p] > _zcltok_trans_keys[_mid]:
_lower = _mid + 1
default:
_trans += int(_mid - int(_keys))
goto _match
}
}
_keys += _klen
_trans += _klen
}
_klen = int(_zcltok_range_lengths[cs])
if _klen > 0 {
_lower := int(_keys)
var _mid int
_upper := int(_keys + (_klen << 1) - 2)
for {
if _upper < _lower {
break
}
_mid = _lower + (((_upper - _lower) >> 1) & ^1)
switch {
case data[p] < _zcltok_trans_keys[_mid]:
_upper = _mid - 2
case data[p] > _zcltok_trans_keys[_mid+1]:
_lower = _mid + 2
default:
_trans += int((_mid - int(_keys)) >> 1)
goto _match
}
}
_trans += _klen
}
_match:
zclsyntax: identifiers in the scanner
2017-05-28 16:16:53 +00:00
_trans = int(_zcltok_indicies[_trans])
zclsyntax: start of a ragel-based scanner Using Ragel here because the scanner is going to be somewhat complex due to the need to switch back and forth between normal and template states, etc. This should be easier to maintain than a hand-written scanner, while ragel gives us the extra features we need to implement things that would normally be too complex for a "regular" scanner generator.
2017-05-28 02:01:43 +00:00
_eof_trans:
cs = int(_zcltok_trans_targs[_trans])
if _zcltok_trans_actions[_trans] == 0 {
goto _again
}
_acts = int(_zcltok_trans_actions[_trans])
_nacts = uint(_zcltok_actions[_acts])
_acts++
for ; _nacts > 0; _nacts-- {
_acts++
switch _zcltok_actions[_acts-1] {
zclsyntax: heredoc support in the scanner
2017-05-29 15:55:53 +00:00
case 3:
zclsyntax: start of a ragel-based scanner Using Ragel here because the scanner is going to be somewhat complex due to the need to switch back and forth between normal and template states, etc. This should be easier to maintain than a hand-written scanner, while ragel gives us the extra features we need to implement things that would normally be too complex for a "regular" scanner generator.
2017-05-28 02:01:43 +00:00
// line 1 "NONE"
te = p + 1
zclsyntax: heredoc support in the scanner
2017-05-29 15:55:53 +00:00
case 4:
zclsyntax: separate tokens for assign = and equality test ==
2017-06-04 23:00:40 +00:00
// line 134 "scan_tokens.rl"
zclsyntax: start of a ragel-based scanner Using Ragel here because the scanner is going to be somewhat complex due to the need to switch back and forth between normal and template states, etc. This should be easier to maintain than a hand-written scanner, while ragel gives us the extra features we need to implement things that would normally be too complex for a "regular" scanner generator.
2017-05-28 02:01:43 +00:00
te = p + 1
{
zclsyntax: scanner support of string templates This requires some extra state-keeping because we allow templates to be nested inside templates. This takes us outside of the world of regular languages, but we accept that here because it makes things easier to deal with down the line in the parser. The methodology is to keep track of how many braces are open at a given time and then, when a nested template interpolation begins, record the current brace level. Then, when a closing brace is encountered, if its nesting level is at the top of the stack then we pop off the stack and return to "main" parsing mode. Ragel's existing idea of calling and returning from machines is important here too. As this currently stands this is not actually needed, but once heredocs are in play we will have two possible places to return to at the end of an interpolation sequence, so the state return stack maintained by Ragel will determine whether to return to string mode or heredoc mode.
2017-05-28 22:33:01 +00:00
token(TokenTemplateInterp)
braces++
retBraces = append(retBraces, braces)
zclsyntax: heredoc support in the scanner
2017-05-29 15:55:53 +00:00
if len(heredocs) > 0 {
heredocs[len(heredocs)-1].StartOfLine = false
}
zclsyntax: scanner support of string templates This requires some extra state-keeping because we allow templates to be nested inside templates. This takes us outside of the world of regular languages, but we accept that here because it makes things easier to deal with down the line in the parser. The methodology is to keep track of how many braces are open at a given time and then, when a nested template interpolation begins, record the current brace level. Then, when a closing brace is encountered, if its nesting level is at the top of the stack then we pop off the stack and return to "main" parsing mode. Ragel's existing idea of calling and returning from machines is important here too. As this currently stands this is not actually needed, but once heredocs are in play we will have two possible places to return to at the end of an interpolation sequence, so the state return stack maintained by Ragel will determine whether to return to string mode or heredoc mode.
2017-05-28 22:33:01 +00:00
{
stack = append(stack, 0)
stack[top] = cs
top++
zclsyntax: scanning of bare (top-level) templates This alternative scanning mode makes the scanner start in template context rather than normal context. This will be later used by the parser to allow parsing of standalone templates that aren't embedded inside a zcl configuration file.
2017-05-29 16:42:20 +00:00
cs = 947
zclsyntax: scanner support of string templates This requires some extra state-keeping because we allow templates to be nested inside templates. This takes us outside of the world of regular languages, but we accept that here because it makes things easier to deal with down the line in the parser. The methodology is to keep track of how many braces are open at a given time and then, when a nested template interpolation begins, record the current brace level. Then, when a closing brace is encountered, if its nesting level is at the top of the stack then we pop off the stack and return to "main" parsing mode. Ragel's existing idea of calling and returning from machines is important here too. As this currently stands this is not actually needed, but once heredocs are in play we will have two possible places to return to at the end of an interpolation sequence, so the state return stack maintained by Ragel will determine whether to return to string mode or heredoc mode.
2017-05-28 22:33:01 +00:00
goto _again
}
zclsyntax: start of a ragel-based scanner Using Ragel here because the scanner is going to be somewhat complex due to the need to switch back and forth between normal and template states, etc. This should be easier to maintain than a hand-written scanner, while ragel gives us the extra features we need to implement things that would normally be too complex for a "regular" scanner generator.
2017-05-28 02:01:43 +00:00
}
zclsyntax: heredoc support in the scanner
2017-05-29 15:55:53 +00:00
case 5:
zclsyntax: separate tokens for assign = and equality test ==
2017-06-04 23:00:40 +00:00
// line 144 "scan_tokens.rl"
zclsyntax: start of a ragel-based scanner Using Ragel here because the scanner is going to be somewhat complex due to the need to switch back and forth between normal and template states, etc. This should be easier to maintain than a hand-written scanner, while ragel gives us the extra features we need to implement things that would normally be too complex for a "regular" scanner generator.
2017-05-28 02:01:43 +00:00
te = p + 1
{
zclsyntax: scanner support of string templates This requires some extra state-keeping because we allow templates to be nested inside templates. This takes us outside of the world of regular languages, but we accept that here because it makes things easier to deal with down the line in the parser. The methodology is to keep track of how many braces are open at a given time and then, when a nested template interpolation begins, record the current brace level. Then, when a closing brace is encountered, if its nesting level is at the top of the stack then we pop off the stack and return to "main" parsing mode. Ragel's existing idea of calling and returning from machines is important here too. As this currently stands this is not actually needed, but once heredocs are in play we will have two possible places to return to at the end of an interpolation sequence, so the state return stack maintained by Ragel will determine whether to return to string mode or heredoc mode.
2017-05-28 22:33:01 +00:00
token(TokenTemplateControl)
braces++
retBraces = append(retBraces, braces)
zclsyntax: heredoc support in the scanner
2017-05-29 15:55:53 +00:00
if len(heredocs) > 0 {
heredocs[len(heredocs)-1].StartOfLine = false
}
zclsyntax: scanner support of string templates This requires some extra state-keeping because we allow templates to be nested inside templates. This takes us outside of the world of regular languages, but we accept that here because it makes things easier to deal with down the line in the parser. The methodology is to keep track of how many braces are open at a given time and then, when a nested template interpolation begins, record the current brace level. Then, when a closing brace is encountered, if its nesting level is at the top of the stack then we pop off the stack and return to "main" parsing mode. Ragel's existing idea of calling and returning from machines is important here too. As this currently stands this is not actually needed, but once heredocs are in play we will have two possible places to return to at the end of an interpolation sequence, so the state return stack maintained by Ragel will determine whether to return to string mode or heredoc mode.
2017-05-28 22:33:01 +00:00
{
stack = append(stack, 0)
stack[top] = cs
top++
zclsyntax: scanning of bare (top-level) templates This alternative scanning mode makes the scanner start in template context rather than normal context. This will be later used by the parser to allow parsing of standalone templates that aren't embedded inside a zcl configuration file.
2017-05-29 16:42:20 +00:00
cs = 947
zclsyntax: scanner support of string templates This requires some extra state-keeping because we allow templates to be nested inside templates. This takes us outside of the world of regular languages, but we accept that here because it makes things easier to deal with down the line in the parser. The methodology is to keep track of how many braces are open at a given time and then, when a nested template interpolation begins, record the current brace level. Then, when a closing brace is encountered, if its nesting level is at the top of the stack then we pop off the stack and return to "main" parsing mode. Ragel's existing idea of calling and returning from machines is important here too. As this currently stands this is not actually needed, but once heredocs are in play we will have two possible places to return to at the end of an interpolation sequence, so the state return stack maintained by Ragel will determine whether to return to string mode or heredoc mode.
2017-05-28 22:33:01 +00:00
goto _again
}
zclsyntax: start of a ragel-based scanner Using Ragel here because the scanner is going to be somewhat complex due to the need to switch back and forth between normal and template states, etc. This should be easier to maintain than a hand-written scanner, while ragel gives us the extra features we need to implement things that would normally be too complex for a "regular" scanner generator.
2017-05-28 02:01:43 +00:00
}
zclsyntax: heredoc support in the scanner
2017-05-29 15:55:53 +00:00
case 6:
zclsyntax: separate tokens for assign = and equality test ==
2017-06-04 23:00:40 +00:00
// line 76 "scan_tokens.rl"
zclsyntax: scan single-character tokens that represent themselves For convenience we use the rune values of these tokens as their token enum values, so we can handle them all via a single rule.
2017-05-28 16:34:20 +00:00
te = p + 1
{
zclsyntax: scanner support of string templates This requires some extra state-keeping because we allow templates to be nested inside templates. This takes us outside of the world of regular languages, but we accept that here because it makes things easier to deal with down the line in the parser. The methodology is to keep track of how many braces are open at a given time and then, when a nested template interpolation begins, record the current brace level. Then, when a closing brace is encountered, if its nesting level is at the top of the stack then we pop off the stack and return to "main" parsing mode. Ragel's existing idea of calling and returning from machines is important here too. As this currently stands this is not actually needed, but once heredocs are in play we will have two possible places to return to at the end of an interpolation sequence, so the state return stack maintained by Ragel will determine whether to return to string mode or heredoc mode.
2017-05-28 22:33:01 +00:00
token(TokenCQuote)
top--
cs = stack[top]
{
stack = stack[:len(stack)-1]
}
goto _again
zclsyntax: scan single-character tokens that represent themselves For convenience we use the rune values of these tokens as their token enum values, so we can handle them all via a single rule.
2017-05-28 16:34:20 +00:00
}
zclsyntax: heredoc support in the scanner
2017-05-29 15:55:53 +00:00
case 7:
zclsyntax: separate tokens for assign = and equality test ==
2017-06-04 23:00:40 +00:00
// line 218 "scan_tokens.rl"
zclsyntax: disallow newlines in string templates Heredocs will deal with the multiline string case once implemented.
2017-05-28 22:35:55 +00:00
te = p + 1
{
token(TokenInvalid)
}
zclsyntax: heredoc support in the scanner
2017-05-29 15:55:53 +00:00
case 8:
zclsyntax: separate tokens for assign = and equality test ==
2017-06-04 23:00:40 +00:00
// line 219 "scan_tokens.rl"
zclsyntax: scan multi-character punctuation tokens
2017-05-28 16:40:58 +00:00
te = p + 1
{
zclsyntax: scanner support of string templates This requires some extra state-keeping because we allow templates to be nested inside templates. This takes us outside of the world of regular languages, but we accept that here because it makes things easier to deal with down the line in the parser. The methodology is to keep track of how many braces are open at a given time and then, when a nested template interpolation begins, record the current brace level. Then, when a closing brace is encountered, if its nesting level is at the top of the stack then we pop off the stack and return to "main" parsing mode. Ragel's existing idea of calling and returning from machines is important here too. As this currently stands this is not actually needed, but once heredocs are in play we will have two possible places to return to at the end of an interpolation sequence, so the state return stack maintained by Ragel will determine whether to return to string mode or heredoc mode.
2017-05-28 22:33:01 +00:00
token(TokenBadUTF8)
zclsyntax: scan multi-character punctuation tokens
2017-05-28 16:40:58 +00:00
}
zclsyntax: heredoc support in the scanner
2017-05-29 15:55:53 +00:00
case 9:
zclsyntax: separate tokens for assign = and equality test ==
2017-06-04 23:00:40 +00:00
// line 134 "scan_tokens.rl"
zclsyntax: scanner support of string templates This requires some extra state-keeping because we allow templates to be nested inside templates. This takes us outside of the world of regular languages, but we accept that here because it makes things easier to deal with down the line in the parser. The methodology is to keep track of how many braces are open at a given time and then, when a nested template interpolation begins, record the current brace level. Then, when a closing brace is encountered, if its nesting level is at the top of the stack then we pop off the stack and return to "main" parsing mode. Ragel's existing idea of calling and returning from machines is important here too. As this currently stands this is not actually needed, but once heredocs are in play we will have two possible places to return to at the end of an interpolation sequence, so the state return stack maintained by Ragel will determine whether to return to string mode or heredoc mode.
2017-05-28 22:33:01 +00:00
te = p
p--
{
token(TokenTemplateInterp)
braces++
retBraces = append(retBraces, braces)
zclsyntax: heredoc support in the scanner
2017-05-29 15:55:53 +00:00
if len(heredocs) > 0 {
heredocs[len(heredocs)-1].StartOfLine = false
}
zclsyntax: scanner support of string templates This requires some extra state-keeping because we allow templates to be nested inside templates. This takes us outside of the world of regular languages, but we accept that here because it makes things easier to deal with down the line in the parser. The methodology is to keep track of how many braces are open at a given time and then, when a nested template interpolation begins, record the current brace level. Then, when a closing brace is encountered, if its nesting level is at the top of the stack then we pop off the stack and return to "main" parsing mode. Ragel's existing idea of calling and returning from machines is important here too. As this currently stands this is not actually needed, but once heredocs are in play we will have two possible places to return to at the end of an interpolation sequence, so the state return stack maintained by Ragel will determine whether to return to string mode or heredoc mode.
2017-05-28 22:33:01 +00:00
{
stack = append(stack, 0)
stack[top] = cs
top++
zclsyntax: scanning of bare (top-level) templates This alternative scanning mode makes the scanner start in template context rather than normal context. This will be later used by the parser to allow parsing of standalone templates that aren't embedded inside a zcl configuration file.
2017-05-29 16:42:20 +00:00
cs = 947
zclsyntax: scanner support of string templates This requires some extra state-keeping because we allow templates to be nested inside templates. This takes us outside of the world of regular languages, but we accept that here because it makes things easier to deal with down the line in the parser. The methodology is to keep track of how many braces are open at a given time and then, when a nested template interpolation begins, record the current brace level. Then, when a closing brace is encountered, if its nesting level is at the top of the stack then we pop off the stack and return to "main" parsing mode. Ragel's existing idea of calling and returning from machines is important here too. As this currently stands this is not actually needed, but once heredocs are in play we will have two possible places to return to at the end of an interpolation sequence, so the state return stack maintained by Ragel will determine whether to return to string mode or heredoc mode.
2017-05-28 22:33:01 +00:00
goto _again
}
}
zclsyntax: heredoc support in the scanner
2017-05-29 15:55:53 +00:00
case 10:
zclsyntax: separate tokens for assign = and equality test ==
2017-06-04 23:00:40 +00:00
// line 144 "scan_tokens.rl"
zclsyntax: scanner support of string templates This requires some extra state-keeping because we allow templates to be nested inside templates. This takes us outside of the world of regular languages, but we accept that here because it makes things easier to deal with down the line in the parser. The methodology is to keep track of how many braces are open at a given time and then, when a nested template interpolation begins, record the current brace level. Then, when a closing brace is encountered, if its nesting level is at the top of the stack then we pop off the stack and return to "main" parsing mode. Ragel's existing idea of calling and returning from machines is important here too. As this currently stands this is not actually needed, but once heredocs are in play we will have two possible places to return to at the end of an interpolation sequence, so the state return stack maintained by Ragel will determine whether to return to string mode or heredoc mode.
2017-05-28 22:33:01 +00:00
te = p
p--
{
token(TokenTemplateControl)
braces++
retBraces = append(retBraces, braces)
zclsyntax: heredoc support in the scanner
2017-05-29 15:55:53 +00:00
if len(heredocs) > 0 {
heredocs[len(heredocs)-1].StartOfLine = false
}
zclsyntax: scanner support of string templates This requires some extra state-keeping because we allow templates to be nested inside templates. This takes us outside of the world of regular languages, but we accept that here because it makes things easier to deal with down the line in the parser. The methodology is to keep track of how many braces are open at a given time and then, when a nested template interpolation begins, record the current brace level. Then, when a closing brace is encountered, if its nesting level is at the top of the stack then we pop off the stack and return to "main" parsing mode. Ragel's existing idea of calling and returning from machines is important here too. As this currently stands this is not actually needed, but once heredocs are in play we will have two possible places to return to at the end of an interpolation sequence, so the state return stack maintained by Ragel will determine whether to return to string mode or heredoc mode.
2017-05-28 22:33:01 +00:00
{
stack = append(stack, 0)
stack[top] = cs
top++
zclsyntax: scanning of bare (top-level) templates This alternative scanning mode makes the scanner start in template context rather than normal context. This will be later used by the parser to allow parsing of standalone templates that aren't embedded inside a zcl configuration file.
2017-05-29 16:42:20 +00:00
cs = 947
zclsyntax: scanner support of string templates This requires some extra state-keeping because we allow templates to be nested inside templates. This takes us outside of the world of regular languages, but we accept that here because it makes things easier to deal with down the line in the parser. The methodology is to keep track of how many braces are open at a given time and then, when a nested template interpolation begins, record the current brace level. Then, when a closing brace is encountered, if its nesting level is at the top of the stack then we pop off the stack and return to "main" parsing mode. Ragel's existing idea of calling and returning from machines is important here too. As this currently stands this is not actually needed, but once heredocs are in play we will have two possible places to return to at the end of an interpolation sequence, so the state return stack maintained by Ragel will determine whether to return to string mode or heredoc mode.
2017-05-28 22:33:01 +00:00
goto _again
}
}
zclsyntax: heredoc support in the scanner
2017-05-29 15:55:53 +00:00
case 11:
zclsyntax: separate tokens for assign = and equality test ==
2017-06-04 23:00:40 +00:00
// line 217 "scan_tokens.rl"
zclsyntax: scanner support of string templates This requires some extra state-keeping because we allow templates to be nested inside templates. This takes us outside of the world of regular languages, but we accept that here because it makes things easier to deal with down the line in the parser. The methodology is to keep track of how many braces are open at a given time and then, when a nested template interpolation begins, record the current brace level. Then, when a closing brace is encountered, if its nesting level is at the top of the stack then we pop off the stack and return to "main" parsing mode. Ragel's existing idea of calling and returning from machines is important here too. As this currently stands this is not actually needed, but once heredocs are in play we will have two possible places to return to at the end of an interpolation sequence, so the state return stack maintained by Ragel will determine whether to return to string mode or heredoc mode.
2017-05-28 22:33:01 +00:00
te = p
p--
{
zclsyntax: differentiate quoted and unquoted string literals The context where a string literal was found affects what sort of escaping it can have, so we need to distinguish these cases so that we will only look for and handle backslash escapes in quoted strings.
2017-05-31 02:03:25 +00:00
token(TokenQuotedLit)
zclsyntax: scanner support of string templates This requires some extra state-keeping because we allow templates to be nested inside templates. This takes us outside of the world of regular languages, but we accept that here because it makes things easier to deal with down the line in the parser. The methodology is to keep track of how many braces are open at a given time and then, when a nested template interpolation begins, record the current brace level. Then, when a closing brace is encountered, if its nesting level is at the top of the stack then we pop off the stack and return to "main" parsing mode. Ragel's existing idea of calling and returning from machines is important here too. As this currently stands this is not actually needed, but once heredocs are in play we will have two possible places to return to at the end of an interpolation sequence, so the state return stack maintained by Ragel will determine whether to return to string mode or heredoc mode.
2017-05-28 22:33:01 +00:00
}
zclsyntax: heredoc support in the scanner
2017-05-29 15:55:53 +00:00
case 12:
zclsyntax: separate tokens for assign = and equality test ==
2017-06-04 23:00:40 +00:00
// line 218 "scan_tokens.rl"
zclsyntax: disallow newlines in string templates Heredocs will deal with the multiline string case once implemented.
2017-05-28 22:35:55 +00:00
te = p
p--
{
token(TokenInvalid)
}
zclsyntax: heredoc support in the scanner
2017-05-29 15:55:53 +00:00
case 13:
zclsyntax: separate tokens for assign = and equality test ==
2017-06-04 23:00:40 +00:00
// line 219 "scan_tokens.rl"
zclsyntax: scanner support of string templates This requires some extra state-keeping because we allow templates to be nested inside templates. This takes us outside of the world of regular languages, but we accept that here because it makes things easier to deal with down the line in the parser. The methodology is to keep track of how many braces are open at a given time and then, when a nested template interpolation begins, record the current brace level. Then, when a closing brace is encountered, if its nesting level is at the top of the stack then we pop off the stack and return to "main" parsing mode. Ragel's existing idea of calling and returning from machines is important here too. As this currently stands this is not actually needed, but once heredocs are in play we will have two possible places to return to at the end of an interpolation sequence, so the state return stack maintained by Ragel will determine whether to return to string mode or heredoc mode.
2017-05-28 22:33:01 +00:00
te = p
p--
{
token(TokenBadUTF8)
}
zclsyntax: heredoc support in the scanner
2017-05-29 15:55:53 +00:00
case 14:
zclsyntax: separate tokens for assign = and equality test ==
2017-06-04 23:00:40 +00:00
// line 217 "scan_tokens.rl"
zclsyntax: scanner support of string templates This requires some extra state-keeping because we allow templates to be nested inside templates. This takes us outside of the world of regular languages, but we accept that here because it makes things easier to deal with down the line in the parser. The methodology is to keep track of how many braces are open at a given time and then, when a nested template interpolation begins, record the current brace level. Then, when a closing brace is encountered, if its nesting level is at the top of the stack then we pop off the stack and return to "main" parsing mode. Ragel's existing idea of calling and returning from machines is important here too. As this currently stands this is not actually needed, but once heredocs are in play we will have two possible places to return to at the end of an interpolation sequence, so the state return stack maintained by Ragel will determine whether to return to string mode or heredoc mode.
2017-05-28 22:33:01 +00:00
p = (te) - 1
{
zclsyntax: differentiate quoted and unquoted string literals The context where a string literal was found affects what sort of escaping it can have, so we need to distinguish these cases so that we will only look for and handle backslash escapes in quoted strings.
2017-05-31 02:03:25 +00:00
token(TokenQuotedLit)
zclsyntax: scanner support of string templates This requires some extra state-keeping because we allow templates to be nested inside templates. This takes us outside of the world of regular languages, but we accept that here because it makes things easier to deal with down the line in the parser. The methodology is to keep track of how many braces are open at a given time and then, when a nested template interpolation begins, record the current brace level. Then, when a closing brace is encountered, if its nesting level is at the top of the stack then we pop off the stack and return to "main" parsing mode. Ragel's existing idea of calling and returning from machines is important here too. As this currently stands this is not actually needed, but once heredocs are in play we will have two possible places to return to at the end of an interpolation sequence, so the state return stack maintained by Ragel will determine whether to return to string mode or heredoc mode.
2017-05-28 22:33:01 +00:00
}
zclsyntax: heredoc support in the scanner
2017-05-29 15:55:53 +00:00
case 15:
zclsyntax: separate tokens for assign = and equality test ==
2017-06-04 23:00:40 +00:00
// line 219 "scan_tokens.rl"
zclsyntax: scanner support of string templates This requires some extra state-keeping because we allow templates to be nested inside templates. This takes us outside of the world of regular languages, but we accept that here because it makes things easier to deal with down the line in the parser. The methodology is to keep track of how many braces are open at a given time and then, when a nested template interpolation begins, record the current brace level. Then, when a closing brace is encountered, if its nesting level is at the top of the stack then we pop off the stack and return to "main" parsing mode. Ragel's existing idea of calling and returning from machines is important here too. As this currently stands this is not actually needed, but once heredocs are in play we will have two possible places to return to at the end of an interpolation sequence, so the state return stack maintained by Ragel will determine whether to return to string mode or heredoc mode.
2017-05-28 22:33:01 +00:00
zclsyntax: disallow newlines in string templates Heredocs will deal with the multiline string case once implemented.
2017-05-28 22:35:55 +00:00
p = (te) - 1
{
token(TokenBadUTF8)
zclsyntax: scanner support of string templates This requires some extra state-keeping because we allow templates to be nested inside templates. This takes us outside of the world of regular languages, but we accept that here because it makes things easier to deal with down the line in the parser. The methodology is to keep track of how many braces are open at a given time and then, when a nested template interpolation begins, record the current brace level. Then, when a closing brace is encountered, if its nesting level is at the top of the stack then we pop off the stack and return to "main" parsing mode. Ragel's existing idea of calling and returning from machines is important here too. As this currently stands this is not actually needed, but once heredocs are in play we will have two possible places to return to at the end of an interpolation sequence, so the state return stack maintained by Ragel will determine whether to return to string mode or heredoc mode.
2017-05-28 22:33:01 +00:00
}
case 16:
zclsyntax: separate tokens for assign = and equality test ==
2017-06-04 23:00:40 +00:00
// line 122 "scan_tokens.rl"
zclsyntax: scanner support of string templates This requires some extra state-keeping because we allow templates to be nested inside templates. This takes us outside of the world of regular languages, but we accept that here because it makes things easier to deal with down the line in the parser. The methodology is to keep track of how many braces are open at a given time and then, when a nested template interpolation begins, record the current brace level. Then, when a closing brace is encountered, if its nesting level is at the top of the stack then we pop off the stack and return to "main" parsing mode. Ragel's existing idea of calling and returning from machines is important here too. As this currently stands this is not actually needed, but once heredocs are in play we will have two possible places to return to at the end of an interpolation sequence, so the state return stack maintained by Ragel will determine whether to return to string mode or heredoc mode.
2017-05-28 22:33:01 +00:00
zclsyntax: heredoc support in the scanner
2017-05-29 15:55:53 +00:00
act = 10
zclsyntax: scanner support of string templates This requires some extra state-keeping because we allow templates to be nested inside templates. This takes us outside of the world of regular languages, but we accept that here because it makes things easier to deal with down the line in the parser. The methodology is to keep track of how many braces are open at a given time and then, when a nested template interpolation begins, record the current brace level. Then, when a closing brace is encountered, if its nesting level is at the top of the stack then we pop off the stack and return to "main" parsing mode. Ragel's existing idea of calling and returning from machines is important here too. As this currently stands this is not actually needed, but once heredocs are in play we will have two possible places to return to at the end of an interpolation sequence, so the state return stack maintained by Ragel will determine whether to return to string mode or heredoc mode.
2017-05-28 22:33:01 +00:00
case 17:
zclsyntax: separate tokens for assign = and equality test ==
2017-06-04 23:00:40 +00:00
// line 227 "scan_tokens.rl"
zclsyntax: heredoc support in the scanner
2017-05-29 15:55:53 +00:00
act = 11
case 18:
zclsyntax: separate tokens for assign = and equality test ==
2017-06-04 23:00:40 +00:00
// line 134 "scan_tokens.rl"
zclsyntax: heredoc support in the scanner
2017-05-29 15:55:53 +00:00
te = p + 1
{
token(TokenTemplateInterp)
braces++
retBraces = append(retBraces, braces)
if len(heredocs) > 0 {
heredocs[len(heredocs)-1].StartOfLine = false
}
{
stack = append(stack, 0)
stack[top] = cs
top++
zclsyntax: scanning of bare (top-level) templates This alternative scanning mode makes the scanner start in template context rather than normal context. This will be later used by the parser to allow parsing of standalone templates that aren't embedded inside a zcl configuration file.
2017-05-29 16:42:20 +00:00
cs = 947
zclsyntax: heredoc support in the scanner
2017-05-29 15:55:53 +00:00
goto _again
}
}
case 19:
zclsyntax: separate tokens for assign = and equality test ==
2017-06-04 23:00:40 +00:00
// line 144 "scan_tokens.rl"
zclsyntax: heredoc support in the scanner
2017-05-29 15:55:53 +00:00
te = p + 1
{
token(TokenTemplateControl)
braces++
retBraces = append(retBraces, braces)
if len(heredocs) > 0 {
heredocs[len(heredocs)-1].StartOfLine = false
}
{
stack = append(stack, 0)
stack[top] = cs
top++
zclsyntax: scanning of bare (top-level) templates This alternative scanning mode makes the scanner start in template context rather than normal context. This will be later used by the parser to allow parsing of standalone templates that aren't embedded inside a zcl configuration file.
2017-05-29 16:42:20 +00:00
cs = 947
zclsyntax: heredoc support in the scanner
2017-05-29 15:55:53 +00:00
goto _again
}
}
case 20:
zclsyntax: separate tokens for assign = and equality test ==
2017-06-04 23:00:40 +00:00
// line 103 "scan_tokens.rl"
zclsyntax: heredoc support in the scanner
2017-05-29 15:55:53 +00:00
te = p + 1
{
// This action is called specificially when a heredoc literal
// ends with a newline character.
// This might actually be our end marker.
topdoc := &heredocs[len(heredocs)-1]
if topdoc.StartOfLine {
maybeMarker := bytes.TrimSpace(data[ts:te])
if bytes.Equal(maybeMarker, topdoc.Marker) {
token(TokenCHeredoc)
heredocs = heredocs[:len(heredocs)-1]
top--
cs = stack[top]
{
stack = stack[:len(stack)-1]
}
goto _again
}
}
topdoc.StartOfLine = true
token(TokenStringLit)
}
case 21:
zclsyntax: separate tokens for assign = and equality test ==
2017-06-04 23:00:40 +00:00
// line 227 "scan_tokens.rl"
zclsyntax: heredoc support in the scanner
2017-05-29 15:55:53 +00:00
te = p + 1
{
token(TokenBadUTF8)
}
case 22:
zclsyntax: separate tokens for assign = and equality test ==
2017-06-04 23:00:40 +00:00
// line 134 "scan_tokens.rl"
zclsyntax: heredoc support in the scanner
2017-05-29 15:55:53 +00:00
te = p
p--
{
token(TokenTemplateInterp)
braces++
retBraces = append(retBraces, braces)
if len(heredocs) > 0 {
heredocs[len(heredocs)-1].StartOfLine = false
}
{
stack = append(stack, 0)
stack[top] = cs
top++
zclsyntax: scanning of bare (top-level) templates This alternative scanning mode makes the scanner start in template context rather than normal context. This will be later used by the parser to allow parsing of standalone templates that aren't embedded inside a zcl configuration file.
2017-05-29 16:42:20 +00:00
cs = 947
zclsyntax: heredoc support in the scanner
2017-05-29 15:55:53 +00:00
goto _again
}
}
case 23:
zclsyntax: separate tokens for assign = and equality test ==
2017-06-04 23:00:40 +00:00
// line 144 "scan_tokens.rl"
zclsyntax: heredoc support in the scanner
2017-05-29 15:55:53 +00:00
te = p
p--
{
token(TokenTemplateControl)
braces++
retBraces = append(retBraces, braces)
if len(heredocs) > 0 {
heredocs[len(heredocs)-1].StartOfLine = false
}
{
stack = append(stack, 0)
stack[top] = cs
top++
zclsyntax: scanning of bare (top-level) templates This alternative scanning mode makes the scanner start in template context rather than normal context. This will be later used by the parser to allow parsing of standalone templates that aren't embedded inside a zcl configuration file.
2017-05-29 16:42:20 +00:00
cs = 947
zclsyntax: heredoc support in the scanner
2017-05-29 15:55:53 +00:00
goto _again
}
}
case 24:
zclsyntax: separate tokens for assign = and equality test ==
2017-06-04 23:00:40 +00:00
// line 122 "scan_tokens.rl"
zclsyntax: heredoc support in the scanner
2017-05-29 15:55:53 +00:00
te = p
p--
{
// This action is called when a heredoc literal _doesn't_ end
// with a newline character, e.g. because we're about to enter
// an interpolation sequence.
heredocs[len(heredocs)-1].StartOfLine = false
token(TokenStringLit)
}
case 25:
zclsyntax: separate tokens for assign = and equality test ==
2017-06-04 23:00:40 +00:00
// line 227 "scan_tokens.rl"
zclsyntax: heredoc support in the scanner
2017-05-29 15:55:53 +00:00
te = p
p--
{
token(TokenBadUTF8)
}
case 26:
zclsyntax: separate tokens for assign = and equality test ==
2017-06-04 23:00:40 +00:00
// line 122 "scan_tokens.rl"
zclsyntax: heredoc support in the scanner
2017-05-29 15:55:53 +00:00
p = (te) - 1
{
// This action is called when a heredoc literal _doesn't_ end
// with a newline character, e.g. because we're about to enter
// an interpolation sequence.
heredocs[len(heredocs)-1].StartOfLine = false
token(TokenStringLit)
}
case 27:
// line 1 "NONE"
switch act {
case 0:
{
cs = 0
goto _again
}
case 10:
{
p = (te) - 1
// This action is called when a heredoc literal _doesn't_ end
// with a newline character, e.g. because we're about to enter
// an interpolation sequence.
heredocs[len(heredocs)-1].StartOfLine = false
token(TokenStringLit)
}
case 11:
{
p = (te) - 1
token(TokenBadUTF8)
}
}
case 28:
zclsyntax: separate tokens for assign = and equality test ==
2017-06-04 23:00:40 +00:00
// line 130 "scan_tokens.rl"
zclsyntax: heredoc support in the scanner
2017-05-29 15:55:53 +00:00
act = 14
case 29:
zclsyntax: separate tokens for assign = and equality test ==
2017-06-04 23:00:40 +00:00
// line 234 "scan_tokens.rl"
zclsyntax: heredoc support in the scanner
2017-05-29 15:55:53 +00:00
zclsyntax: scanning of comments
2017-05-29 16:13:35 +00:00
act = 15
zclsyntax: heredoc support in the scanner
2017-05-29 15:55:53 +00:00
case 30:
zclsyntax: separate tokens for assign = and equality test ==
2017-06-04 23:00:40 +00:00
// line 134 "scan_tokens.rl"
zclsyntax: scanning of comments
2017-05-29 16:13:35 +00:00
zclsyntax: scanning of bare (top-level) templates This alternative scanning mode makes the scanner start in template context rather than normal context. This will be later used by the parser to allow parsing of standalone templates that aren't embedded inside a zcl configuration file.
2017-05-29 16:42:20 +00:00
te = p + 1
{
token(TokenTemplateInterp)
braces++
retBraces = append(retBraces, braces)
if len(heredocs) > 0 {
heredocs[len(heredocs)-1].StartOfLine = false
}
{
stack = append(stack, 0)
stack[top] = cs
top++
cs = 947
goto _again
}
}
zclsyntax: scanning of comments
2017-05-29 16:13:35 +00:00
case 31:
zclsyntax: separate tokens for assign = and equality test ==
2017-06-04 23:00:40 +00:00
// line 144 "scan_tokens.rl"
zclsyntax: scanning of comments
2017-05-29 16:13:35 +00:00
zclsyntax: scanning of bare (top-level) templates This alternative scanning mode makes the scanner start in template context rather than normal context. This will be later used by the parser to allow parsing of standalone templates that aren't embedded inside a zcl configuration file.
2017-05-29 16:42:20 +00:00
te = p + 1
{
token(TokenTemplateControl)
braces++
retBraces = append(retBraces, braces)
if len(heredocs) > 0 {
heredocs[len(heredocs)-1].StartOfLine = false
}
{
stack = append(stack, 0)
stack[top] = cs
top++
cs = 947
goto _again
}
}
zclsyntax: detect newlines during scanning This is important because our syntax for objects uses newlines as the separator between items, so this is the only signal we'll get that a given item has ended and another is beginning.
2017-05-29 16:25:21 +00:00
case 32:
zclsyntax: separate tokens for assign = and equality test ==
2017-06-04 23:00:40 +00:00
// line 130 "scan_tokens.rl"
zclsyntax: detect newlines during scanning This is important because our syntax for objects uses newlines as the separator between items, so this is the only signal we'll get that a given item has ended and another is beginning.
2017-05-29 16:25:21 +00:00
zclsyntax: scanning of bare (top-level) templates This alternative scanning mode makes the scanner start in template context rather than normal context. This will be later used by the parser to allow parsing of standalone templates that aren't embedded inside a zcl configuration file.
2017-05-29 16:42:20 +00:00
te = p + 1
{
token(TokenStringLit)
}
zclsyntax: scanning of comments
2017-05-29 16:13:35 +00:00
case 33:
zclsyntax: separate tokens for assign = and equality test ==
2017-06-04 23:00:40 +00:00
// line 234 "scan_tokens.rl"
zclsyntax: scanner support of string templates This requires some extra state-keeping because we allow templates to be nested inside templates. This takes us outside of the world of regular languages, but we accept that here because it makes things easier to deal with down the line in the parser. The methodology is to keep track of how many braces are open at a given time and then, when a nested template interpolation begins, record the current brace level. Then, when a closing brace is encountered, if its nesting level is at the top of the stack then we pop off the stack and return to "main" parsing mode. Ragel's existing idea of calling and returning from machines is important here too. As this currently stands this is not actually needed, but once heredocs are in play we will have two possible places to return to at the end of an interpolation sequence, so the state return stack maintained by Ragel will determine whether to return to string mode or heredoc mode.
2017-05-28 22:33:01 +00:00
te = p + 1
{
zclsyntax: scanning of bare (top-level) templates This alternative scanning mode makes the scanner start in template context rather than normal context. This will be later used by the parser to allow parsing of standalone templates that aren't embedded inside a zcl configuration file.
2017-05-29 16:42:20 +00:00
token(TokenBadUTF8)
zclsyntax: scanner support of string templates This requires some extra state-keeping because we allow templates to be nested inside templates. This takes us outside of the world of regular languages, but we accept that here because it makes things easier to deal with down the line in the parser. The methodology is to keep track of how many braces are open at a given time and then, when a nested template interpolation begins, record the current brace level. Then, when a closing brace is encountered, if its nesting level is at the top of the stack then we pop off the stack and return to "main" parsing mode. Ragel's existing idea of calling and returning from machines is important here too. As this currently stands this is not actually needed, but once heredocs are in play we will have two possible places to return to at the end of an interpolation sequence, so the state return stack maintained by Ragel will determine whether to return to string mode or heredoc mode.
2017-05-28 22:33:01 +00:00
}
zclsyntax: scanning of comments
2017-05-29 16:13:35 +00:00
case 34:
zclsyntax: separate tokens for assign = and equality test ==
2017-06-04 23:00:40 +00:00
// line 134 "scan_tokens.rl"
zclsyntax: scanning of bare (top-level) templates This alternative scanning mode makes the scanner start in template context rather than normal context. This will be later used by the parser to allow parsing of standalone templates that aren't embedded inside a zcl configuration file.
2017-05-29 16:42:20 +00:00
te = p
p--
{
token(TokenTemplateInterp)
braces++
retBraces = append(retBraces, braces)
if len(heredocs) > 0 {
heredocs[len(heredocs)-1].StartOfLine = false
}
{
stack = append(stack, 0)
stack[top] = cs
top++
cs = 947
goto _again
}
}
case 35:
zclsyntax: separate tokens for assign = and equality test ==
2017-06-04 23:00:40 +00:00
// line 144 "scan_tokens.rl"
zclsyntax: scanning of bare (top-level) templates This alternative scanning mode makes the scanner start in template context rather than normal context. This will be later used by the parser to allow parsing of standalone templates that aren't embedded inside a zcl configuration file.
2017-05-29 16:42:20 +00:00
te = p
p--
{
token(TokenTemplateControl)
braces++
retBraces = append(retBraces, braces)
if len(heredocs) > 0 {
heredocs[len(heredocs)-1].StartOfLine = false
}
{
stack = append(stack, 0)
stack[top] = cs
top++
cs = 947
goto _again
}
}
case 36:
zclsyntax: separate tokens for assign = and equality test ==
2017-06-04 23:00:40 +00:00
// line 130 "scan_tokens.rl"
zclsyntax: scanning of bare (top-level) templates This alternative scanning mode makes the scanner start in template context rather than normal context. This will be later used by the parser to allow parsing of standalone templates that aren't embedded inside a zcl configuration file.
2017-05-29 16:42:20 +00:00
te = p
p--
{
token(TokenStringLit)
}
case 37:
zclsyntax: separate tokens for assign = and equality test ==
2017-06-04 23:00:40 +00:00
// line 234 "scan_tokens.rl"
zclsyntax: scanning of bare (top-level) templates This alternative scanning mode makes the scanner start in template context rather than normal context. This will be later used by the parser to allow parsing of standalone templates that aren't embedded inside a zcl configuration file.
2017-05-29 16:42:20 +00:00
te = p
p--
{
token(TokenBadUTF8)
}
case 38:
zclsyntax: separate tokens for assign = and equality test ==
2017-06-04 23:00:40 +00:00
// line 130 "scan_tokens.rl"
zclsyntax: scanning of bare (top-level) templates This alternative scanning mode makes the scanner start in template context rather than normal context. This will be later used by the parser to allow parsing of standalone templates that aren't embedded inside a zcl configuration file.
2017-05-29 16:42:20 +00:00
p = (te) - 1
{
token(TokenStringLit)
}
case 39:
// line 1 "NONE"
switch act {
case 0:
{
cs = 0
goto _again
}
case 14:
{
p = (te) - 1
token(TokenStringLit)
}
case 15:
{
p = (te) - 1
token(TokenBadUTF8)
}
}
case 40:
zclsyntax: separate tokens for assign = and equality test ==
2017-06-04 23:00:40 +00:00
// line 240 "scan_tokens.rl"
zclsyntax: scanning of bare (top-level) templates This alternative scanning mode makes the scanner start in template context rather than normal context. This will be later used by the parser to allow parsing of standalone templates that aren't embedded inside a zcl configuration file.
2017-05-29 16:42:20 +00:00
act = 18
case 41:
zclsyntax: separate tokens for assign = and equality test ==
2017-06-04 23:00:40 +00:00
// line 242 "scan_tokens.rl"
zclsyntax: scanning of bare (top-level) templates This alternative scanning mode makes the scanner start in template context rather than normal context. This will be later used by the parser to allow parsing of standalone templates that aren't embedded inside a zcl configuration file.
2017-05-29 16:42:20 +00:00
act = 19
case 42:
zclsyntax: separate tokens for assign = and equality test ==
2017-06-04 23:00:40 +00:00
// line 251 "scan_tokens.rl"
zclsyntax: scanning of bare (top-level) templates This alternative scanning mode makes the scanner start in template context rather than normal context. This will be later used by the parser to allow parsing of standalone templates that aren't embedded inside a zcl configuration file.
2017-05-29 16:42:20 +00:00
zclsyntax: separate tokens for assign = and equality test ==
2017-06-04 23:00:40 +00:00
act = 27
zclsyntax: scanning of bare (top-level) templates This alternative scanning mode makes the scanner start in template context rather than normal context. This will be later used by the parser to allow parsing of standalone templates that aren't embedded inside a zcl configuration file.
2017-05-29 16:42:20 +00:00
case 43:
zclsyntax: separate tokens for assign = and equality test ==
2017-06-04 23:00:40 +00:00
// line 262 "scan_tokens.rl"
zclsyntax: scanning of bare (top-level) templates This alternative scanning mode makes the scanner start in template context rather than normal context. This will be later used by the parser to allow parsing of standalone templates that aren't embedded inside a zcl configuration file.
2017-05-29 16:42:20 +00:00
zclsyntax: separate tokens for assign = and equality test ==
2017-06-04 23:00:40 +00:00
act = 34
zclsyntax: scanning of bare (top-level) templates This alternative scanning mode makes the scanner start in template context rather than normal context. This will be later used by the parser to allow parsing of standalone templates that aren't embedded inside a zcl configuration file.
2017-05-29 16:42:20 +00:00
case 44:
zclsyntax: separate tokens for assign = and equality test ==
2017-06-04 23:00:40 +00:00
// line 263 "scan_tokens.rl"
zclsyntax: scanning of bare (top-level) templates This alternative scanning mode makes the scanner start in template context rather than normal context. This will be later used by the parser to allow parsing of standalone templates that aren't embedded inside a zcl configuration file.
2017-05-29 16:42:20 +00:00
zclsyntax: separate tokens for assign = and equality test ==
2017-06-04 23:00:40 +00:00
act = 35
zclsyntax: scanning of bare (top-level) templates This alternative scanning mode makes the scanner start in template context rather than normal context. This will be later used by the parser to allow parsing of standalone templates that aren't embedded inside a zcl configuration file.
2017-05-29 16:42:20 +00:00
case 45:
zclwrite: absorb lead comments into attributes The native parser's ranges don't include any surrounding comments, so we need to do a little more work to pick them out of the surrounding token sequences. This just takes care of _lead_ comments, which are those that appear as whole line comments above the item in question. Line comments, which appear after the item on the same line, will follow in a later commit.
2017-06-08 16:04:27 +00:00
// line 242 "scan_tokens.rl"
te = p + 1
{
token(TokenComment)
}
case 46:
zclsyntax: separate tokens for assign = and equality test ==
2017-06-04 23:00:40 +00:00
// line 243 "scan_tokens.rl"
zclsyntax: scanning of bare (top-level) templates This alternative scanning mode makes the scanner start in template context rather than normal context. This will be later used by the parser to allow parsing of standalone templates that aren't embedded inside a zcl configuration file.
2017-05-29 16:42:20 +00:00
te = p + 1
{
token(TokenNewline)
}
zclwrite: absorb lead comments into attributes The native parser's ranges don't include any surrounding comments, so we need to do a little more work to pick them out of the surrounding token sequences. This just takes care of _lead_ comments, which are those that appear as whole line comments above the item in question. Line comments, which appear after the item on the same line, will follow in a later commit.
2017-06-08 16:04:27 +00:00
case 47:
zclsyntax: separate tokens for assign = and equality test ==
2017-06-04 23:00:40 +00:00
// line 245 "scan_tokens.rl"
zclsyntax: scanner support of string templates This requires some extra state-keeping because we allow templates to be nested inside templates. This takes us outside of the world of regular languages, but we accept that here because it makes things easier to deal with down the line in the parser. The methodology is to keep track of how many braces are open at a given time and then, when a nested template interpolation begins, record the current brace level. Then, when a closing brace is encountered, if its nesting level is at the top of the stack then we pop off the stack and return to "main" parsing mode. Ragel's existing idea of calling and returning from machines is important here too. As this currently stands this is not actually needed, but once heredocs are in play we will have two possible places to return to at the end of an interpolation sequence, so the state return stack maintained by Ragel will determine whether to return to string mode or heredoc mode.
2017-05-28 22:33:01 +00:00
te = p + 1
{
zclsyntax: separate tokens for assign = and equality test ==
2017-06-04 23:00:40 +00:00
token(TokenEqualOp)
zclsyntax: scanner support of string templates This requires some extra state-keeping because we allow templates to be nested inside templates. This takes us outside of the world of regular languages, but we accept that here because it makes things easier to deal with down the line in the parser. The methodology is to keep track of how many braces are open at a given time and then, when a nested template interpolation begins, record the current brace level. Then, when a closing brace is encountered, if its nesting level is at the top of the stack then we pop off the stack and return to "main" parsing mode. Ragel's existing idea of calling and returning from machines is important here too. As this currently stands this is not actually needed, but once heredocs are in play we will have two possible places to return to at the end of an interpolation sequence, so the state return stack maintained by Ragel will determine whether to return to string mode or heredoc mode.
2017-05-28 22:33:01 +00:00
}
zclwrite: absorb lead comments into attributes The native parser's ranges don't include any surrounding comments, so we need to do a little more work to pick them out of the surrounding token sequences. This just takes care of _lead_ comments, which are those that appear as whole line comments above the item in question. Line comments, which appear after the item on the same line, will follow in a later commit.
2017-06-08 16:04:27 +00:00
case 48:
zclsyntax: separate tokens for assign = and equality test ==
2017-06-04 23:00:40 +00:00
// line 246 "scan_tokens.rl"
zclsyntax: scanner support of string templates This requires some extra state-keeping because we allow templates to be nested inside templates. This takes us outside of the world of regular languages, but we accept that here because it makes things easier to deal with down the line in the parser. The methodology is to keep track of how many braces are open at a given time and then, when a nested template interpolation begins, record the current brace level. Then, when a closing brace is encountered, if its nesting level is at the top of the stack then we pop off the stack and return to "main" parsing mode. Ragel's existing idea of calling and returning from machines is important here too. As this currently stands this is not actually needed, but once heredocs are in play we will have two possible places to return to at the end of an interpolation sequence, so the state return stack maintained by Ragel will determine whether to return to string mode or heredoc mode.
2017-05-28 22:33:01 +00:00
te = p + 1
{
zclsyntax: separate tokens for assign = and equality test ==
2017-06-04 23:00:40 +00:00
token(TokenNotEqual)
zclsyntax: scanner support of string templates This requires some extra state-keeping because we allow templates to be nested inside templates. This takes us outside of the world of regular languages, but we accept that here because it makes things easier to deal with down the line in the parser. The methodology is to keep track of how many braces are open at a given time and then, when a nested template interpolation begins, record the current brace level. Then, when a closing brace is encountered, if its nesting level is at the top of the stack then we pop off the stack and return to "main" parsing mode. Ragel's existing idea of calling and returning from machines is important here too. As this currently stands this is not actually needed, but once heredocs are in play we will have two possible places to return to at the end of an interpolation sequence, so the state return stack maintained by Ragel will determine whether to return to string mode or heredoc mode.
2017-05-28 22:33:01 +00:00
}
zclwrite: absorb lead comments into attributes The native parser's ranges don't include any surrounding comments, so we need to do a little more work to pick them out of the surrounding token sequences. This just takes care of _lead_ comments, which are those that appear as whole line comments above the item in question. Line comments, which appear after the item on the same line, will follow in a later commit.
2017-06-08 16:04:27 +00:00
case 49:
zclsyntax: separate tokens for assign = and equality test ==
2017-06-04 23:00:40 +00:00
// line 247 "scan_tokens.rl"
zclsyntax: scanner support of string templates This requires some extra state-keeping because we allow templates to be nested inside templates. This takes us outside of the world of regular languages, but we accept that here because it makes things easier to deal with down the line in the parser. The methodology is to keep track of how many braces are open at a given time and then, when a nested template interpolation begins, record the current brace level. Then, when a closing brace is encountered, if its nesting level is at the top of the stack then we pop off the stack and return to "main" parsing mode. Ragel's existing idea of calling and returning from machines is important here too. As this currently stands this is not actually needed, but once heredocs are in play we will have two possible places to return to at the end of an interpolation sequence, so the state return stack maintained by Ragel will determine whether to return to string mode or heredoc mode.
2017-05-28 22:33:01 +00:00
te = p + 1
{
zclsyntax: separate tokens for assign = and equality test ==
2017-06-04 23:00:40 +00:00
token(TokenGreaterThanEq)
zclsyntax: scanner support of string templates This requires some extra state-keeping because we allow templates to be nested inside templates. This takes us outside of the world of regular languages, but we accept that here because it makes things easier to deal with down the line in the parser. The methodology is to keep track of how many braces are open at a given time and then, when a nested template interpolation begins, record the current brace level. Then, when a closing brace is encountered, if its nesting level is at the top of the stack then we pop off the stack and return to "main" parsing mode. Ragel's existing idea of calling and returning from machines is important here too. As this currently stands this is not actually needed, but once heredocs are in play we will have two possible places to return to at the end of an interpolation sequence, so the state return stack maintained by Ragel will determine whether to return to string mode or heredoc mode.
2017-05-28 22:33:01 +00:00
}
zclwrite: absorb lead comments into attributes The native parser's ranges don't include any surrounding comments, so we need to do a little more work to pick them out of the surrounding token sequences. This just takes care of _lead_ comments, which are those that appear as whole line comments above the item in question. Line comments, which appear after the item on the same line, will follow in a later commit.
2017-06-08 16:04:27 +00:00
case 50:
zclsyntax: separate tokens for assign = and equality test ==
2017-06-04 23:00:40 +00:00
// line 248 "scan_tokens.rl"
zclsyntax: scan multi-character punctuation tokens
2017-05-28 16:40:58 +00:00
te = p + 1
{
zclsyntax: separate tokens for assign = and equality test ==
2017-06-04 23:00:40 +00:00
token(TokenLessThanEq)
zclsyntax: scan multi-character punctuation tokens
2017-05-28 16:40:58 +00:00
}
zclwrite: absorb lead comments into attributes The native parser's ranges don't include any surrounding comments, so we need to do a little more work to pick them out of the surrounding token sequences. This just takes care of _lead_ comments, which are those that appear as whole line comments above the item in question. Line comments, which appear after the item on the same line, will follow in a later commit.
2017-06-08 16:04:27 +00:00
case 51:
zclsyntax: separate tokens for assign = and equality test ==
2017-06-04 23:00:40 +00:00
// line 249 "scan_tokens.rl"
zclsyntax: scan multi-character punctuation tokens
2017-05-28 16:40:58 +00:00
te = p + 1
{
zclsyntax: separate tokens for assign = and equality test ==
2017-06-04 23:00:40 +00:00
token(TokenAnd)
zclsyntax: scan multi-character punctuation tokens
2017-05-28 16:40:58 +00:00
}
zclwrite: absorb lead comments into attributes The native parser's ranges don't include any surrounding comments, so we need to do a little more work to pick them out of the surrounding token sequences. This just takes care of _lead_ comments, which are those that appear as whole line comments above the item in question. Line comments, which appear after the item on the same line, will follow in a later commit.
2017-06-08 16:04:27 +00:00
case 52:
zclsyntax: separate tokens for assign = and equality test ==
2017-06-04 23:00:40 +00:00
// line 250 "scan_tokens.rl"
zclsyntax: detect newlines during scanning This is important because our syntax for objects uses newlines as the separator between items, so this is the only signal we'll get that a given item has ended and another is beginning.
2017-05-29 16:25:21 +00:00
te = p + 1
{
zclsyntax: separate tokens for assign = and equality test ==
2017-06-04 23:00:40 +00:00
token(TokenOr)
zclsyntax: detect newlines during scanning This is important because our syntax for objects uses newlines as the separator between items, so this is the only signal we'll get that a given item has ended and another is beginning.
2017-05-29 16:25:21 +00:00
}
zclwrite: absorb lead comments into attributes The native parser's ranges don't include any surrounding comments, so we need to do a little more work to pick them out of the surrounding token sequences. This just takes care of _lead_ comments, which are those that appear as whole line comments above the item in question. Line comments, which appear after the item on the same line, will follow in a later commit.
2017-06-08 16:04:27 +00:00
case 53:
zclsyntax: separate tokens for assign = and equality test ==
2017-06-04 23:00:40 +00:00
// line 251 "scan_tokens.rl"
te = p + 1
{
selfToken()
}
zclwrite: absorb lead comments into attributes The native parser's ranges don't include any surrounding comments, so we need to do a little more work to pick them out of the surrounding token sequences. This just takes care of _lead_ comments, which are those that appear as whole line comments above the item in question. Line comments, which appear after the item on the same line, will follow in a later commit.
2017-06-08 16:04:27 +00:00
case 54:
zclsyntax: separate tokens for assign = and equality test ==
2017-06-04 23:00:40 +00:00
// line 154 "scan_tokens.rl"
zclsyntax: scanner support of string templates This requires some extra state-keeping because we allow templates to be nested inside templates. This takes us outside of the world of regular languages, but we accept that here because it makes things easier to deal with down the line in the parser. The methodology is to keep track of how many braces are open at a given time and then, when a nested template interpolation begins, record the current brace level. Then, when a closing brace is encountered, if its nesting level is at the top of the stack then we pop off the stack and return to "main" parsing mode. Ragel's existing idea of calling and returning from machines is important here too. As this currently stands this is not actually needed, but once heredocs are in play we will have two possible places to return to at the end of an interpolation sequence, so the state return stack maintained by Ragel will determine whether to return to string mode or heredoc mode.
2017-05-28 22:33:01 +00:00
te = p + 1
{
token(TokenOBrace)
braces++
}
zclwrite: absorb lead comments into attributes The native parser's ranges don't include any surrounding comments, so we need to do a little more work to pick them out of the surrounding token sequences. This just takes care of _lead_ comments, which are those that appear as whole line comments above the item in question. Line comments, which appear after the item on the same line, will follow in a later commit.
2017-06-08 16:04:27 +00:00
case 55:
zclsyntax: separate tokens for assign = and equality test ==
2017-06-04 23:00:40 +00:00
// line 159 "scan_tokens.rl"
zclsyntax: scanner support of string templates This requires some extra state-keeping because we allow templates to be nested inside templates. This takes us outside of the world of regular languages, but we accept that here because it makes things easier to deal with down the line in the parser. The methodology is to keep track of how many braces are open at a given time and then, when a nested template interpolation begins, record the current brace level. Then, when a closing brace is encountered, if its nesting level is at the top of the stack then we pop off the stack and return to "main" parsing mode. Ragel's existing idea of calling and returning from machines is important here too. As this currently stands this is not actually needed, but once heredocs are in play we will have two possible places to return to at the end of an interpolation sequence, so the state return stack maintained by Ragel will determine whether to return to string mode or heredoc mode.
2017-05-28 22:33:01 +00:00
te = p + 1
{
if len(retBraces) > 0 && retBraces[len(retBraces)-1] == braces {
token(TokenTemplateSeqEnd)
braces--
retBraces = retBraces[0 : len(retBraces)-1]
top--
cs = stack[top]
{
stack = stack[:len(stack)-1]
}
goto _again
} else {
token(TokenCBrace)
braces--
}
}
zclwrite: absorb lead comments into attributes The native parser's ranges don't include any surrounding comments, so we need to do a little more work to pick them out of the surrounding token sequences. This just takes care of _lead_ comments, which are those that appear as whole line comments above the item in question. Line comments, which appear after the item on the same line, will follow in a later commit.
2017-06-08 16:04:27 +00:00
case 56:
zclsyntax: separate tokens for assign = and equality test ==
2017-06-04 23:00:40 +00:00
// line 171 "scan_tokens.rl"
zclsyntax: scanner support of string templates This requires some extra state-keeping because we allow templates to be nested inside templates. This takes us outside of the world of regular languages, but we accept that here because it makes things easier to deal with down the line in the parser. The methodology is to keep track of how many braces are open at a given time and then, when a nested template interpolation begins, record the current brace level. Then, when a closing brace is encountered, if its nesting level is at the top of the stack then we pop off the stack and return to "main" parsing mode. Ragel's existing idea of calling and returning from machines is important here too. As this currently stands this is not actually needed, but once heredocs are in play we will have two possible places to return to at the end of an interpolation sequence, so the state return stack maintained by Ragel will determine whether to return to string mode or heredoc mode.
2017-05-28 22:33:01 +00:00
te = p + 1
{
// Only consume from the retBraces stack and return if we are at
// a suitable brace nesting level, otherwise things will get
// confused. (Not entering this branch indicates a syntax error,
// which we will catch in the parser.)
if len(retBraces) > 0 && retBraces[len(retBraces)-1] == braces {
zclsyntax: scan correctly closing ~} markers Previously we were failing to return back to template-scanning mode due to decrementing "braces" too early, causing the remainder of the template to be scanned as if it were an expression.
2017-06-01 15:36:48 +00:00
token(TokenTemplateSeqEnd)
braces--
zclsyntax: scanner support of string templates This requires some extra state-keeping because we allow templates to be nested inside templates. This takes us outside of the world of regular languages, but we accept that here because it makes things easier to deal with down the line in the parser. The methodology is to keep track of how many braces are open at a given time and then, when a nested template interpolation begins, record the current brace level. Then, when a closing brace is encountered, if its nesting level is at the top of the stack then we pop off the stack and return to "main" parsing mode. Ragel's existing idea of calling and returning from machines is important here too. As this currently stands this is not actually needed, but once heredocs are in play we will have two possible places to return to at the end of an interpolation sequence, so the state return stack maintained by Ragel will determine whether to return to string mode or heredoc mode.
2017-05-28 22:33:01 +00:00
retBraces = retBraces[0 : len(retBraces)-1]
top--
cs = stack[top]
{
stack = stack[:len(stack)-1]
}
goto _again
zclsyntax: scan correctly closing ~} markers Previously we were failing to return back to template-scanning mode due to decrementing "braces" too early, causing the remainder of the template to be scanned as if it were an expression.
2017-06-01 15:36:48 +00:00
} else {
// We intentionally generate a TokenTemplateSeqEnd here,
// even though the user apparently wanted a brace, because
// we want to allow the parser to catch the incorrect use
// of a ~} to balance a generic opening brace, rather than
// a template sequence.
token(TokenTemplateSeqEnd)
braces--
zclsyntax: scanner support of string templates This requires some extra state-keeping because we allow templates to be nested inside templates. This takes us outside of the world of regular languages, but we accept that here because it makes things easier to deal with down the line in the parser. The methodology is to keep track of how many braces are open at a given time and then, when a nested template interpolation begins, record the current brace level. Then, when a closing brace is encountered, if its nesting level is at the top of the stack then we pop off the stack and return to "main" parsing mode. Ragel's existing idea of calling and returning from machines is important here too. As this currently stands this is not actually needed, but once heredocs are in play we will have two possible places to return to at the end of an interpolation sequence, so the state return stack maintained by Ragel will determine whether to return to string mode or heredoc mode.
2017-05-28 22:33:01 +00:00
}
}
zclwrite: absorb lead comments into attributes The native parser's ranges don't include any surrounding comments, so we need to do a little more work to pick them out of the surrounding token sequences. This just takes care of _lead_ comments, which are those that appear as whole line comments above the item in question. Line comments, which appear after the item on the same line, will follow in a later commit.
2017-06-08 16:04:27 +00:00
case 57:
zclsyntax: separate tokens for assign = and equality test ==
2017-06-04 23:00:40 +00:00
// line 71 "scan_tokens.rl"
zclsyntax: scanner support of string templates This requires some extra state-keeping because we allow templates to be nested inside templates. This takes us outside of the world of regular languages, but we accept that here because it makes things easier to deal with down the line in the parser. The methodology is to keep track of how many braces are open at a given time and then, when a nested template interpolation begins, record the current brace level. Then, when a closing brace is encountered, if its nesting level is at the top of the stack then we pop off the stack and return to "main" parsing mode. Ragel's existing idea of calling and returning from machines is important here too. As this currently stands this is not actually needed, but once heredocs are in play we will have two possible places to return to at the end of an interpolation sequence, so the state return stack maintained by Ragel will determine whether to return to string mode or heredoc mode.
2017-05-28 22:33:01 +00:00
te = p + 1
{
token(TokenOQuote)
{
stack = append(stack, 0)
stack[top] = cs
top++
zclsyntax: separate tokens for assign = and equality test ==
2017-06-04 23:00:40 +00:00
cs = 998
zclsyntax: scanner support of string templates This requires some extra state-keeping because we allow templates to be nested inside templates. This takes us outside of the world of regular languages, but we accept that here because it makes things easier to deal with down the line in the parser. The methodology is to keep track of how many braces are open at a given time and then, when a nested template interpolation begins, record the current brace level. Then, when a closing brace is encountered, if its nesting level is at the top of the stack then we pop off the stack and return to "main" parsing mode. Ragel's existing idea of calling and returning from machines is important here too. As this currently stands this is not actually needed, but once heredocs are in play we will have two possible places to return to at the end of an interpolation sequence, so the state return stack maintained by Ragel will determine whether to return to string mode or heredoc mode.
2017-05-28 22:33:01 +00:00
goto _again
}
}
zclwrite: absorb lead comments into attributes The native parser's ranges don't include any surrounding comments, so we need to do a little more work to pick them out of the surrounding token sequences. This just takes care of _lead_ comments, which are those that appear as whole line comments above the item in question. Line comments, which appear after the item on the same line, will follow in a later commit.
2017-06-08 16:04:27 +00:00
case 58:
zclsyntax: separate tokens for assign = and equality test ==
2017-06-04 23:00:40 +00:00
// line 81 "scan_tokens.rl"
zclsyntax: heredoc support in the scanner
2017-05-29 15:55:53 +00:00
te = p + 1
{
token(TokenOHeredoc)
// the token is currently the whole heredoc introducer, like
// <<EOT or <<-EOT, followed by a newline. We want to extract
// just the "EOT" portion that we'll use as the closing marker.
marker := data[ts+2 : te-1]
if marker[0] == '-' {
marker = marker[1:]
}
if marker[len(marker)-1] == '\r' {
marker = marker[:len(marker)-1]
}
heredocs = append(heredocs, heredocInProgress{
Marker: marker,
StartOfLine: true,
})
{
stack = append(stack, 0)
stack[top] = cs
top++
zclsyntax: separate tokens for assign = and equality test ==
2017-06-04 23:00:40 +00:00
cs = 1012
zclsyntax: heredoc support in the scanner
2017-05-29 15:55:53 +00:00
goto _again
}
}
zclwrite: absorb lead comments into attributes The native parser's ranges don't include any surrounding comments, so we need to do a little more work to pick them out of the surrounding token sequences. This just takes care of _lead_ comments, which are those that appear as whole line comments above the item in question. Line comments, which appear after the item on the same line, will follow in a later commit.
2017-06-08 16:04:27 +00:00
case 59:
zclsyntax: separate tokens for assign = and equality test ==
2017-06-04 23:00:40 +00:00
// line 262 "scan_tokens.rl"
zclsyntax: scan multi-character punctuation tokens
2017-05-28 16:40:58 +00:00
te = p + 1
{
zclsyntax: generate lexer diagnostics There are certain tokens that are _never_ valid, so we might as well catch them early in the Lex... functions rather than having to handle them in many different contexts within the parser. Unfortunately for now when such errors occur they tend to be echoed by more confusing errors coming from the parser, but we'll accept that for now.
2017-06-04 14:34:26 +00:00
token(TokenBadUTF8)
zclsyntax: scan multi-character punctuation tokens
2017-05-28 16:40:58 +00:00
}
zclwrite: absorb lead comments into attributes The native parser's ranges don't include any surrounding comments, so we need to do a little more work to pick them out of the surrounding token sequences. This just takes care of _lead_ comments, which are those that appear as whole line comments above the item in question. Line comments, which appear after the item on the same line, will follow in a later commit.
2017-06-08 16:04:27 +00:00
case 60:
zclsyntax: separate tokens for assign = and equality test ==
2017-06-04 23:00:40 +00:00
// line 263 "scan_tokens.rl"
zclsyntax: scan multi-character punctuation tokens
2017-05-28 16:40:58 +00:00
te = p + 1
{
zclsyntax: generate lexer diagnostics There are certain tokens that are _never_ valid, so we might as well catch them early in the Lex... functions rather than having to handle them in many different contexts within the parser. Unfortunately for now when such errors occur they tend to be echoed by more confusing errors coming from the parser, but we'll accept that for now.
2017-06-04 14:34:26 +00:00
token(TokenInvalid)
zclsyntax: scan multi-character punctuation tokens
2017-05-28 16:40:58 +00:00
}
zclwrite: absorb lead comments into attributes The native parser's ranges don't include any surrounding comments, so we need to do a little more work to pick them out of the surrounding token sequences. This just takes care of _lead_ comments, which are those that appear as whole line comments above the item in question. Line comments, which appear after the item on the same line, will follow in a later commit.
2017-06-08 16:04:27 +00:00
case 61:
zclsyntax: separate tokens for assign = and equality test ==
2017-06-04 23:00:40 +00:00
// line 238 "scan_tokens.rl"
zclsyntax: re-organize and simplify the scanner
2017-05-28 15:38:13 +00:00
te = p
p--
zclwrite: absorb lead comments into attributes The native parser's ranges don't include any surrounding comments, so we need to do a little more work to pick them out of the surrounding token sequences. This just takes care of _lead_ comments, which are those that appear as whole line comments above the item in question. Line comments, which appear after the item on the same line, will follow in a later commit.
2017-06-08 16:04:27 +00:00
case 62:
zclsyntax: separate tokens for assign = and equality test ==
2017-06-04 23:00:40 +00:00
// line 239 "scan_tokens.rl"
zclsyntax: start of a ragel-based scanner Using Ragel here because the scanner is going to be somewhat complex due to the need to switch back and forth between normal and template states, etc. This should be easier to maintain than a hand-written scanner, while ragel gives us the extra features we need to implement things that would normally be too complex for a "regular" scanner generator.
2017-05-28 02:01:43 +00:00
te = p
p--
{
zclsyntax: scanning of numeric literals
2017-05-28 15:56:43 +00:00
token(TokenNumberLit)
zclsyntax: start of a ragel-based scanner Using Ragel here because the scanner is going to be somewhat complex due to the need to switch back and forth between normal and template states, etc. This should be easier to maintain than a hand-written scanner, while ragel gives us the extra features we need to implement things that would normally be too complex for a "regular" scanner generator.
2017-05-28 02:01:43 +00:00
}
zclwrite: absorb lead comments into attributes The native parser's ranges don't include any surrounding comments, so we need to do a little more work to pick them out of the surrounding token sequences. This just takes care of _lead_ comments, which are those that appear as whole line comments above the item in question. Line comments, which appear after the item on the same line, will follow in a later commit.
2017-06-08 16:04:27 +00:00
case 63:
zclsyntax: separate tokens for assign = and equality test ==
2017-06-04 23:00:40 +00:00
// line 240 "scan_tokens.rl"
zclsyntax: identifiers in the scanner
2017-05-28 16:16:53 +00:00
te = p
p--
{
token(TokenIdent)
}
zclwrite: absorb lead comments into attributes The native parser's ranges don't include any surrounding comments, so we need to do a little more work to pick them out of the surrounding token sequences. This just takes care of _lead_ comments, which are those that appear as whole line comments above the item in question. Line comments, which appear after the item on the same line, will follow in a later commit.
2017-06-08 16:04:27 +00:00
case 64:
zclsyntax: separate tokens for assign = and equality test ==
2017-06-04 23:00:40 +00:00
// line 242 "scan_tokens.rl"
zclsyntax: scanning of comments
2017-05-29 16:13:35 +00:00
te = p
p--
{
token(TokenComment)
}
zclwrite: absorb lead comments into attributes The native parser's ranges don't include any surrounding comments, so we need to do a little more work to pick them out of the surrounding token sequences. This just takes care of _lead_ comments, which are those that appear as whole line comments above the item in question. Line comments, which appear after the item on the same line, will follow in a later commit.
2017-06-08 16:04:27 +00:00
case 65:
zclsyntax: separate tokens for assign = and equality test ==
2017-06-04 23:00:40 +00:00
// line 251 "scan_tokens.rl"
zclsyntax: scan multi-character punctuation tokens
2017-05-28 16:40:58 +00:00
te = p
p--
{
selfToken()
}
zclwrite: absorb lead comments into attributes The native parser's ranges don't include any surrounding comments, so we need to do a little more work to pick them out of the surrounding token sequences. This just takes care of _lead_ comments, which are those that appear as whole line comments above the item in question. Line comments, which appear after the item on the same line, will follow in a later commit.
2017-06-08 16:04:27 +00:00
case 66:
zclsyntax: separate tokens for assign = and equality test ==
2017-06-04 23:00:40 +00:00
// line 261 "scan_tokens.rl"
zclsyntax: re-organize and simplify the scanner
2017-05-28 15:38:13 +00:00
te = p
p--
{
zclsyntax: scanning of numeric literals
2017-05-28 15:56:43 +00:00
token(TokenTabs)
zclsyntax: re-organize and simplify the scanner
2017-05-28 15:38:13 +00:00
}
zclwrite: absorb lead comments into attributes The native parser's ranges don't include any surrounding comments, so we need to do a little more work to pick them out of the surrounding token sequences. This just takes care of _lead_ comments, which are those that appear as whole line comments above the item in question. Line comments, which appear after the item on the same line, will follow in a later commit.
2017-06-08 16:04:27 +00:00
case 67:
zclsyntax: separate tokens for assign = and equality test ==
2017-06-04 23:00:40 +00:00
// line 262 "scan_tokens.rl"
zclsyntax: scanning of numeric literals
2017-05-28 15:56:43 +00:00
zclsyntax: detect newlines during scanning This is important because our syntax for objects uses newlines as the separator between items, so this is the only signal we'll get that a given item has ended and another is beginning.
2017-05-29 16:25:21 +00:00
te = p
p--
{
zclsyntax: generate lexer diagnostics There are certain tokens that are _never_ valid, so we might as well catch them early in the Lex... functions rather than having to handle them in many different contexts within the parser. Unfortunately for now when such errors occur they tend to be echoed by more confusing errors coming from the parser, but we'll accept that for now.
2017-06-04 14:34:26 +00:00
token(TokenBadUTF8)
zclsyntax: detect newlines during scanning This is important because our syntax for objects uses newlines as the separator between items, so this is the only signal we'll get that a given item has ended and another is beginning.
2017-05-29 16:25:21 +00:00
}
zclwrite: absorb lead comments into attributes The native parser's ranges don't include any surrounding comments, so we need to do a little more work to pick them out of the surrounding token sequences. This just takes care of _lead_ comments, which are those that appear as whole line comments above the item in question. Line comments, which appear after the item on the same line, will follow in a later commit.
2017-06-08 16:04:27 +00:00
case 68:
zclsyntax: separate tokens for assign = and equality test ==
2017-06-04 23:00:40 +00:00
// line 263 "scan_tokens.rl"
zclsyntax: detect newlines during scanning This is important because our syntax for objects uses newlines as the separator between items, so this is the only signal we'll get that a given item has ended and another is beginning.
2017-05-29 16:25:21 +00:00
zclsyntax: scanning of numeric literals
2017-05-28 15:56:43 +00:00
te = p
p--
{
zclsyntax: generate lexer diagnostics There are certain tokens that are _never_ valid, so we might as well catch them early in the Lex... functions rather than having to handle them in many different contexts within the parser. Unfortunately for now when such errors occur they tend to be echoed by more confusing errors coming from the parser, but we'll accept that for now.
2017-06-04 14:34:26 +00:00
token(TokenInvalid)
zclsyntax: scanning of numeric literals
2017-05-28 15:56:43 +00:00
}
zclwrite: absorb lead comments into attributes The native parser's ranges don't include any surrounding comments, so we need to do a little more work to pick them out of the surrounding token sequences. This just takes care of _lead_ comments, which are those that appear as whole line comments above the item in question. Line comments, which appear after the item on the same line, will follow in a later commit.
2017-06-08 16:04:27 +00:00
case 69:
zclsyntax: separate tokens for assign = and equality test ==
2017-06-04 23:00:40 +00:00
// line 239 "scan_tokens.rl"
zclsyntax: start of a ragel-based scanner Using Ragel here because the scanner is going to be somewhat complex due to the need to switch back and forth between normal and template states, etc. This should be easier to maintain than a hand-written scanner, while ragel gives us the extra features we need to implement things that would normally be too complex for a "regular" scanner generator.
2017-05-28 02:01:43 +00:00
zclsyntax: scanning of numeric literals
2017-05-28 15:56:43 +00:00
p = (te) - 1
{
token(TokenNumberLit)
}
zclwrite: absorb lead comments into attributes The native parser's ranges don't include any surrounding comments, so we need to do a little more work to pick them out of the surrounding token sequences. This just takes care of _lead_ comments, which are those that appear as whole line comments above the item in question. Line comments, which appear after the item on the same line, will follow in a later commit.
2017-06-08 16:04:27 +00:00
case 70:
zclsyntax: separate tokens for assign = and equality test ==
2017-06-04 23:00:40 +00:00
// line 240 "scan_tokens.rl"
zclsyntax: scanning of numeric literals
2017-05-28 15:56:43 +00:00
zclsyntax: identifiers in the scanner
2017-05-28 16:16:53 +00:00
p = (te) - 1
{
token(TokenIdent)
}
zclwrite: absorb lead comments into attributes The native parser's ranges don't include any surrounding comments, so we need to do a little more work to pick them out of the surrounding token sequences. This just takes care of _lead_ comments, which are those that appear as whole line comments above the item in question. Line comments, which appear after the item on the same line, will follow in a later commit.
2017-06-08 16:04:27 +00:00
case 71:
zclsyntax: separate tokens for assign = and equality test ==
2017-06-04 23:00:40 +00:00
// line 251 "scan_tokens.rl"
zclsyntax: heredoc support in the scanner
2017-05-29 15:55:53 +00:00
p = (te) - 1
{
selfToken()
}
zclwrite: absorb lead comments into attributes The native parser's ranges don't include any surrounding comments, so we need to do a little more work to pick them out of the surrounding token sequences. This just takes care of _lead_ comments, which are those that appear as whole line comments above the item in question. Line comments, which appear after the item on the same line, will follow in a later commit.
2017-06-08 16:04:27 +00:00
case 72:
zclsyntax: separate tokens for assign = and equality test ==
2017-06-04 23:00:40 +00:00
// line 262 "scan_tokens.rl"
zclsyntax: identifiers in the scanner
2017-05-28 16:16:53 +00:00
zclsyntax: start of a ragel-based scanner Using Ragel here because the scanner is going to be somewhat complex due to the need to switch back and forth between normal and template states, etc. This should be easier to maintain than a hand-written scanner, while ragel gives us the extra features we need to implement things that would normally be too complex for a "regular" scanner generator.
2017-05-28 02:01:43 +00:00
p = (te) - 1
{
zclsyntax: re-organize and simplify the scanner
2017-05-28 15:38:13 +00:00
token(TokenBadUTF8)
zclsyntax: start of a ragel-based scanner Using Ragel here because the scanner is going to be somewhat complex due to the need to switch back and forth between normal and template states, etc. This should be easier to maintain than a hand-written scanner, while ragel gives us the extra features we need to implement things that would normally be too complex for a "regular" scanner generator.
2017-05-28 02:01:43 +00:00
}
zclwrite: absorb lead comments into attributes The native parser's ranges don't include any surrounding comments, so we need to do a little more work to pick them out of the surrounding token sequences. This just takes care of _lead_ comments, which are those that appear as whole line comments above the item in question. Line comments, which appear after the item on the same line, will follow in a later commit.
2017-06-08 16:04:27 +00:00
case 73:
zclsyntax: identifiers in the scanner
2017-05-28 16:16:53 +00:00
// line 1 "NONE"
switch act {
zclsyntax: scanning of bare (top-level) templates This alternative scanning mode makes the scanner start in template context rather than normal context. This will be later used by the parser to allow parsing of standalone templates that aren't embedded inside a zcl configuration file.
2017-05-29 16:42:20 +00:00
case 18:
zclsyntax: identifiers in the scanner
2017-05-28 16:16:53 +00:00
{
p = (te) - 1
token(TokenIdent)
}
zclsyntax: scanning of bare (top-level) templates This alternative scanning mode makes the scanner start in template context rather than normal context. This will be later used by the parser to allow parsing of standalone templates that aren't embedded inside a zcl configuration file.
2017-05-29 16:42:20 +00:00
case 19:
zclsyntax: scanning of comments
2017-05-29 16:13:35 +00:00
{
p = (te) - 1
token(TokenComment)
}
zclsyntax: separate tokens for assign = and equality test ==
2017-06-04 23:00:40 +00:00
case 27:
zclsyntax: scanning of comments
2017-05-29 16:13:35 +00:00
{
p = (te) - 1
selfToken()
}
zclsyntax: separate tokens for assign = and equality test ==
2017-06-04 23:00:40 +00:00
case 34:
zclsyntax: scanning of comments
2017-05-29 16:13:35 +00:00
{
p = (te) - 1
zclsyntax: generate lexer diagnostics There are certain tokens that are _never_ valid, so we might as well catch them early in the Lex... functions rather than having to handle them in many different contexts within the parser. Unfortunately for now when such errors occur they tend to be echoed by more confusing errors coming from the parser, but we'll accept that for now.
2017-06-04 14:34:26 +00:00
token(TokenBadUTF8)
zclsyntax: scanning of comments
2017-05-29 16:13:35 +00:00
}
zclsyntax: separate tokens for assign = and equality test ==
2017-06-04 23:00:40 +00:00
case 35:
zclsyntax: identifiers in the scanner
2017-05-28 16:16:53 +00:00
{
p = (te) - 1
zclsyntax: generate lexer diagnostics There are certain tokens that are _never_ valid, so we might as well catch them early in the Lex... functions rather than having to handle them in many different contexts within the parser. Unfortunately for now when such errors occur they tend to be echoed by more confusing errors coming from the parser, but we'll accept that for now.
2017-06-04 14:34:26 +00:00
token(TokenInvalid)
zclsyntax: identifiers in the scanner
2017-05-28 16:16:53 +00:00
}
}
zclwrite: absorb lead comments into attributes The native parser's ranges don't include any surrounding comments, so we need to do a little more work to pick them out of the surrounding token sequences. This just takes care of _lead_ comments, which are those that appear as whole line comments above the item in question. Line comments, which appear after the item on the same line, will follow in a later commit.
2017-06-08 16:04:27 +00:00
// line 3578 "scan_tokens.go"
zclsyntax: start of a ragel-based scanner Using Ragel here because the scanner is going to be somewhat complex due to the need to switch back and forth between normal and template states, etc. This should be easier to maintain than a hand-written scanner, while ragel gives us the extra features we need to implement things that would normally be too complex for a "regular" scanner generator.
2017-05-28 02:01:43 +00:00
}
}
_again:
_acts = int(_zcltok_to_state_actions[cs])
_nacts = uint(_zcltok_actions[_acts])
_acts++
for ; _nacts > 0; _nacts-- {
_acts++
switch _zcltok_actions[_acts-1] {
zclsyntax: re-organize and simplify the scanner
2017-05-28 15:38:13 +00:00
case 0:
zclsyntax: start of a ragel-based scanner Using Ragel here because the scanner is going to be somewhat complex due to the need to switch back and forth between normal and template states, etc. This should be easier to maintain than a hand-written scanner, while ragel gives us the extra features we need to implement things that would normally be too complex for a "regular" scanner generator.
2017-05-28 02:01:43 +00:00
// line 1 "NONE"
ts = 0
zclsyntax: heredoc support in the scanner
2017-05-29 15:55:53 +00:00
case 1:
// line 1 "NONE"
act = 0
zclwrite: absorb lead comments into attributes The native parser's ranges don't include any surrounding comments, so we need to do a little more work to pick them out of the surrounding token sequences. This just takes care of _lead_ comments, which are those that appear as whole line comments above the item in question. Line comments, which appear after the item on the same line, will follow in a later commit.
2017-06-08 16:04:27 +00:00
// line 3598 "scan_tokens.go"
zclsyntax: start of a ragel-based scanner Using Ragel here because the scanner is going to be somewhat complex due to the need to switch back and forth between normal and template states, etc. This should be easier to maintain than a hand-written scanner, while ragel gives us the extra features we need to implement things that would normally be too complex for a "regular" scanner generator.
2017-05-28 02:01:43 +00:00
}
}
zclsyntax: heredoc support in the scanner
2017-05-29 15:55:53 +00:00
if cs == 0 {
goto _out
}
zclsyntax: start of a ragel-based scanner Using Ragel here because the scanner is going to be somewhat complex due to the need to switch back and forth between normal and template states, etc. This should be easier to maintain than a hand-written scanner, while ragel gives us the extra features we need to implement things that would normally be too complex for a "regular" scanner generator.
2017-05-28 02:01:43 +00:00
p++
if p != pe {
goto _resume
}
_test_eof:
{
}
if p == eof {
if _zcltok_eof_trans[cs] > 0 {
_trans = int(_zcltok_eof_trans[cs] - 1)
goto _eof_trans
}
}
zclsyntax: heredoc support in the scanner
2017-05-29 15:55:53 +00:00
_out:
{
}
zclsyntax: start of a ragel-based scanner Using Ragel here because the scanner is going to be somewhat complex due to the need to switch back and forth between normal and template states, etc. This should be easier to maintain than a hand-written scanner, while ragel gives us the extra features we need to implement things that would normally be too complex for a "regular" scanner generator.
2017-05-28 02:01:43 +00:00
}
zclsyntax: separate tokens for assign = and equality test ==
2017-06-04 23:00:40 +00:00
// line 322 "scan_tokens.rl"
zclsyntax: start of a ragel-based scanner Using Ragel here because the scanner is going to be somewhat complex due to the need to switch back and forth between normal and template states, etc. This should be easier to maintain than a hand-written scanner, while ragel gives us the extra features we need to implement things that would normally be too complex for a "regular" scanner generator.
2017-05-28 02:01:43 +00:00
zclsyntax: scanner to return whole token slice at once On reflection, it seems easier to maintain the necessary state we need by doing all of the scanning in a single pass, since we can then just use local variables within the scanner function.
2017-05-28 14:11:24 +00:00
// If we fall out here without being in a final state then we've
// encountered something that the scanner can't match, which we'll
// deal with as an invalid.
if cs < zcltok_first_final {
f.emitToken(TokenInvalid, p, len(data))
}
zclsyntax: re-organize and simplify the scanner
2017-05-28 15:38:13 +00:00
// We always emit a synthetic EOF token at the end, since it gives the
// parser position information for an "unexpected EOF" diagnostic.
f.emitToken(TokenEOF, len(data), len(data))
zclsyntax: scanner to return whole token slice at once On reflection, it seems easier to maintain the necessary state we need by doing all of the scanning in a single pass, since we can then just use local variables within the scanner function.
2017-05-28 14:11:24 +00:00
return f.Tokens
zclsyntax: start of a ragel-based scanner Using Ragel here because the scanner is going to be somewhat complex due to the need to switch back and forth between normal and template states, etc. This should be easier to maintain than a hand-written scanner, while ragel gives us the extra features we need to implement things that would normally be too complex for a "regular" scanner generator.
2017-05-28 02:01:43 +00:00
}
Reference in New Issue Copy Permalink