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

3779 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,
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
1, 74, 1, 75, 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: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
0, 0, 1, 2, 3, 5, 9, 11,
zclsyntax: permit dashes in identifiers While this does create some ambiguity with arithmetic on variables, like a-b, this is permitted by HCL and so we'll permit it for zcl too, at the expense of requiring spaces to be used around minus signs for correct interpretation.
2017-06-24 16:12:24 +00:00
52, 92, 138, 139, 143, 149, 149, 151,
153, 162, 168, 175, 176, 179, 180, 184,
189, 198, 202, 206, 214, 216, 218, 220,
223, 255, 257, 259, 263, 267, 270, 281,
294, 313, 326, 342, 354, 370, 385, 406,
416, 428, 439, 453, 468, 478, 490, 499,
511, 513, 517, 538, 547, 557, 563, 569,
570, 619, 621, 625, 627, 633, 640, 648,
655, 658, 664, 668, 672, 674, 678, 682,
686, 692, 700, 708, 714, 716, 720, 722,
728, 732, 736, 740, 744, 749, 756, 762,
764, 766, 770, 772, 778, 782, 786, 796,
801, 815, 830, 832, 840, 842, 847, 861,
866, 868, 872, 873, 877, 883, 889, 899,
909, 920, 928, 931, 934, 938, 942, 944,
947, 947, 950, 952, 982, 984, 986, 990,
995, 999, 1004, 1006, 1008, 1010, 1019, 1023,
1027, 1033, 1035, 1043, 1051, 1063, 1066, 1072,
1076, 1078, 1082, 1102, 1104, 1106, 1117, 1123,
1125, 1127, 1129, 1133, 1139, 1145, 1147, 1152,
1156, 1158, 1166, 1184, 1224, 1234, 1238, 1240,
1242, 1243, 1247, 1251, 1255, 1259, 1263, 1268,
1272, 1276, 1280, 1282, 1284, 1288, 1298, 1302,
1304, 1308, 1312, 1316, 1329, 1331, 1333, 1337,
1339, 1343, 1345, 1347, 1377, 1381, 1385, 1389,
1392, 1399, 1404, 1415, 1419, 1435, 1449, 1453,
1458, 1462, 1466, 1472, 1474, 1480, 1482, 1486,
1488, 1494, 1499, 1504, 1514, 1516, 1518, 1522,
1526, 1528, 1541, 1543, 1547, 1551, 1559, 1561,
1565, 1567, 1568, 1571, 1576, 1578, 1580, 1584,
1586, 1590, 1596, 1616, 1622, 1628, 1630, 1631,
1641, 1642, 1650, 1657, 1659, 1662, 1664, 1666,
1668, 1673, 1677, 1681, 1686, 1696, 1706, 1710,
1714, 1728, 1754, 1764, 1766, 1768, 1771, 1773,
1776, 1778, 1782, 1784, 1785, 1789, 1791, 1794,
1801, 1809, 1811, 1813, 1817, 1819, 1825, 1836,
1839, 1841, 1845, 1850, 1880, 1885, 1887, 1890,
1895, 1909, 1916, 1930, 1935, 1948, 1952, 1965,
1970, 1988, 1989, 1998, 2002, 2014, 2019, 2026,
2033, 2040, 2042, 2046, 2068, 2073, 2074, 2078,
2080, 2130, 2133, 2144, 2148, 2150, 2156, 2162,
2164, 2169, 2171, 2175, 2177, 2178, 2180, 2182,
2188, 2190, 2192, 2196, 2202, 2215, 2217, 2223,
2227, 2235, 2246, 2254, 2257, 2287, 2293, 2296,
2301, 2303, 2307, 2311, 2315, 2317, 2324, 2326,
2335, 2342, 2350, 2352, 2372, 2384, 2388, 2390,
2408, 2447, 2449, 2453, 2455, 2462, 2466, 2494,
2496, 2498, 2500, 2502, 2505, 2507, 2511, 2515,
2517, 2520, 2522, 2524, 2527, 2529, 2531, 2532,
2534, 2536, 2540, 2544, 2547, 2560, 2562, 2568,
2572, 2574, 2578, 2582, 2596, 2599, 2608, 2610,
2614, 2620, 2620, 2622, 2624, 2633, 2639, 2646,
2647, 2650, 2651, 2655, 2660, 2669, 2673, 2677,
2685, 2687, 2689, 2691, 2694, 2726, 2728, 2730,
2734, 2738, 2741, 2752, 2765, 2784, 2797, 2813,
2825, 2841, 2856, 2877, 2887, 2899, 2910, 2924,
2939, 2949, 2961, 2970, 2982, 2984, 2988, 3009,
3018, 3028, 3034, 3040, 3041, 3090, 3092, 3096,
3098, 3104, 3111, 3119, 3126, 3129, 3135, 3139,
3143, 3145, 3149, 3153, 3157, 3163, 3171, 3179,
3185, 3187, 3191, 3193, 3199, 3203, 3207, 3211,
3215, 3220, 3227, 3233, 3235, 3237, 3241, 3243,
3249, 3253, 3257, 3267, 3272, 3286, 3301, 3303,
3311, 3313, 3318, 3332, 3337, 3339, 3343, 3344,
3348, 3354, 3360, 3370, 3380, 3391, 3399, 3402,
3405, 3409, 3413, 3415, 3418, 3418, 3421, 3423,
3453, 3455, 3457, 3461, 3466, 3470, 3475, 3477,
3479, 3481, 3490, 3494, 3498, 3504, 3506, 3514,
3522, 3534, 3537, 3543, 3547, 3549, 3553, 3573,
3575, 3577, 3588, 3594, 3596, 3598, 3600, 3604,
3610, 3616, 3618, 3623, 3627, 3629, 3637, 3655,
3695, 3705, 3709, 3711, 3713, 3714, 3718, 3722,
3726, 3730, 3734, 3739, 3743, 3747, 3751, 3753,
3755, 3759, 3769, 3773, 3775, 3779, 3783, 3787,
3800, 3802, 3804, 3808, 3810, 3814, 3816, 3818,
3848, 3852, 3856, 3860, 3863, 3870, 3875, 3886,
3890, 3906, 3920, 3924, 3929, 3933, 3937, 3943,
3945, 3951, 3953, 3957, 3959, 3965, 3970, 3975,
3985, 3987, 3989, 3993, 3997, 3999, 4012, 4014,
4018, 4022, 4030, 4032, 4036, 4038, 4039, 4042,
4047, 4049, 4051, 4055, 4057, 4061, 4067, 4087,
4093, 4099, 4101, 4102, 4112, 4113, 4121, 4128,
4130, 4133, 4135, 4137, 4139, 4144, 4148, 4152,
4157, 4167, 4177, 4181, 4185, 4199, 4225, 4235,
4237, 4239, 4242, 4244, 4247, 4249, 4253, 4255,
4256, 4260, 4262, 4264, 4271, 4275, 4282, 4289,
4298, 4314, 4326, 4344, 4355, 4367, 4375, 4393,
4401, 4431, 4434, 4444, 4454, 4466, 4477, 4486,
4499, 4511, 4515, 4521, 4548, 4557, 4560, 4565,
4571, 4576, 4597, 4601, 4607, 4607, 4614, 4623,
4631, 4634, 4638, 4644, 4650, 4653, 4657, 4664,
4670, 4679, 4688, 4692, 4696, 4700, 4704, 4711,
4715, 4719, 4729, 4735, 4739, 4745, 4749, 4752,
4758, 4764, 4776, 4780, 4784, 4794, 4798, 4809,
4811, 4813, 4817, 4829, 4834, 4858, 4862, 4868,
4890, 4899, 4903, 4906, 4907, 4915, 4923, 4929,
4939, 4946, 4964, 4967, 4970, 4978, 4984, 4988,
4992, 4996, 5002, 5010, 5015, 5021, 5025, 5033,
5040, 5044, 5051, 5057, 5065, 5073, 5079, 5085,
5096, 5100, 5112, 5121, 5138, 5155, 5158, 5162,
5164, 5170, 5172, 5176, 5191, 5195, 5199, 5203,
5207, 5211, 5213, 5219, 5224, 5228, 5234, 5241,
5244, 5262, 5264, 5309, 5315, 5321, 5325, 5329,
5335, 5339, 5345, 5351, 5358, 5360, 5366, 5372,
5376, 5380, 5388, 5401, 5407, 5414, 5422, 5428,
5437, 5443, 5447, 5452, 5456, 5464, 5468, 5472,
5502, 5508, 5514, 5520, 5526, 5533, 5539, 5546,
5551, 5561, 5565, 5572, 5578, 5582, 5589, 5593,
5599, 5602, 5606, 5610, 5614, 5618, 5623, 5628,
5632, 5643, 5647, 5651, 5657, 5665, 5669, 5686,
5690, 5696, 5706, 5712, 5718, 5721, 5726, 5735,
5739, 5743, 5749, 5753, 5759, 5767, 5785, 5786,
5796, 5797, 5806, 5814, 5816, 5819, 5821, 5823,
5825, 5830, 5843, 5847, 5862, 5891, 5902, 5904,
5908, 5912, 5917, 5921, 5923, 5930, 5934, 5942,
5946, 5947, 5949, 5951, 5953, 5955, 5957, 5958,
5959, 5961, 5963, 5965, 5966, 5967, 5968, 5969,
5971, 5973, 5975, 5976, 5977, 6052, 6053, 6054,
6055, 6056, 6057, 6058, 6059, 6061, 6062, 6067,
6069, 6071, 6072, 6116, 6117, 6118, 6120, 6125,
6129, 6129, 6131, 6133, 6144, 6154, 6162, 6163,
6165, 6166, 6170, 6174, 6184, 6188, 6195, 6206,
6213, 6217, 6223, 6234, 6266, 6315, 6330, 6345,
6350, 6352, 6357, 6389, 6397, 6399, 6421, 6443,
6445, 6461, 6477, 6492, 6501, 6515, 6529, 6545,
6546, 6547, 6548, 6549, 6551, 6553, 6555, 6569,
6583, 6584, 6585, 6587, 6589, 6591, 6605, 6619,
6620, 6621, 6623, 6625,
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: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
10, 46, 42, 42, 47, 43, 45, 48,
57, 48, 57, 45, 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, 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,
zclsyntax: permit dashes in identifiers While this does create some ambiguity with arithmetic on variables, like a-b, this is permitted by HCL and so we'll permit it for zcl too, at the expense of requiring spaces to be used around minus signs for correct interpretation.
2017-06-24 16:12:24 +00:00
208, 218, 229, 236, 10, 13, 45, 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, 182, 184, 255, 192, 255, 0,
127, 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, 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, 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, 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, 170, 176, 178, 179, 181, 182,
184, 185, 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, 255, 160, 168, 169, 171, 172,
173, 174, 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,
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
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, 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, 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, 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,
zclsyntax: permit dashes in identifiers While this does create some ambiguity with arithmetic on variables, like a-b, this is permitted by HCL and so we'll permit it for zcl too, at the expense of requiring spaces to be used around minus signs for correct interpretation.
2017-06-24 16:12:24 +00:00
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,
zclsyntax: scanning of comments
2017-05-29 16:13:35 +00:00
159, 134, 187, 136, 140, 142, 143, 137,
151, 153, 142, 143, 158, 159, 137, 177,
zclsyntax: permit dashes in identifiers While this does create some ambiguity with arithmetic on variables, like a-b, this is permitted by HCL and so we'll permit it for zcl too, at the expense of requiring spaces to be used around minus signs for correct interpretation.
2017-06-24 16:12:24 +00:00
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,
zclsyntax: scanning of comments
2017-05-29 16:13:35 +00:00
138, 139, 140, 141, 144, 145, 146, 147,
zclsyntax: permit dashes in identifiers While this does create some ambiguity with arithmetic on variables, like a-b, this is permitted by HCL and so we'll permit it for zcl too, at the expense of requiring spaces to be used around minus signs for correct interpretation.
2017-06-24 16:12:24 +00:00
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, 191, 128, 191, 123, 123, 10,
123, 128, 191, 128, 191, 128, 191, 123,
123, 9, 10, 13, 32, 33, 34, 35,
38, 46, 47, 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, 45, 48, 57, 58, 63, 65, 90,
91, 96, 97, 122, 192, 193, 196, 218,
229, 236, 241, 247, 9, 10, 32, 61,
10, 38, 46, 42, 47, 42, 46, 69,
101, 48, 57, 60, 61, 61, 62, 61,
45, 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, 34,
36, 37, 92, 128, 191, 192, 223, 224,
239, 240, 247, 248, 255, 10, 13, 34,
92, 36, 37, 128, 191, 192, 223, 224,
239, 240, 247, 248, 255, 10, 13, 92,
36, 37, 128, 191, 192, 223, 224, 239,
240, 247, 248, 255, 92, 36, 37, 192,
223, 224, 239, 240, 247, 10, 13, 34,
92, 36, 37, 192, 223, 224, 239, 240,
zclsyntax: change template control sequence introducer to %{ Previously it was !{, but in real examples this looked confusing since an exclamation point after a word looks (to humans) like literal punctuation rather than syntax. % is not ideal either since it's also the marker traditionally used for printf, but has the advantage that programmers are already primed for it to be syntax.
2017-06-18 01:33:56 +00:00
247, 248, 255, 10, 13, 34, 92, 36,
zclsyntax: permit dashes in identifiers While this does create some ambiguity with arithmetic on variables, like a-b, this is permitted by HCL and so we'll permit it for zcl too, at the expense of requiring spaces to be used around minus signs for correct interpretation.
2017-06-24 16:12:24 +00:00
37, 128, 223, 224, 239, 240, 247, 248,
zclsyntax: change template control sequence introducer to %{ Previously it was !{, but in real examples this looked confusing since an exclamation point after a word looks (to humans) like literal punctuation rather than syntax. % is not ideal either since it's also the marker traditionally used for printf, but has the advantage that programmers are already primed for it to be syntax.
2017-06-18 01:33:56 +00:00
255, 10, 13, 34, 92, 36, 37, 128,
zclsyntax: permit dashes in identifiers While this does create some ambiguity with arithmetic on variables, like a-b, this is permitted by HCL and so we'll permit it for zcl too, at the expense of requiring spaces to be used around minus signs for correct interpretation.
2017-06-24 16:12:24 +00:00
191, 192, 223, 224, 239, 240, 247, 248,
255, 123, 126, 123, 126, 128, 191, 128,
191, 128, 191, 10, 13, 36, 37, 128,
191, 192, 223, 224, 239, 240, 247, 248,
255, 10, 13, 36, 37, 128, 191, 192,
223, 224, 239, 240, 247, 248, 255, 126,
126, 128, 191, 128, 191, 128, 191, 10,
zclsyntax: change template control sequence introducer to %{ Previously it was !{, but in real examples this looked confusing since an exclamation point after a word looks (to humans) like literal punctuation rather than syntax. % is not ideal either since it's also the marker traditionally used for printf, but has the advantage that programmers are already primed for it to be syntax.
2017-06-18 01:33:56 +00:00
13, 36, 37, 128, 191, 192, 223, 224,
zclsyntax: permit dashes in identifiers While this does create some ambiguity with arithmetic on variables, like a-b, this is permitted by HCL and so we'll permit it for zcl too, at the expense of requiring spaces to be used around minus signs for correct interpretation.
2017-06-24 16:12:24 +00:00
239, 240, 247, 248, 255, 10, 13, 36,
zclsyntax: change template control sequence introducer to %{ Previously it was !{, but in real examples this looked confusing since an exclamation point after a word looks (to humans) like literal punctuation rather than syntax. % is not ideal either since it's also the marker traditionally used for printf, but has the advantage that programmers are already primed for it to be syntax.
2017-06-18 01:33:56 +00:00
37, 128, 191, 192, 223, 224, 239, 240,
zclsyntax: permit dashes in identifiers While this does create some ambiguity with arithmetic on variables, like a-b, this is permitted by HCL and so we'll permit it for zcl too, at the expense of requiring spaces to be used around minus signs for correct interpretation.
2017-06-24 16:12:24 +00:00
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: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
0, 1, 1, 1, 2, 2, 0, 31,
zclsyntax: permit dashes in identifiers While this does create some ambiguity with arithmetic on variables, like a-b, this is permitted by HCL and so we'll permit it for zcl too, at the expense of requiring spaces to be used around minus signs for correct interpretation.
2017-06-24 16:12:24 +00:00
30, 36, 1, 4, 0, 0, 0, 0,
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
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,
zclsyntax: heredoc support in the scanner
2017-05-29 15:55:53 +00:00
1, 0, 0, 0, 0, 0, 0, 0,
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
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,
zclsyntax: heredoc support in the scanner
2017-05-29 15:55:53 +00:00
0, 0, 0, 1, 0, 0, 0, 0,
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
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, 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, 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,
zclsyntax: scanning of comments
2017-05-29 16:13:35 +00:00
0, 1, 0, 0, 0, 0, 0, 0,
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
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,
zclsyntax: heredoc support in the scanner
2017-05-29 15:55:53 +00:00
0, 0, 1, 0, 0, 0, 0, 0,
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
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,
zclsyntax: scanning of comments
2017-05-29 16:13:35 +00:00
0, 0, 2, 2, 0, 11, 0, 0,
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
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, 0, 0, 1, 0, 0, 0, 0,
0, 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, 0, 0, 1, 1, 1, 1, 0,
0, 0, 1, 1, 53, 1, 1, 1,
1, 1, 1, 1, 2, 1, 3, 2,
zclsyntax: permit dashes in identifiers While this does create some ambiguity with arithmetic on variables, like a-b, this is permitted by HCL and so we'll permit it for zcl too, at the expense of requiring spaces to be used around minus signs for correct interpretation.
2017-06-24 16:12:24 +00:00
2, 1, 34, 1, 1, 0, 3, 2,
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
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,
zclsyntax: change template control sequence introducer to %{ Previously it was !{, but in real examples this looked confusing since an exclamation point after a word looks (to humans) like literal punctuation rather than syntax. % is not ideal either since it's also the marker traditionally used for printf, but has the advantage that programmers are already primed for it to be syntax.
2017-06-18 01:33:56 +00:00
6, 4, 3, 1, 4, 4, 4, 1,
1, 1, 1, 0, 0, 0, 4, 2,
1, 1, 0, 0, 0, 4, 2, 1,
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
1, 0, 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: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
0, 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, 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, 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, 1, 1, 0, 0, 0, 0, 1,
1, 1, 0, 0, 11, 0, 0, 0,
0, 0, 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,
zclsyntax: change template control sequence introducer to %{ Previously it was !{, but in real examples this looked confusing since an exclamation point after a word looks (to humans) like literal punctuation rather than syntax. % is not ideal either since it's also the marker traditionally used for printf, but has the advantage that programmers are already primed for it to be syntax.
2017-06-18 01:33:56 +00:00
5, 6, 6, 4, 5, 5, 6, 0,
0, 0, 0, 1, 1, 1, 5, 6,
0, 0, 1, 1, 1, 5, 6, 0,
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
0, 1, 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: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
0, 0, 2, 4, 6, 9, 13, 15,
zclsyntax: permit dashes in identifiers While this does create some ambiguity with arithmetic on variables, like a-b, this is permitted by HCL and so we'll permit it for zcl too, at the expense of requiring spaces to be used around minus signs for correct interpretation.
2017-06-24 16:12:24 +00:00
52, 88, 130, 132, 137, 141, 142, 144,
146, 152, 157, 162, 164, 167, 169, 172,
176, 182, 185, 188, 194, 196, 198, 200,
203, 236, 238, 240, 243, 246, 249, 257,
265, 276, 284, 293, 301, 310, 319, 331,
338, 345, 353, 361, 370, 376, 384, 390,
398, 400, 403, 417, 423, 431, 435, 439,
441, 488, 490, 493, 495, 500, 506, 512,
517, 520, 524, 527, 530, 532, 535, 538,
541, 545, 550, 555, 559, 561, 564, 566,
570, 573, 576, 579, 582, 586, 591, 595,
597, 599, 602, 604, 608, 611, 614, 622,
626, 634, 650, 652, 657, 659, 663, 674,
678, 680, 683, 685, 688, 693, 697, 703,
709, 720, 725, 728, 731, 734, 737, 739,
743, 744, 747, 749, 779, 781, 783, 786,
790, 793, 797, 799, 801, 803, 809, 812,
815, 819, 821, 826, 831, 838, 841, 845,
849, 851, 854, 874, 876, 878, 885, 889,
891, 893, 895, 898, 902, 906, 908, 912,
915, 917, 922, 940, 979, 985, 988, 990,
992, 994, 997, 1000, 1003, 1006, 1009, 1013,
1016, 1019, 1022, 1024, 1026, 1029, 1036, 1039,
1041, 1044, 1047, 1050, 1058, 1060, 1062, 1065,
1067, 1070, 1072, 1074, 1104, 1107, 1110, 1113,
1116, 1121, 1125, 1132, 1135, 1144, 1153, 1156,
1160, 1163, 1166, 1170, 1172, 1176, 1178, 1181,
1183, 1187, 1191, 1195, 1203, 1205, 1207, 1211,
1215, 1217, 1230, 1232, 1235, 1238, 1243, 1245,
1248, 1250, 1252, 1255, 1260, 1262, 1264, 1269,
1271, 1274, 1278, 1298, 1302, 1306, 1308, 1310,
1318, 1320, 1327, 1332, 1334, 1338, 1341, 1344,
1347, 1351, 1354, 1357, 1361, 1371, 1377, 1380,
1383, 1393, 1413, 1419, 1422, 1424, 1428, 1430,
1433, 1435, 1439, 1441, 1443, 1447, 1449, 1453,
1458, 1464, 1466, 1468, 1471, 1473, 1477, 1484,
1487, 1489, 1492, 1496, 1526, 1531, 1533, 1536,
1540, 1549, 1554, 1562, 1566, 1574, 1578, 1586,
1590, 1601, 1603, 1609, 1612, 1620, 1624, 1629,
1634, 1639, 1641, 1644, 1659, 1663, 1665, 1668,
1670, 1719, 1722, 1729, 1732, 1734, 1738, 1742,
1745, 1749, 1751, 1754, 1756, 1758, 1760, 1762,
1766, 1768, 1770, 1773, 1777, 1791, 1794, 1798,
1801, 1806, 1817, 1822, 1825, 1855, 1859, 1862,
1867, 1869, 1873, 1876, 1879, 1881, 1886, 1888,
1894, 1899, 1905, 1907, 1927, 1935, 1938, 1940,
1958, 1996, 1998, 2001, 2003, 2008, 2011, 2040,
2042, 2044, 2046, 2048, 2051, 2053, 2057, 2060,
2062, 2065, 2067, 2069, 2072, 2074, 2076, 2078,
2080, 2082, 2085, 2088, 2091, 2104, 2106, 2110,
2113, 2115, 2120, 2123, 2137, 2140, 2149, 2151,
2156, 2160, 2161, 2163, 2165, 2171, 2176, 2181,
2183, 2186, 2188, 2191, 2195, 2201, 2204, 2207,
2213, 2215, 2217, 2219, 2222, 2255, 2257, 2259,
2262, 2265, 2268, 2276, 2284, 2295, 2303, 2312,
2320, 2329, 2338, 2350, 2357, 2364, 2372, 2380,
2389, 2395, 2403, 2409, 2417, 2419, 2422, 2436,
2442, 2450, 2454, 2458, 2460, 2507, 2509, 2512,
2514, 2519, 2525, 2531, 2536, 2539, 2543, 2546,
2549, 2551, 2554, 2557, 2560, 2564, 2569, 2574,
2578, 2580, 2583, 2585, 2589, 2592, 2595, 2598,
2601, 2605, 2610, 2614, 2616, 2618, 2621, 2623,
2627, 2630, 2633, 2641, 2645, 2653, 2669, 2671,
2676, 2678, 2682, 2693, 2697, 2699, 2702, 2704,
2707, 2712, 2716, 2722, 2728, 2739, 2744, 2747,
2750, 2753, 2756, 2758, 2762, 2763, 2766, 2768,
2798, 2800, 2802, 2805, 2809, 2812, 2816, 2818,
2820, 2822, 2828, 2831, 2834, 2838, 2840, 2845,
2850, 2857, 2860, 2864, 2868, 2870, 2873, 2893,
2895, 2897, 2904, 2908, 2910, 2912, 2914, 2917,
2921, 2925, 2927, 2931, 2934, 2936, 2941, 2959,
2998, 3004, 3007, 3009, 3011, 3013, 3016, 3019,
3022, 3025, 3028, 3032, 3035, 3038, 3041, 3043,
3045, 3048, 3055, 3058, 3060, 3063, 3066, 3069,
3077, 3079, 3081, 3084, 3086, 3089, 3091, 3093,
3123, 3126, 3129, 3132, 3135, 3140, 3144, 3151,
3154, 3163, 3172, 3175, 3179, 3182, 3185, 3189,
3191, 3195, 3197, 3200, 3202, 3206, 3210, 3214,
3222, 3224, 3226, 3230, 3234, 3236, 3249, 3251,
3254, 3257, 3262, 3264, 3267, 3269, 3271, 3274,
3279, 3281, 3283, 3288, 3290, 3293, 3297, 3317,
3321, 3325, 3327, 3329, 3337, 3339, 3346, 3351,
3353, 3357, 3360, 3363, 3366, 3370, 3373, 3376,
3380, 3390, 3396, 3399, 3402, 3412, 3432, 3438,
3441, 3443, 3447, 3449, 3452, 3454, 3458, 3460,
3462, 3466, 3468, 3470, 3476, 3479, 3484, 3489,
3495, 3505, 3513, 3525, 3532, 3542, 3548, 3560,
3566, 3584, 3587, 3595, 3601, 3611, 3618, 3625,
3633, 3641, 3644, 3649, 3669, 3675, 3678, 3682,
3686, 3690, 3702, 3705, 3710, 3711, 3717, 3724,
3730, 3733, 3736, 3740, 3744, 3747, 3750, 3755,
3759, 3765, 3771, 3774, 3778, 3781, 3784, 3789,
3792, 3795, 3801, 3805, 3808, 3812, 3815, 3818,
3822, 3826, 3833, 3836, 3839, 3845, 3848, 3855,
3857, 3859, 3862, 3871, 3876, 3890, 3894, 3898,
3913, 3919, 3922, 3925, 3927, 3932, 3938, 3942,
3950, 3956, 3966, 3969, 3972, 3977, 3981, 3984,
3987, 3990, 3994, 3999, 4003, 4007, 4010, 4015,
4020, 4023, 4029, 4033, 4039, 4044, 4048, 4052,
4060, 4063, 4071, 4077, 4087, 4098, 4101, 4104,
4106, 4110, 4112, 4115, 4126, 4130, 4133, 4136,
4139, 4142, 4144, 4148, 4152, 4155, 4159, 4164,
4167, 4177, 4179, 4220, 4226, 4230, 4233, 4236,
4240, 4243, 4247, 4251, 4256, 4258, 4262, 4266,
4269, 4272, 4277, 4286, 4290, 4295, 4300, 4304,
4311, 4315, 4318, 4322, 4325, 4330, 4333, 4336,
4366, 4370, 4374, 4378, 4382, 4387, 4391, 4397,
4401, 4409, 4412, 4417, 4421, 4424, 4429, 4432,
4436, 4439, 4442, 4445, 4448, 4451, 4455, 4459,
4462, 4472, 4475, 4478, 4483, 4489, 4492, 4507,
4510, 4514, 4520, 4524, 4528, 4531, 4535, 4542,
4545, 4548, 4554, 4557, 4561, 4566, 4582, 4584,
4592, 4594, 4602, 4608, 4610, 4614, 4617, 4620,
4623, 4627, 4638, 4641, 4653, 4677, 4685, 4687,
4691, 4694, 4699, 4702, 4704, 4709, 4712, 4718,
4721, 4723, 4725, 4727, 4729, 4731, 4733, 4735,
4737, 4739, 4741, 4743, 4745, 4747, 4749, 4751,
4753, 4755, 4757, 4759, 4761, 4826, 4828, 4830,
4832, 4834, 4836, 4838, 4840, 4843, 4845, 4850,
4853, 4856, 4858, 4898, 4900, 4902, 4904, 4909,
4913, 4914, 4916, 4918, 4925, 4932, 4939, 4941,
4943, 4945, 4948, 4951, 4957, 4960, 4965, 4972,
4977, 4980, 4984, 4991, 5023, 5072, 5087, 5100,
5105, 5107, 5111, 5142, 5148, 5150, 5171, 5191,
5193, 5205, 5216, 5226, 5232, 5242, 5252, 5263,
5265, 5267, 5269, 5271, 5273, 5275, 5277, 5287,
5296, 5298, 5300, 5302, 5304, 5306, 5316, 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: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
2, 1, 4, 3, 6, 5, 6, 7,
5, 9, 9, 10, 8, 10, 8, 11,
13, 14, 16, 17, 18, 19, 20, 21,
22, 23, 24, 25, 26, 27, 28, 29,
30, 31, 32, 33, 34, 35, 36, 37,
38, 40, 41, 42, 43, 44, 12, 12,
15, 15, 39, 3, 13, 14, 16, 17,
18, 19, 20, 21, 22, 23, 24, 25,
26, 27, 28, 29, 30, 31, 32, 33,
34, 35, 36, 37, 38, 40, 41, 42,
43, 44, 12, 12, 15, 15, 39, 3,
zclsyntax: permit dashes in identifiers While this does create some ambiguity with arithmetic on variables, like a-b, this is permitted by HCL and so we'll permit it for zcl too, at the expense of requiring spaces to be used around minus signs for correct interpretation.
2017-06-24 16:12:24 +00:00
45, 46, 12, 12, 47, 14, 16, 17,
18, 17, 48, 49, 21, 50, 23, 24,
51, 52, 53, 54, 55, 56, 57, 58,
59, 60, 61, 62, 63, 38, 40, 64,
42, 65, 66, 67, 12, 12, 12, 15,
39, 3, 45, 3, 12, 12, 12, 12,
3, 12, 12, 12, 3, 12, 3, 12,
3, 12, 3, 3, 3, 3, 3, 12,
3, 3, 3, 3, 12, 12, 12, 12,
12, 3, 3, 12, 3, 3, 12, 3,
12, 3, 3, 12, 3, 3, 3, 12,
12, 12, 12, 12, 12, 3, 12, 12,
3, 12, 12, 3, 3, 3, 3, 3,
3, 12, 12, 3, 3, 12, 3, 12,
12, 12, 3, 68, 69, 70, 71, 15,
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, 3, 12, 3, 12, 3,
12, 12, 3, 12, 12, 3, 3, 3,
12, 3, 3, 3, 3, 3, 3, 3,
12, 3, 3, 3, 3, 3, 3, 3,
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
12, 12, 12, 12, 12, 12, 12, 12,
12, 12, 12, 3, 3, 3, 3, 3,
3, 3, 3, 12, 12, 12, 12, 12,
zclsyntax: permit dashes in identifiers While this does create some ambiguity with arithmetic on variables, like a-b, this is permitted by HCL and so we'll permit it for zcl too, at the expense of requiring spaces to be used around minus signs for correct interpretation.
2017-06-24 16:12:24 +00:00
12, 12, 12, 12, 3, 3, 3, 3,
3, 3, 3, 3, 12, 12, 12, 12,
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
12, 12, 12, 12, 12, 3, 12, 12,
zclsyntax: permit dashes in identifiers While this does create some ambiguity with arithmetic on variables, like a-b, this is permitted by HCL and so we'll permit it for zcl too, at the expense of requiring spaces to be used around minus signs for correct interpretation.
2017-06-24 16:12:24 +00:00
12, 12, 12, 12, 12, 12, 3, 12,
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
12, 12, 12, 12, 12, 12, 12, 12,
zclsyntax: permit dashes in identifiers While this does create some ambiguity with arithmetic on variables, like a-b, this is permitted by HCL and so we'll permit it for zcl too, at the expense of requiring spaces to be used around minus signs for correct interpretation.
2017-06-24 16:12:24 +00:00
12, 12, 3, 12, 12, 12, 12, 12,
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
12, 3, 12, 12, 12, 12, 12, 12,
zclsyntax: permit dashes in identifiers While this does create some ambiguity with arithmetic on variables, like a-b, this is permitted by HCL and so we'll permit it for zcl too, at the expense of requiring spaces to be used around minus signs for correct interpretation.
2017-06-24 16:12:24 +00:00
3, 3, 3, 3, 3, 3, 3, 3,
12, 12, 12, 12, 12, 12, 12, 12,
3, 12, 12, 12, 12, 12, 12, 12,
12, 3, 12, 12, 12, 12, 12, 3,
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
3, 3, 3, 3, 3, 3, 3, 12,
zclsyntax: permit dashes in identifiers While this does create some ambiguity with arithmetic on variables, like a-b, this is permitted by HCL and so we'll permit it for zcl too, at the expense of requiring spaces to be used around minus signs for correct interpretation.
2017-06-24 16:12:24 +00:00
12, 12, 12, 12, 12, 3, 12, 12,
12, 12, 12, 12, 12, 3, 12, 3,
12, 12, 3, 12, 12, 12, 12, 12,
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
12, 12, 12, 12, 12, 12, 12, 12,
zclsyntax: permit dashes in identifiers While this does create some ambiguity with arithmetic on variables, like a-b, this is permitted by HCL and so we'll permit it for zcl too, at the expense of requiring spaces to be used around minus signs for correct interpretation.
2017-06-24 16:12:24 +00:00
3, 12, 12, 12, 12, 12, 3, 12,
12, 12, 12, 12, 12, 12, 3, 12,
12, 12, 3, 12, 12, 12, 3, 12,
3, 99, 100, 101, 102, 103, 104, 105,
106, 107, 108, 109, 110, 111, 112, 113,
114, 115, 17, 116, 117, 118, 119, 120,
121, 122, 123, 124, 125, 126, 127, 128,
129, 130, 131, 132, 133, 15, 16, 134,
135, 136, 137, 138, 15, 17, 15, 3,
12, 3, 12, 12, 3, 3, 12, 3,
3, 3, 3, 12, 3, 3, 3, 3,
3, 12, 3, 3, 3, 3, 3, 12,
12, 12, 12, 12, 3, 3, 3, 12,
3, 3, 3, 12, 12, 12, 3, 3,
3, 12, 12, 3, 3, 3, 12, 12,
12, 3, 3, 3, 12, 12, 12, 12,
3, 12, 12, 12, 12, 3, 3, 3,
3, 3, 12, 12, 12, 12, 3, 3,
12, 12, 12, 3, 3, 12, 12, 12,
12, 3, 12, 12, 3, 12, 12, 3,
3, 3, 12, 12, 12, 3, 3, 3,
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
3, 12, 12, 12, 12, 12, 3, 3,
zclsyntax: permit dashes in identifiers While this does create some ambiguity with arithmetic on variables, like a-b, this is permitted by HCL and so we'll permit it for zcl too, at the expense of requiring spaces to be used around minus signs for correct interpretation.
2017-06-24 16:12:24 +00:00
3, 3, 12, 3, 12, 12, 3, 12,
12, 3, 12, 3, 12, 12, 12, 3,
12, 12, 3, 3, 3, 12, 3, 3,
3, 3, 3, 3, 3, 12, 12, 12,
12, 3, 12, 12, 12, 12, 12, 12,
12, 3, 139, 140, 141, 142, 143, 144,
145, 146, 147, 15, 148, 149, 150, 151,
152, 3, 12, 3, 3, 3, 3, 3,
12, 12, 3, 12, 12, 12, 3, 12,
12, 12, 12, 12, 12, 12, 12, 12,
12, 3, 12, 12, 12, 3, 3, 12,
12, 12, 3, 3, 12, 3, 3, 12,
12, 12, 12, 12, 3, 3, 3, 3,
12, 12, 12, 12, 12, 12, 3, 12,
12, 12, 12, 12, 3, 153, 110, 154,
155, 156, 15, 157, 158, 17, 15, 3,
12, 12, 12, 12, 3, 3, 3, 12,
3, 3, 12, 12, 12, 3, 3, 3,
12, 12, 3, 120, 3, 17, 15, 15,
159, 3, 15, 3, 12, 17, 160, 161,
17, 162, 163, 17, 58, 164, 165, 166,
167, 168, 17, 169, 170, 171, 17, 172,
173, 174, 16, 175, 176, 177, 16, 178,
17, 15, 3, 3, 12, 12, 3, 3,
3, 12, 12, 12, 12, 3, 12, 12,
3, 3, 3, 3, 12, 12, 3, 3,
12, 12, 3, 3, 3, 3, 3, 3,
12, 12, 12, 3, 3, 3, 12, 3,
3, 3, 12, 12, 3, 12, 12, 12,
12, 3, 12, 12, 12, 12, 3, 12,
12, 12, 12, 12, 12, 3, 3, 3,
12, 12, 12, 12, 3, 179, 180, 3,
15, 3, 12, 3, 3, 12, 17, 181,
182, 183, 184, 58, 185, 186, 56, 187,
188, 189, 190, 191, 192, 193, 194, 195,
15, 3, 3, 12, 3, 12, 12, 12,
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
12, 12, 12, 12, 3, 12, 12, 12,
zclsyntax: permit dashes in identifiers While this does create some ambiguity with arithmetic on variables, like a-b, this is permitted by HCL and so we'll permit it for zcl too, at the expense of requiring spaces to be used around minus signs for correct interpretation.
2017-06-24 16:12:24 +00:00
3, 12, 3, 3, 12, 3, 12, 3,
3, 12, 12, 12, 12, 3, 12, 12,
12, 3, 3, 12, 12, 12, 12, 3,
12, 12, 3, 3, 12, 12, 12, 12,
12, 3, 196, 197, 198, 199, 200, 201,
202, 203, 204, 205, 206, 202, 207, 208,
209, 210, 39, 3, 211, 212, 17, 213,
214, 215, 216, 217, 218, 219, 220, 221,
17, 15, 222, 223, 224, 225, 17, 226,
227, 228, 229, 230, 231, 232, 233, 234,
235, 236, 237, 238, 239, 240, 17, 145,
15, 241, 3, 12, 12, 12, 12, 12,
3, 3, 3, 12, 3, 12, 12, 3,
12, 3, 12, 12, 3, 3, 3, 12,
12, 12, 3, 3, 3, 12, 12, 12,
3, 3, 3, 3, 12, 3, 3, 12,
3, 3, 12, 12, 12, 3, 3, 12,
3, 12, 12, 12, 3, 12, 12, 12,
12, 12, 12, 3, 3, 3, 12, 12,
3, 12, 12, 3, 12, 12, 3, 12,
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
12, 3, 12, 12, 12, 12, 12, 12,
zclsyntax: permit dashes in identifiers While this does create some ambiguity with arithmetic on variables, like a-b, this is permitted by HCL and so we'll permit it for zcl too, at the expense of requiring spaces to be used around minus signs for correct interpretation.
2017-06-24 16:12:24 +00:00
12, 3, 12, 3, 12, 3, 12, 12,
3, 12, 3, 12, 12, 3, 12, 3,
12, 3, 242, 213, 243, 244, 245, 246,
247, 248, 249, 250, 251, 99, 252, 17,
253, 254, 255, 17, 256, 130, 257, 258,
259, 260, 261, 262, 263, 264, 17, 3,
3, 3, 12, 12, 12, 3, 12, 12,
3, 12, 12, 3, 3, 3, 3, 3,
12, 12, 12, 12, 3, 12, 12, 12,
12, 12, 12, 3, 3, 3, 12, 12,
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
12, 12, 12, 12, 12, 12, 12, 3,
zclsyntax: permit dashes in identifiers While this does create some ambiguity with arithmetic on variables, like a-b, this is permitted by HCL and so we'll permit it for zcl too, at the expense of requiring spaces to be used around minus signs for correct interpretation.
2017-06-24 16:12:24 +00:00
12, 12, 12, 12, 12, 12, 12, 12,
3, 12, 12, 3, 3, 3, 3, 12,
12, 12, 3, 3, 3, 12, 3, 3,
3, 12, 12, 3, 12, 12, 12, 3,
12, 3, 3, 3, 12, 12, 3, 12,
12, 12, 3, 12, 12, 12, 3, 3,
3, 3, 12, 17, 182, 265, 266, 15,
17, 15, 3, 3, 12, 3, 12, 17,
265, 15, 3, 17, 267, 15, 3, 3,
12, 17, 268, 269, 270, 173, 271, 272,
17, 273, 274, 275, 15, 3, 3, 12,
12, 12, 3, 12, 12, 3, 12, 12,
12, 12, 3, 3, 12, 3, 3, 12,
12, 3, 12, 3, 17, 15, 3, 276,
17, 277, 3, 15, 3, 12, 3, 12,
278, 17, 279, 280, 3, 12, 3, 3,
3, 12, 12, 12, 12, 3, 281, 282,
283, 17, 284, 285, 286, 287, 288, 289,
290, 291, 292, 293, 294, 295, 296, 297,
15, 3, 12, 12, 12, 3, 3, 3,
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
3, 12, 12, 3, 3, 12, 3, 3,
zclsyntax: permit dashes in identifiers While this does create some ambiguity with arithmetic on variables, like a-b, this is permitted by HCL and so we'll permit it for zcl too, at the expense of requiring spaces to be used around minus signs for correct interpretation.
2017-06-24 16:12:24 +00:00
3, 3, 3, 3, 3, 12, 3, 12,
3, 3, 3, 3, 3, 3, 12, 12,
12, 12, 12, 3, 3, 12, 3, 3,
3, 12, 3, 3, 12, 3, 3, 12,
3, 3, 12, 3, 3, 3, 12, 12,
12, 3, 3, 3, 12, 12, 12, 12,
3, 298, 17, 299, 17, 300, 301, 302,
303, 15, 3, 12, 12, 12, 12, 12,
3, 3, 3, 12, 3, 3, 12, 12,
12, 12, 12, 12, 12, 12, 12, 12,
3, 12, 12, 12, 12, 12, 12, 12,
12, 12, 12, 12, 12, 12, 12, 12,
12, 12, 12, 12, 3, 12, 12, 12,
12, 12, 3, 304, 17, 15, 3, 12,
305, 17, 101, 15, 3, 12, 306, 3,
15, 3, 12, 17, 307, 15, 3, 3,
12, 308, 3, 17, 309, 15, 3, 3,
12, 12, 12, 12, 3, 12, 12, 12,
12, 3, 12, 12, 12, 12, 12, 3,
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
3, 12, 3, 12, 12, 12, 3, 12,
zclsyntax: permit dashes in identifiers While this does create some ambiguity with arithmetic on variables, like a-b, this is permitted by HCL and so we'll permit it for zcl too, at the expense of requiring spaces to be used around minus signs for correct interpretation.
2017-06-24 16:12:24 +00:00
3, 12, 12, 12, 3, 3, 3, 3,
3, 3, 3, 12, 12, 12, 3, 12,
3, 3, 3, 12, 12, 12, 12, 3,
310, 311, 70, 312, 313, 314, 315, 316,
317, 318, 319, 320, 321, 322, 323, 324,
325, 326, 327, 328, 329, 330, 332, 333,
334, 335, 336, 337, 331, 3, 12, 12,
12, 12, 3, 12, 3, 12, 12, 3,
12, 12, 12, 3, 3, 3, 3, 3,
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
3, 3, 3, 3, 12, 12, 12, 12,
zclsyntax: permit dashes in identifiers While this does create some ambiguity with arithmetic on variables, like a-b, this is permitted by HCL and so we'll permit it for zcl too, at the expense of requiring spaces to be used around minus signs for correct interpretation.
2017-06-24 16:12:24 +00:00
12, 3, 12, 12, 12, 12, 12, 12,
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
12, 3, 12, 12, 12, 3, 12, 12,
12, 12, 12, 12, 12, 3, 12, 12,
zclsyntax: permit dashes in identifiers While this does create some ambiguity with arithmetic on variables, like a-b, this is permitted by HCL and so we'll permit it for zcl too, at the expense of requiring spaces to be used around minus signs for correct interpretation.
2017-06-24 16:12:24 +00:00
12, 3, 12, 12, 12, 12, 12, 12,
12, 3, 12, 12, 12, 3, 12, 12,
12, 12, 12, 12, 12, 12, 12, 12,
3, 12, 3, 12, 12, 12, 12, 12,
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
3, 12, 12, 3, 12, 12, 12, 12,
12, 12, 12, 3, 12, 12, 12, 3,
12, 12, 12, 12, 3, 12, 12, 12,
zclsyntax: permit dashes in identifiers While this does create some ambiguity with arithmetic on variables, like a-b, this is permitted by HCL and so we'll permit it for zcl too, at the expense of requiring spaces to be used around minus signs for correct interpretation.
2017-06-24 16:12:24 +00:00
12, 3, 12, 12, 12, 12, 3, 12,
3, 12, 12, 3, 12, 12, 12, 12,
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
12, 12, 12, 12, 12, 12, 12, 12,
12, 12, 3, 12, 12, 12, 3, 12,
zclsyntax: permit dashes in identifiers While this does create some ambiguity with arithmetic on variables, like a-b, this is permitted by HCL and so we'll permit it for zcl too, at the expense of requiring spaces to be used around minus signs for correct interpretation.
2017-06-24 16:12:24 +00:00
3, 12, 12, 3, 12, 3, 338, 339,
340, 102, 103, 104, 105, 106, 341, 108,
109, 110, 111, 112, 113, 342, 343, 168,
344, 259, 118, 345, 120, 230, 270, 123,
346, 347, 348, 349, 350, 351, 352, 353,
354, 355, 132, 356, 17, 15, 16, 17,
135, 136, 137, 138, 15, 15, 3, 12,
12, 3, 12, 12, 12, 12, 12, 12,
3, 3, 3, 12, 3, 12, 12, 12,
12, 3, 12, 12, 12, 3, 12, 12,
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
3, 12, 12, 12, 3, 3, 12, 12,
zclsyntax: permit dashes in identifiers While this does create some ambiguity with arithmetic on variables, like a-b, this is permitted by HCL and so we'll permit it for zcl too, at the expense of requiring spaces to be used around minus signs for correct interpretation.
2017-06-24 16:12:24 +00:00
12, 3, 3, 12, 12, 3, 12, 3,
12, 3, 12, 12, 12, 3, 3, 12,
12, 3, 12, 12, 3, 12, 12, 12,
3, 357, 141, 143, 144, 145, 146, 147,
15, 358, 149, 359, 151, 360, 3, 12,
12, 3, 3, 3, 3, 12, 3, 3,
12, 12, 12, 12, 12, 3, 361, 110,
362, 155, 156, 15, 157, 158, 17, 15,
3, 12, 12, 12, 12, 3, 3, 3,
12, 17, 160, 161, 17, 363, 364, 220,
309, 164, 165, 166, 365, 168, 366, 367,
368, 369, 370, 371, 372, 373, 374, 375,
176, 177, 16, 376, 17, 15, 3, 3,
3, 3, 12, 12, 12, 3, 3, 3,
3, 3, 12, 12, 3, 12, 12, 12,
3, 12, 12, 3, 3, 3, 12, 12,
3, 12, 12, 12, 12, 3, 12, 3,
12, 12, 12, 12, 12, 3, 3, 3,
3, 3, 12, 12, 12, 12, 12, 12,
3, 12, 3, 17, 181, 182, 377, 184,
58, 185, 186, 56, 187, 188, 378, 15,
191, 379, 193, 194, 195, 15, 3, 12,
12, 12, 12, 12, 12, 12, 3, 12,
12, 3, 12, 3, 380, 381, 198, 199,
200, 382, 202, 203, 383, 384, 385, 202,
207, 208, 209, 210, 39, 3, 211, 212,
17, 213, 214, 216, 386, 218, 387, 220,
221, 17, 15, 388, 223, 224, 225, 17,
226, 227, 228, 229, 230, 231, 232, 233,
389, 235, 236, 390, 238, 239, 240, 17,
145, 15, 241, 3, 3, 12, 3, 3,
12, 3, 12, 12, 12, 12, 12, 3,
12, 12, 3, 391, 392, 393, 394, 395,
396, 397, 398, 248, 399, 320, 400, 214,
401, 402, 403, 404, 405, 402, 406, 407,
408, 259, 409, 261, 410, 411, 272, 3,
12, 3, 12, 3, 12, 3, 12, 3,
12, 12, 3, 12, 3, 12, 12, 12,
3, 12, 12, 3, 3, 12, 12, 12,
3, 12, 3, 12, 3, 12, 12, 3,
12, 3, 12, 3, 12, 3, 12, 3,
12, 3, 3, 3, 12, 12, 12, 3,
12, 12, 3, 17, 268, 230, 412, 402,
413, 272, 17, 414, 415, 275, 15, 3,
12, 3, 12, 12, 12, 3, 3, 3,
12, 12, 3, 278, 17, 279, 416, 3,
12, 12, 3, 17, 284, 285, 286, 287,
288, 289, 290, 291, 292, 293, 417, 15,
3, 3, 3, 12, 17, 418, 17, 266,
301, 302, 303, 15, 3, 3, 12, 420,
420, 420, 420, 419, 420, 420, 420, 419,
420, 419, 420, 420, 419, 419, 419, 419,
419, 419, 420, 419, 419, 419, 419, 420,
420, 420, 420, 420, 419, 419, 420, 419,
419, 420, 419, 420, 419, 419, 420, 419,
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
419, 419, 420, 420, 420, 420, 420, 420,
zclsyntax: permit dashes in identifiers While this does create some ambiguity with arithmetic on variables, like a-b, this is permitted by HCL and so we'll permit it for zcl too, at the expense of requiring spaces to be used around minus signs for correct interpretation.
2017-06-24 16:12:24 +00:00
419, 420, 420, 419, 420, 420, 419, 419,
419, 419, 419, 419, 420, 420, 419, 419,
420, 419, 420, 420, 420, 419, 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, 452, 419, 420,
419, 420, 419, 420, 420, 419, 420, 420,
419, 419, 419, 420, 419, 419, 419, 419,
419, 419, 419, 420, 419, 419, 419, 419,
419, 419, 419, 420, 420, 420, 420, 420,
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
420, 420, 420, 420, 420, 420, 419, 419,
419, 419, 419, 419, 419, 419, 420, 420,
420, 420, 420, 420, 420, 420, 420, 419,
zclsyntax: permit dashes in identifiers While this does create some ambiguity with arithmetic on variables, like a-b, this is permitted by HCL and so we'll permit it for zcl too, at the expense of requiring spaces to be used around minus signs for correct interpretation.
2017-06-24 16:12:24 +00:00
419, 419, 419, 419, 419, 419, 419, 420,
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
420, 420, 420, 420, 420, 420, 420, 420,
419, 420, 420, 420, 420, 420, 420, 420,
zclsyntax: permit dashes in identifiers While this does create some ambiguity with arithmetic on variables, like a-b, this is permitted by HCL and so we'll permit it for zcl too, at the expense of requiring spaces to be used around minus signs for correct interpretation.
2017-06-24 16:12:24 +00:00
420, 419, 420, 420, 420, 420, 420, 420,
420, 420, 420, 420, 420, 419, 420, 420,
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
420, 420, 420, 420, 419, 420, 420, 420,
zclsyntax: permit dashes in identifiers While this does create some ambiguity with arithmetic on variables, like a-b, this is permitted by HCL and so we'll permit it for zcl too, at the expense of requiring spaces to be used around minus signs for correct interpretation.
2017-06-24 16:12:24 +00:00
420, 420, 420, 419, 419, 419, 419, 419,
419, 419, 419, 420, 420, 420, 420, 420,
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
420, 420, 420, 419, 420, 420, 420, 420,
zclsyntax: permit dashes in identifiers While this does create some ambiguity with arithmetic on variables, like a-b, this is permitted by HCL and so we'll permit it for zcl too, at the expense of requiring spaces to be used around minus signs for correct interpretation.
2017-06-24 16:12:24 +00:00
420, 420, 420, 420, 419, 420, 420, 420,
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
420, 420, 419, 419, 419, 419, 419, 419,
419, 419, 420, 420, 420, 420, 420, 420,
419, 420, 420, 420, 420, 420, 420, 420,
zclsyntax: permit dashes in identifiers While this does create some ambiguity with arithmetic on variables, like a-b, this is permitted by HCL and so we'll permit it for zcl too, at the expense of requiring spaces to be used around minus signs for correct interpretation.
2017-06-24 16:12:24 +00:00
419, 420, 419, 420, 420, 419, 420, 420,
420, 420, 420, 420, 420, 420, 420, 420,
420, 420, 420, 419, 420, 420, 420, 420,
420, 419, 420, 420, 420, 420, 420, 420,
420, 419, 420, 420, 420, 419, 420, 420,
420, 419, 420, 419, 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, 488,
425, 489, 490, 491, 492, 493, 494, 425,
470, 425, 419, 420, 419, 420, 420, 419,
419, 420, 419, 419, 419, 419, 420, 419,
419, 419, 419, 419, 420, 419, 419, 419,
419, 419, 420, 420, 420, 420, 420, 419,
419, 419, 420, 419, 419, 419, 420, 420,
420, 419, 419, 419, 420, 420, 419, 419,
419, 420, 420, 420, 419, 419, 419, 420,
420, 420, 420, 419, 420, 420, 420, 420,
419, 419, 419, 419, 419, 420, 420, 420,
420, 419, 419, 420, 420, 420, 419, 419,
420, 420, 420, 420, 419, 420, 420, 419,
420, 420, 419, 419, 419, 420, 420, 420,
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
419, 419, 419, 419, 420, 420, 420, 420,
zclsyntax: permit dashes in identifiers While this does create some ambiguity with arithmetic on variables, like a-b, this is permitted by HCL and so we'll permit it for zcl too, at the expense of requiring spaces to be used around minus signs for correct interpretation.
2017-06-24 16:12:24 +00:00
420, 419, 419, 419, 419, 420, 419, 420,
420, 419, 420, 420, 419, 420, 419, 420,
420, 420, 419, 420, 420, 419, 419, 419,
420, 419, 419, 419, 419, 419, 419, 419,
420, 420, 420, 420, 419, 420, 420, 420,
420, 420, 420, 420, 419, 495, 496, 497,
498, 499, 500, 501, 502, 503, 425, 504,
505, 506, 507, 508, 419, 420, 419, 419,
419, 419, 419, 420, 420, 419, 420, 420,
420, 419, 420, 420, 420, 420, 420, 420,
420, 420, 420, 420, 419, 420, 420, 420,
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
419, 419, 420, 420, 420, 419, 419, 420,
zclsyntax: permit dashes in identifiers While this does create some ambiguity with arithmetic on variables, like a-b, this is permitted by HCL and so we'll permit it for zcl too, at the expense of requiring spaces to be used around minus signs for correct interpretation.
2017-06-24 16:12:24 +00:00
419, 419, 420, 420, 420, 420, 420, 419,
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
419, 419, 419, 420, 420, 420, 420, 420,
zclsyntax: permit dashes in identifiers While this does create some ambiguity with arithmetic on variables, like a-b, this is permitted by HCL and so we'll permit it for zcl too, at the expense of requiring spaces to be used around minus signs for correct interpretation.
2017-06-24 16:12:24 +00:00
420, 419, 420, 420, 420, 420, 420, 419,
509, 464, 510, 511, 512, 425, 513, 514,
470, 425, 419, 420, 420, 420, 420, 419,
419, 419, 420, 419, 419, 420, 420, 420,
419, 419, 419, 420, 420, 419, 475, 419,
470, 425, 425, 515, 419, 425, 419, 420,
470, 516, 517, 470, 518, 519, 470, 520,
521, 522, 523, 524, 525, 470, 526, 527,
528, 470, 529, 530, 531, 489, 532, 533,
534, 489, 535, 470, 425, 419, 419, 420,
420, 419, 419, 419, 420, 420, 420, 420,
419, 420, 420, 419, 419, 419, 419, 420,
420, 419, 419, 420, 420, 419, 419, 419,
419, 419, 419, 420, 420, 420, 419, 419,
419, 420, 419, 419, 419, 420, 420, 419,
420, 420, 420, 420, 419, 420, 420, 420,
420, 419, 420, 420, 420, 420, 420, 420,
419, 419, 419, 420, 420, 420, 420, 419,
536, 537, 419, 425, 419, 420, 419, 419,
420, 470, 538, 539, 540, 541, 520, 542,
543, 544, 545, 546, 547, 548, 549, 550,
551, 552, 553, 425, 419, 419, 420, 419,
420, 420, 420, 420, 420, 420, 420, 419,
420, 420, 420, 419, 420, 419, 419, 420,
419, 420, 419, 419, 420, 420, 420, 420,
419, 420, 420, 420, 419, 419, 420, 420,
420, 420, 419, 420, 420, 419, 419, 420,
420, 420, 420, 420, 419, 554, 555, 556,
557, 558, 559, 560, 561, 562, 563, 564,
560, 566, 567, 568, 569, 565, 419, 570,
571, 470, 572, 573, 574, 575, 576, 577,
578, 579, 580, 470, 425, 581, 582, 583,
584, 470, 585, 586, 587, 588, 589, 590,
591, 592, 593, 594, 595, 596, 597, 598,
599, 470, 501, 425, 600, 419, 420, 420,
420, 420, 420, 419, 419, 419, 420, 419,
420, 420, 419, 420, 419, 420, 420, 419,
419, 419, 420, 420, 420, 419, 419, 419,
420, 420, 420, 419, 419, 419, 419, 420,
419, 419, 420, 419, 419, 420, 420, 420,
419, 419, 420, 419, 420, 420, 420, 419,
420, 420, 420, 420, 420, 420, 419, 419,
419, 420, 420, 419, 420, 420, 419, 420,
420, 419, 420, 420, 419, 420, 420, 420,
420, 420, 420, 420, 419, 420, 419, 420,
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
419, 420, 420, 419, 420, 419, 420, 420,
zclsyntax: permit dashes in identifiers While this does create some ambiguity with arithmetic on variables, like a-b, this is permitted by HCL and so we'll permit it for zcl too, at the expense of requiring spaces to be used around minus signs for correct interpretation.
2017-06-24 16:12:24 +00:00
419, 420, 419, 420, 419, 601, 572, 602,
603, 604, 605, 606, 607, 608, 609, 610,
453, 611, 470, 612, 613, 614, 470, 615,
485, 616, 617, 618, 619, 620, 621, 622,
623, 470, 419, 419, 419, 420, 420, 420,
419, 420, 420, 419, 420, 420, 419, 419,
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
419, 419, 419, 420, 420, 420, 420, 419,
zclsyntax: permit dashes in identifiers While this does create some ambiguity with arithmetic on variables, like a-b, this is permitted by HCL and so we'll permit it for zcl too, at the expense of requiring spaces to be used around minus signs for correct interpretation.
2017-06-24 16:12:24 +00:00
420, 420, 420, 420, 420, 420, 419, 419,
419, 420, 420, 420, 420, 420, 420, 420,
420, 420, 419, 420, 420, 420, 420, 420,
420, 420, 420, 419, 420, 420, 419, 419,
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
419, 419, 420, 420, 420, 419, 419, 419,
420, 419, 419, 419, 420, 420, 419, 420,
zclsyntax: permit dashes in identifiers While this does create some ambiguity with arithmetic on variables, like a-b, this is permitted by HCL and so we'll permit it for zcl too, at the expense of requiring spaces to be used around minus signs for correct interpretation.
2017-06-24 16:12:24 +00:00
420, 420, 419, 420, 419, 419, 419, 420,
420, 419, 420, 420, 420, 419, 420, 420,
420, 419, 419, 419, 419, 420, 470, 539,
624, 625, 425, 470, 425, 419, 419, 420,
419, 420, 470, 624, 425, 419, 470, 626,
425, 419, 419, 420, 470, 627, 628, 629,
530, 630, 631, 470, 632, 633, 634, 425,
419, 419, 420, 420, 420, 419, 420, 420,
419, 420, 420, 420, 420, 419, 419, 420,
419, 419, 420, 420, 419, 420, 419, 470,
425, 419, 635, 470, 636, 419, 425, 419,
420, 419, 420, 637, 470, 638, 639, 419,
420, 419, 419, 419, 420, 420, 420, 420,
419, 640, 641, 642, 470, 643, 644, 645,
646, 647, 648, 649, 650, 651, 652, 653,
654, 655, 656, 425, 419, 420, 420, 420,
419, 419, 419, 419, 420, 420, 419, 419,
420, 419, 419, 419, 419, 419, 419, 419,
420, 419, 420, 419, 419, 419, 419, 419,
419, 420, 420, 420, 420, 420, 419, 419,
420, 419, 419, 419, 420, 419, 419, 420,
419, 419, 420, 419, 419, 420, 419, 419,
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
419, 420, 420, 420, 419, 419, 419, 420,
zclsyntax: permit dashes in identifiers While this does create some ambiguity with arithmetic on variables, like a-b, this is permitted by HCL and so we'll permit it for zcl too, at the expense of requiring spaces to be used around minus signs for correct interpretation.
2017-06-24 16:12:24 +00:00
420, 420, 420, 419, 657, 470, 658, 470,
659, 660, 661, 662, 425, 419, 420, 420,
420, 420, 420, 419, 419, 419, 420, 419,
419, 420, 420, 420, 420, 420, 420, 420,
420, 420, 420, 419, 420, 420, 420, 420,
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
420, 420, 420, 420, 420, 420, 420, 420,
zclsyntax: permit dashes in identifiers While this does create some ambiguity with arithmetic on variables, like a-b, this is permitted by HCL and so we'll permit it for zcl too, at the expense of requiring spaces to be used around minus signs for correct interpretation.
2017-06-24 16:12:24 +00:00
420, 420, 420, 420, 420, 420, 420, 419,
420, 420, 420, 420, 420, 419, 663, 470,
425, 419, 420, 664, 470, 455, 425, 419,
420, 665, 419, 425, 419, 420, 470, 666,
425, 419, 419, 420, 667, 419, 470, 668,
425, 419, 419, 420, 670, 669, 420, 420,
420, 420, 670, 669, 420, 670, 669, 670,
670, 420, 670, 669, 420, 670, 420, 670,
669, 420, 670, 420, 670, 420, 669, 670,
670, 670, 670, 670, 670, 670, 670, 669,
420, 420, 670, 670, 420, 670, 420, 670,
669, 670, 670, 670, 670, 670, 420, 670,
420, 670, 420, 670, 669, 670, 670, 420,
670, 420, 670, 669, 670, 670, 670, 670,
670, 420, 670, 420, 670, 669, 420, 420,
670, 420, 670, 669, 670, 670, 670, 420,
670, 420, 670, 420, 670, 420, 670, 669,
670, 420, 670, 420, 670, 669, 420, 670,
670, 670, 670, 420, 670, 420, 670, 420,
670, 420, 670, 420, 670, 420, 670, 669,
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
420, 670, 669, 670, 670, 670, 420, 670,
zclsyntax: permit dashes in identifiers While this does create some ambiguity with arithmetic on variables, like a-b, this is permitted by HCL and so we'll permit it for zcl too, at the expense of requiring spaces to be used around minus signs for correct interpretation.
2017-06-24 16:12:24 +00:00
420, 670, 669, 670, 420, 670, 420, 670,
669, 420, 670, 670, 670, 670, 420, 670,
420, 670, 669, 420, 670, 420, 670, 420,
670, 669, 670, 670, 420, 670, 420, 670,
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
669, 420, 670, 420, 670, 420, 670, 420,
zclsyntax: permit dashes in identifiers While this does create some ambiguity with arithmetic on variables, like a-b, this is permitted by HCL and so we'll permit it for zcl too, at the expense of requiring spaces to be used around minus signs for correct interpretation.
2017-06-24 16:12:24 +00:00
669, 670, 670, 670, 420, 670, 420, 670,
669, 420, 670, 669, 670, 670, 420, 670,
669, 670, 670, 670, 420, 670, 670, 670,
670, 670, 670, 420, 420, 670, 420, 670,
420, 670, 420, 670, 669, 670, 420, 670,
420, 670, 669, 420, 670, 669, 670, 420,
670, 669, 670, 420, 670, 669, 420, 420,
670, 669, 420, 670, 420, 670, 420, 670,
420, 670, 420, 670, 420, 669, 670, 670,
420, 670, 670, 670, 670, 420, 420, 670,
670, 670, 670, 670, 420, 670, 670, 670,
670, 670, 669, 420, 670, 670, 420, 670,
420, 669, 670, 670, 420, 670, 669, 420,
420, 670, 420, 669, 670, 670, 669, 420,
670, 420, 669, 670, 669, 420, 670, 420,
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
670, 420, 669, 670, 670, 669, 420, 670,
zclsyntax: permit dashes in identifiers While this does create some ambiguity with arithmetic on variables, like a-b, this is permitted by HCL and so we'll permit it for zcl too, at the expense of requiring spaces to be used around minus signs for correct interpretation.
2017-06-24 16:12:24 +00:00
420, 670, 420, 670, 669, 670, 420, 670,
420, 670, 669, 420, 670, 669, 420, 420,
670, 669, 670, 420, 669, 670, 669, 420,
670, 420, 670, 420, 669, 670, 669, 420,
420, 670, 669, 670, 420, 670, 420, 670,
669, 420, 670, 420, 669, 670, 669, 420,
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
420, 670, 420, 669, 670, 669, 420, 420,
zclsyntax: permit dashes in identifiers While this does create some ambiguity with arithmetic on variables, like a-b, this is permitted by HCL and so we'll permit it for zcl too, at the expense of requiring spaces to be used around minus signs for correct interpretation.
2017-06-24 16:12:24 +00:00
670, 669, 670, 420, 670, 669, 670, 420,
670, 669, 670, 420, 670, 420, 670, 420,
669, 670, 669, 420, 420, 670, 669, 670,
420, 670, 420, 670, 669, 420, 670, 669,
670, 670, 420, 670, 420, 670, 669, 669,
420, 669, 420, 670, 670, 420, 670, 670,
670, 670, 670, 670, 670, 669, 420, 670,
670, 670, 420, 669, 670, 670, 670, 420,
670, 420, 670, 420, 670, 420, 670, 420,
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
670, 669, 420, 420, 670, 669, 670, 420,
zclsyntax: permit dashes in identifiers While this does create some ambiguity with arithmetic on variables, like a-b, this is permitted by HCL and so we'll permit it for zcl too, at the expense of requiring spaces to be used around minus signs for correct interpretation.
2017-06-24 16:12:24 +00:00
670, 669, 420, 420, 670, 420, 420, 420,
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
670, 420, 670, 420, 670, 420, 670, 420,
zclsyntax: permit dashes in identifiers While this does create some ambiguity with arithmetic on variables, like a-b, this is permitted by HCL and so we'll permit it for zcl too, at the expense of requiring spaces to be used around minus signs for correct interpretation.
2017-06-24 16:12:24 +00:00
669, 420, 670, 420, 670, 420, 669, 670,
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
669, 420, 670, 420, 669, 670, 420, 670,
zclsyntax: permit dashes in identifiers While this does create some ambiguity with arithmetic on variables, like a-b, this is permitted by HCL and so we'll permit it for zcl too, at the expense of requiring spaces to be used around minus signs for correct interpretation.
2017-06-24 16:12:24 +00:00
670, 670, 669, 420, 670, 420, 420, 670,
420, 669, 670, 670, 669, 420, 670, 670,
670, 670, 420, 670, 420, 669, 670, 670,
670, 420, 670, 669, 670, 420, 670, 420,
670, 420, 670, 420, 670, 669, 670, 670,
420, 670, 669, 420, 670, 420, 670, 420,
669, 670, 670, 669, 420, 670, 420, 669,
670, 669, 420, 670, 669, 420, 670, 420,
670, 669, 670, 670, 670, 669, 420, 420,
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
420, 670, 669, 420, 670, 420, 669, 670,
zclsyntax: permit dashes in identifiers While this does create some ambiguity with arithmetic on variables, like a-b, this is permitted by HCL and so we'll permit it for zcl too, at the expense of requiring spaces to be used around minus signs for correct interpretation.
2017-06-24 16:12:24 +00:00
669, 420, 670, 420, 670, 420, 669, 670,
670, 670, 669, 420, 670, 420, 669, 670,
670, 670, 670, 669, 420, 670, 420, 670,
669, 420, 420, 670, 420, 670, 669, 670,
420, 670, 420, 669, 670, 670, 669, 420,
670, 420, 670, 669, 420, 670, 670, 670,
420, 670, 420, 669, 420, 670, 669, 670,
420, 420, 670, 420, 670, 420, 669, 670,
670, 670, 670, 669, 420, 670, 420, 670,
420, 670, 420, 670, 420, 670, 669, 670,
670, 670, 420, 670, 420, 670, 420, 670,
420, 669, 670, 670, 420, 420, 670, 669,
670, 420, 670, 670, 669, 420, 670, 420,
670, 669, 420, 420, 670, 670, 670, 670,
420, 670, 420, 670, 420, 669, 670, 670,
420, 669, 670, 669, 420, 670, 420, 669,
670, 669, 420, 670, 420, 669, 670, 420,
670, 670, 669, 420, 670, 670, 420, 669,
670, 669, 420, 670, 420, 670, 669, 670,
420, 670, 420, 669, 670, 669, 420, 670,
420, 670, 420, 670, 420, 670, 420, 670,
669, 671, 669, 672, 673, 674, 675, 676,
677, 678, 679, 680, 681, 682, 674, 683,
684, 685, 686, 687, 674, 688, 689, 690,
691, 692, 693, 694, 695, 696, 697, 698,
699, 700, 701, 702, 674, 703, 671, 683,
671, 704, 671, 669, 670, 670, 670, 670,
420, 669, 670, 670, 669, 420, 670, 669,
420, 420, 670, 669, 420, 670, 420, 669,
670, 669, 420, 420, 670, 420, 669, 670,
670, 669, 420, 670, 670, 670, 669, 420,
670, 420, 670, 670, 669, 420, 420, 670,
420, 669, 670, 669, 420, 670, 669, 420,
420, 670, 420, 670, 669, 420, 670, 420,
420, 670, 420, 670, 420, 669, 670, 670,
669, 420, 670, 670, 420, 670, 669, 420,
670, 420, 670, 669, 420, 670, 420, 669,
420, 670, 670, 670, 420, 670, 669, 670,
420, 670, 669, 420, 670, 669, 670, 420,
670, 669, 420, 670, 669, 420, 670, 420,
670, 669, 420, 670, 669, 420, 670, 669,
705, 706, 707, 708, 709, 710, 711, 712,
713, 714, 715, 716, 676, 717, 718, 719,
720, 721, 718, 722, 723, 724, 725, 726,
727, 728, 729, 730, 671, 669, 670, 420,
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
670, 669, 670, 420, 670, 669, 670, 420,
670, 669, 670, 420, 670, 669, 420, 670,
zclsyntax: permit dashes in identifiers While this does create some ambiguity with arithmetic on variables, like a-b, this is permitted by HCL and so we'll permit it for zcl too, at the expense of requiring spaces to be used around minus signs for correct interpretation.
2017-06-24 16:12:24 +00:00
420, 670, 669, 670, 420, 670, 669, 670,
420, 420, 420, 670, 669, 670, 420, 670,
669, 670, 670, 670, 670, 420, 670, 420,
669, 670, 669, 420, 420, 670, 420, 670,
669, 670, 420, 670, 669, 420, 670, 669,
670, 670, 420, 670, 669, 420, 670, 669,
670, 420, 670, 669, 420, 670, 669, 420,
670, 669, 420, 670, 669, 670, 669, 420,
420, 670, 669, 670, 420, 670, 669, 420,
670, 420, 669, 670, 669, 420, 674, 731,
671, 674, 732, 674, 733, 683, 671, 669,
670, 669, 420, 670, 669, 420, 674, 732,
683, 671, 669, 674, 734, 671, 683, 671,
669, 670, 669, 420, 674, 735, 692, 736,
718, 737, 730, 674, 738, 739, 740, 671,
683, 671, 669, 670, 669, 420, 670, 420,
670, 669, 420, 670, 420, 670, 420, 669,
670, 670, 669, 420, 670, 420, 670, 669,
420, 670, 669, 674, 683, 425, 669, 741,
674, 742, 683, 671, 669, 425, 670, 669,
420, 670, 669, 420, 743, 674, 744, 745,
671, 669, 420, 670, 669, 670, 670, 669,
420, 420, 670, 420, 670, 669, 674, 746,
747, 748, 749, 750, 751, 752, 753, 754,
755, 756, 671, 683, 671, 669, 670, 420,
670, 670, 670, 670, 670, 670, 670, 420,
670, 420, 670, 670, 670, 670, 670, 670,
669, 420, 670, 670, 420, 670, 420, 669,
670, 420, 670, 670, 670, 420, 670, 670,
420, 670, 670, 420, 670, 670, 420, 670,
670, 669, 420, 674, 757, 674, 733, 758,
759, 760, 671, 683, 671, 669, 670, 669,
420, 670, 670, 670, 420, 670, 670, 670,
420, 670, 420, 670, 669, 420, 420, 420,
420, 670, 670, 420, 420, 420, 420, 420,
670, 670, 670, 670, 670, 670, 670, 420,
670, 420, 670, 420, 669, 670, 670, 670,
420, 670, 420, 670, 669, 683, 425, 761,
674, 683, 425, 670, 669, 420, 762, 674,
763, 683, 425, 670, 669, 420, 670, 420,
764, 683, 671, 669, 425, 670, 669, 420,
674, 765, 671, 683, 671, 669, 670, 669,
420, 766, 767, 767, 766, 768, 766, 769,
766, 767, 770, 771, 770, 773, 772, 774,
775, 775, 772, 776, 772, 777, 774, 778,
775, 779, 775, 781, 780, 782, 783, 783,
780, 784, 780, 785, 782, 786, 783, 787,
783, 788, 789, 790, 791, 792, 793, 794,
795, 797, 798, 799, 800, 801, 670, 670,
670, 802, 803, 804, 805, 670, 808, 809,
811, 812, 813, 807, 814, 815, 816, 817,
818, 819, 820, 821, 822, 823, 824, 825,
826, 827, 828, 829, 830, 831, 832, 833,
835, 836, 837, 838, 839, 840, 670, 796,
10, 796, 420, 796, 420, 807, 810, 834,
841, 806, 788, 842, 789, 843, 791, 844,
846, 845, 2, 1, 847, 845, 848, 845,
5, 1, 845, 6, 5, 10, 851, 851,
10, 850, 852, 853, 845, 854, 855, 845,
856, 845, 420, 420, 858, 859, 489, 470,
860, 470, 861, 862, 863, 864, 865, 866,
867, 868, 869, 870, 871, 544, 872, 520,
873, 874, 875, 876, 877, 878, 879, 880,
881, 882, 883, 884, 420, 420, 420, 425,
565, 857, 885, 845, 886, 845, 670, 887,
420, 420, 420, 670, 887, 670, 670, 420,
887, 420, 887, 420, 887, 420, 670, 670,
670, 670, 670, 887, 420, 670, 670, 670,
420, 670, 420, 887, 420, 670, 670, 670,
670, 420, 887, 670, 420, 670, 420, 670,
420, 670, 670, 420, 670, 887, 420, 670,
420, 670, 420, 670, 887, 670, 420, 887,
670, 420, 670, 420, 887, 670, 670, 670,
670, 670, 887, 420, 420, 670, 420, 670,
887, 670, 420, 887, 670, 670, 887, 420,
420, 670, 420, 670, 420, 670, 887, 888,
889, 890, 891, 892, 893, 894, 895, 896,
897, 898, 715, 899, 900, 901, 902, 903,
904, 905, 906, 907, 908, 909, 910, 909,
911, 912, 913, 914, 915, 671, 887, 916,
917, 918, 919, 920, 921, 922, 923, 924,
925, 926, 927, 928, 929, 930, 931, 932,
933, 934, 725, 935, 936, 937, 692, 938,
939, 940, 941, 942, 943, 671, 944, 945,
946, 947, 948, 949, 950, 951, 674, 952,
671, 674, 953, 954, 955, 956, 683, 887,
957, 958, 959, 960, 703, 961, 962, 683,
963, 964, 965, 966, 967, 671, 887, 968,
927, 969, 970, 971, 683, 972, 973, 674,
671, 683, 425, 887, 937, 671, 674, 683,
425, 683, 425, 974, 683, 887, 425, 674,
975, 976, 674, 977, 978, 681, 979, 980,
981, 982, 983, 933, 984, 985, 986, 987,
988, 989, 990, 991, 992, 993, 994, 995,
952, 996, 674, 683, 425, 887, 997, 998,
683, 671, 887, 425, 671, 887, 674, 999,
731, 1000, 1001, 1002, 1003, 1004, 1005, 1006,
1007, 671, 1008, 1009, 1010, 1011, 1012, 1013,
671, 683, 887, 1015, 1016, 1017, 1018, 1019,
1020, 1021, 1022, 1023, 1024, 1025, 1021, 1027,
1028, 1029, 1030, 1014, 1026, 1014, 887, 1014,
887, 1031, 1031, 1032, 1033, 1034, 1035, 1036,
1037, 1038, 1039, 1036, 767, 1040, 1040, 1040,
1035, 1041, 1040, 768, 769, 1042, 1040, 767,
1040, 1040, 1035, 1043, 1040, 768, 769, 1042,
1040, 767, 1035, 1043, 1044, 1045, 1046, 767,
zclsyntax: change template control sequence introducer to %{ Previously it was !{, but in real examples this looked confusing since an exclamation point after a word looks (to humans) like literal punctuation rather than syntax. % is not ideal either since it's also the marker traditionally used for printf, but has the advantage that programmers are already primed for it to be syntax.
2017-06-18 01:33:56 +00:00
1040, 1040, 1040, 1035, 1041, 768, 769, 1042,
zclsyntax: permit dashes in identifiers While this does create some ambiguity with arithmetic on variables, like a-b, this is permitted by HCL and so we'll permit it for zcl too, at the expense of requiring spaces to be used around minus signs for correct interpretation.
2017-06-24 16:12:24 +00:00
1040, 767, 1040, 1040, 1040, 1035, 1041, 768,
769, 1042, 1040, 767, 1040, 1040, 1040, 1035,
1041, 769, 768, 769, 1042, 1040, 767, 1048,
767, 1050, 1049, 1051, 767, 1053, 1052, 767,
1054, 771, 1054, 1055, 1054, 773, 1056, 1057,
1058, 1059, 1060, 1061, 1062, 1059, 775, 773,
1056, 1064, 1063, 776, 777, 1065, 1063, 775,
1067, 1066, 1069, 1068, 775, 1070, 776, 1070,
777, 1070, 781, 1071, 1072, 1073, 1074, 1075,
1076, 1077, 1074, 783, 781, 1071, 1079, 1078,
784, 785, 1080, 1078, 783, 1082, 1081, 1084,
1083, 783, 1085, 784, 1085, 785, 1085,
zclsyntax: identifiers in the scanner
2017-05-28 16:16:53 +00:00
}
var _zcltok_trans_targs []int16 = []int16{
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
948, 1, 948, 948, 948, 3, 4, 957,
948, 6, 958, 8, 9, 286, 12, 13,
14, 15, 16, 287, 288, 19, 289, 21,
22, 290, 291, 292, 293, 294, 295, 296,
297, 298, 299, 328, 348, 353, 127, 128,
129, 356, 151, 371, 375, 948, 10, 11,
17, 18, 20, 23, 24, 25, 26, 27,
28, 29, 30, 31, 32, 64, 105, 120,
131, 154, 170, 283, 33, 34, 35, 36,
zclsyntax: scanning of comments
2017-05-29 16:13:35 +00:00
37, 38, 39, 40, 41, 42, 43, 44,
45, 46, 47, 48, 49, 50, 51, 52,
53, 54, 55, 56, 57, 58, 59, 60,
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
61, 62, 63, 65, 66, 67, 68, 69,
zclsyntax: scanning of comments
2017-05-29 16:13:35 +00:00
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,
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
102, 103, 104, 106, 107, 108, 109, 110,
zclsyntax: scanning of comments
2017-05-29 16:13:35 +00:00
111, 112, 113, 114, 115, 116, 117, 118,
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
119, 121, 122, 123, 124, 125, 126, 130,
zclsyntax: scanning of comments
2017-05-29 16:13:35 +00:00
132, 133, 134, 135, 136, 137, 138, 139,
140, 141, 142, 143, 144, 145, 146, 147,
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
148, 149, 150, 152, 153, 155, 156, 157,
zclsyntax: scanning of comments
2017-05-29 16:13:35 +00:00
158, 159, 160, 161, 162, 163, 164, 165,
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
166, 167, 168, 169, 171, 203, 227, 230,
231, 233, 242, 243, 246, 250, 268, 275,
277, 279, 281, 172, 173, 174, 175, 176,
zclsyntax: scanning of comments
2017-05-29 16:13:35 +00:00
177, 178, 179, 180, 181, 182, 183, 184,
185, 186, 187, 188, 189, 190, 191, 192,
193, 194, 195, 196, 197, 198, 199, 200,
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
201, 202, 204, 205, 206, 207, 208, 209,
zclsyntax: scanning of comments
2017-05-29 16:13:35 +00:00
210, 211, 212, 213, 214, 215, 216, 217,
218, 219, 220, 221, 222, 223, 224, 225,
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
226, 228, 229, 232, 234, 235, 236, 237,
238, 239, 240, 241, 244, 245, 247, 248,
249, 251, 252, 253, 254, 255, 256, 257,
zclsyntax: scanning of comments
2017-05-29 16:13:35 +00:00
258, 259, 260, 261, 262, 263, 264, 265,
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
266, 267, 269, 270, 271, 272, 273, 274,
276, 278, 280, 282, 284, 285, 300, 301,
zclsyntax: scanning of comments
2017-05-29 16:13:35 +00:00
302, 303, 304, 305, 306, 307, 308, 309,
310, 311, 312, 313, 314, 315, 316, 317,
318, 319, 320, 321, 322, 323, 324, 325,
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
326, 327, 329, 330, 331, 332, 333, 334,
zclsyntax: scanning of comments
2017-05-29 16:13:35 +00:00
335, 336, 337, 338, 339, 340, 341, 342,
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
343, 344, 345, 346, 347, 349, 350, 351,
352, 354, 355, 357, 358, 359, 360, 361,
zclsyntax: scanning of comments
2017-05-29 16:13:35 +00:00
362, 363, 364, 365, 366, 367, 368, 369,
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
370, 372, 373, 374, 376, 382, 404, 409,
411, 413, 377, 378, 379, 380, 381, 383,
zclsyntax: scanning of comments
2017-05-29 16:13:35 +00:00
384, 385, 386, 387, 388, 389, 390, 391,
392, 393, 394, 395, 396, 397, 398, 399,
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
400, 401, 402, 403, 405, 406, 407, 408,
410, 412, 414, 948, 962, 437, 438, 439,
440, 417, 441, 442, 443, 444, 445, 446,
zclsyntax: scanning of comments
2017-05-29 16:13:35 +00:00
447, 448, 449, 450, 451, 452, 453, 454,
455, 456, 457, 458, 459, 460, 461, 462,
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
463, 464, 465, 466, 467, 469, 470, 471,
zclsyntax: scanning of comments
2017-05-29 16:13:35 +00:00
472, 473, 474, 475, 476, 477, 478, 479,
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
480, 481, 482, 483, 484, 485, 419, 486,
zclsyntax: scanning of comments
2017-05-29 16:13:35 +00:00
487, 488, 489, 490, 491, 492, 493, 494,
495, 496, 497, 498, 499, 500, 501, 502,
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
503, 418, 504, 505, 506, 507, 508, 510,
zclsyntax: scanning of comments
2017-05-29 16:13:35 +00:00
511, 512, 513, 514, 515, 516, 517, 518,
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
519, 520, 521, 522, 523, 525, 526, 527,
528, 529, 530, 534, 536, 537, 538, 539,
434, 540, 541, 542, 543, 544, 545, 546,
547, 548, 549, 550, 551, 552, 553, 554,
556, 557, 559, 560, 561, 562, 563, 564,
432, 565, 566, 567, 568, 569, 570, 571,
572, 573, 575, 607, 631, 634, 635, 637,
646, 647, 650, 654, 672, 532, 679, 681,
683, 685, 576, 577, 578, 579, 580, 581,
zclsyntax: scanning of comments
2017-05-29 16:13:35 +00:00
582, 583, 584, 585, 586, 587, 588, 589,
590, 591, 592, 593, 594, 595, 596, 597,
598, 599, 600, 601, 602, 603, 604, 605,
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
606, 608, 609, 610, 611, 612, 613, 614,
zclsyntax: scanning of comments
2017-05-29 16:13:35 +00:00
615, 616, 617, 618, 619, 620, 621, 622,
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
623, 624, 625, 626, 627, 628, 629, 630,
632, 633, 636, 638, 639, 640, 641, 642,
643, 644, 645, 648, 649, 651, 652, 653,
zclsyntax: scanning of comments
2017-05-29 16:13:35 +00:00
655, 656, 657, 658, 659, 660, 661, 662,
663, 664, 665, 666, 667, 668, 669, 670,
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
671, 673, 674, 675, 676, 677, 678, 680,
682, 684, 686, 688, 689, 948, 948, 690,
827, 828, 759, 829, 830, 831, 832, 833,
834, 788, 835, 724, 836, 837, 838, 839,
840, 841, 842, 843, 744, 844, 845, 846,
847, 848, 849, 850, 851, 852, 853, 769,
854, 856, 857, 858, 859, 860, 861, 862,
863, 864, 865, 702, 866, 867, 868, 869,
870, 871, 872, 873, 874, 740, 875, 876,
877, 878, 879, 810, 881, 882, 885, 887,
888, 889, 890, 891, 892, 895, 896, 898,
899, 900, 902, 903, 904, 905, 906, 907,
908, 909, 910, 911, 912, 914, 915, 916,
917, 920, 922, 923, 925, 927, 1000, 1001,
929, 930, 1000, 932, 1014, 1014, 1014, 1015,
936, 937, 1016, 1017, 1021, 1021, 1021, 1022,
943, 944, 1023, 1024, 949, 948, 950, 951,
952, 948, 953, 954, 948, 955, 956, 959,
960, 961, 948, 963, 948, 964, 948, 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,
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
998, 999, 948, 948, 948, 948, 948, 948,
2, 948, 948, 5, 7, 948, 948, 948,
948, 948, 415, 416, 420, 421, 422, 423,
424, 425, 426, 427, 428, 429, 430, 431,
433, 435, 436, 468, 509, 524, 531, 533,
535, 555, 558, 574, 687, 948, 948, 948,
691, 692, 693, 694, 695, 696, 697, 698,
699, 700, 701, 703, 704, 705, 706, 707,
708, 709, 710, 711, 712, 713, 714, 715,
716, 717, 718, 719, 720, 721, 722, 723,
725, 726, 727, 728, 729, 730, 731, 732,
733, 734, 735, 736, 737, 738, 739, 741,
742, 743, 745, 746, 747, 748, 749, 750,
751, 752, 753, 754, 755, 756, 757, 758,
760, 761, 762, 763, 764, 765, 766, 767,
768, 770, 771, 772, 773, 774, 775, 776,
777, 778, 779, 780, 781, 782, 783, 784,
785, 786, 787, 789, 790, 791, 792, 793,
794, 795, 796, 797, 798, 799, 800, 801,
802, 803, 804, 805, 806, 807, 808, 809,
811, 812, 813, 814, 815, 816, 817, 818,
819, 820, 821, 822, 823, 824, 825, 826,
855, 880, 883, 884, 886, 893, 894, 897,
901, 913, 918, 919, 921, 924, 926, 1000,
zclsyntax: change template control sequence introducer to %{ Previously it was !{, but in real examples this looked confusing since an exclamation point after a word looks (to humans) like literal punctuation rather than syntax. % is not ideal either since it's also the marker traditionally used for printf, but has the advantage that programmers are already primed for it to be syntax.
2017-06-18 01:33:56 +00:00
1000, 1007, 1009, 1002, 1000, 1011, 1012, 1013,
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
1000, 928, 931, 1003, 1004, 1005, 1006, 1000,
1008, 1000, 1000, 1010, 1000, 1000, 1000, 933,
934, 939, 940, 1014, 1018, 1019, 1020, 1014,
935, 938, 1014, 1014, 1014, 1014, 1014, 941,
946, 947, 1021, 1025, 1026, 1027, 1021, 942,
945, 1021, 1021, 1021, 1021, 1021,
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{
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
131, 0, 71, 127, 87, 0, 0, 151,
123, 0, 5, 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,
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
0, 0, 0, 0, 0, 101, 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,
0, 0, 0, 0, 0, 0, 0, 0,
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
0, 0, 0, 125, 148, 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,
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,
0, 0, 0, 0, 0, 0, 0, 0,
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
0, 0, 0, 0, 0, 129, 105, 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,
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: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
0, 0, 0, 0, 0, 0, 27, 5,
0, 0, 29, 0, 49, 35, 47, 136,
0, 0, 0, 0, 69, 55, 67, 142,
0, 0, 0, 0, 0, 73, 0, 0,
0, 99, 160, 0, 91, 5, 154, 5,
0, 0, 93, 0, 95, 0, 103, 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,
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
0, 0, 0, 0, 0, 5, 5, 5,
157, 157, 157, 157, 157, 157, 5, 5,
157, 5, 117, 121, 107, 115, 77, 83,
0, 113, 109, 0, 0, 81, 75, 89,
79, 111, 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,
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
0, 0, 0, 0, 0, 85, 97, 119,
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: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
0, 0, 0, 0, 0, 0, 0, 13,
zclsyntax: change template control sequence introducer to %{ Previously it was !{, but in real examples this looked confusing since an exclamation point after a word looks (to humans) like literal punctuation rather than syntax. % is not ideal either since it's also the marker traditionally used for printf, but has the advantage that programmers are already primed for it to be syntax.
2017-06-18 01:33:56 +00:00
11, 0, 0, 5, 15, 0, 5, 5,
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
21, 0, 0, 0, 5, 5, 5, 23,
zclsyntax: change template control sequence introducer to %{ Previously it was !{, but in real examples this looked confusing since an exclamation point after a word looks (to humans) like literal punctuation rather than syntax. % is not ideal either since it's also the marker traditionally used for printf, but has the advantage that programmers are already primed for it to be syntax.
2017-06-18 01:33:56 +00:00
0, 17, 7, 0, 19, 9, 25, 0,
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
0, 0, 0, 37, 0, 139, 139, 43,
zclsyntax: change template control sequence introducer to %{ Previously it was !{, but in real examples this looked confusing since an exclamation point after a word looks (to humans) like literal punctuation rather than syntax. % is not ideal either since it's also the marker traditionally used for printf, but has the advantage that programmers are already primed for it to be syntax.
2017-06-18 01:33:56 +00:00
0, 0, 39, 31, 41, 33, 45, 0,
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
0, 0, 57, 0, 145, 145, 63, 0,
zclsyntax: change template control sequence introducer to %{ Previously it was !{, but in real examples this looked confusing since an exclamation point after a word looks (to humans) like literal punctuation rather than syntax. % is not ideal either since it's also the marker traditionally used for printf, but has the advantage that programmers are already primed for it to be syntax.
2017-06-18 01:33:56 +00:00
0, 59, 51, 61, 53, 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: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
0, 0, 0, 0, 1, 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: 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,
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
1, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 133, 0,
0, 0, 0, 0, 0, 133, 0, 0,
0, 0, 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,
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
0, 0, 0, 0, 3, 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: scanning of comments
2017-05-29 16:13:35 +00:00
0, 0, 0, 0, 0, 0, 0, 0,
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
3, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 3, 0,
0, 0, 0, 0, 0, 3, 0, 0,
0, 0, 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: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
0, 1, 4, 1, 1, 9, 9, 4,
4, 4, 4, 4, 4, 4, 4, 4,
4, 4, 4, 4, 4, 4, 4, 4,
4, 4, 4, 4, 4, 4, 4, 4,
4, 4, 4, 4, 4, 4, 4, 4,
4, 4, 4, 4, 4, 4, 4, 4,
4, 4, 4, 4, 4, 4, 4, 4,
4, 4, 4, 4, 4, 4, 4, 4,
4, 4, 4, 4, 4, 4, 4, 4,
4, 4, 4, 4, 4, 4, 4, 4,
4, 4, 4, 4, 4, 4, 4, 4,
4, 4, 4, 4, 4, 4, 4, 4,
4, 4, 4, 4, 4, 4, 4, 4,
4, 4, 4, 4, 4, 4, 4, 4,
4, 4, 4, 4, 4, 4, 4, 4,
4, 4, 4, 4, 4, 4, 4, 4,
4, 4, 4, 4, 4, 4, 4, 4,
4, 4, 4, 4, 4, 4, 4, 4,
4, 4, 4, 4, 4, 4, 4, 4,
4, 4, 4, 4, 4, 4, 4, 4,
4, 4, 4, 4, 4, 4, 4, 4,
4, 4, 4, 4, 4, 4, 4, 4,
4, 4, 4, 4, 4, 4, 4, 4,
4, 4, 4, 4, 4, 4, 4, 4,
4, 4, 4, 4, 4, 4, 4, 4,
4, 4, 4, 4, 4, 4, 4, 4,
4, 4, 4, 4, 4, 4, 4, 4,
4, 4, 4, 4, 4, 4, 4, 4,
4, 4, 4, 4, 4, 4, 4, 4,
4, 4, 4, 4, 4, 4, 4, 4,
4, 4, 4, 4, 4, 4, 4, 4,
4, 4, 4, 4, 4, 4, 4, 4,
4, 4, 4, 4, 4, 4, 4, 4,
4, 4, 4, 4, 4, 4, 4, 4,
4, 4, 4, 4, 4, 4, 4, 4,
4, 4, 4, 4, 4, 4, 4, 4,
4, 4, 4, 4, 4, 4, 4, 4,
4, 4, 4, 4, 4, 4, 4, 4,
4, 4, 4, 4, 4, 4, 4, 4,
4, 4, 4, 4, 4, 4, 4, 4,
4, 4, 4, 4, 4, 4, 4, 4,
4, 4, 4, 4, 4, 4, 4, 4,
4, 4, 4, 4, 4, 4, 4, 4,
4, 4, 4, 4, 4, 4, 4, 4,
4, 4, 4, 4, 4, 4, 4, 4,
4, 4, 4, 4, 4, 4, 4, 4,
4, 4, 4, 4, 4, 4, 4, 4,
4, 4, 4, 4, 4, 4, 4, 4,
4, 4, 4, 4, 4, 4, 4, 4,
4, 4, 4, 4, 4, 4, 4, 4,
4, 4, 4, 4, 4, 4, 4, 4,
4, 4, 4, 4, 4, 4, 4, 420,
420, 1, 420, 420, 420, 420, 420, 420,
420, 420, 420, 420, 420, 420, 420, 420,
420, 420, 420, 420, 420, 420, 420, 420,
420, 420, 420, 420, 420, 420, 420, 420,
420, 420, 420, 420, 420, 420, 420, 420,
420, 420, 420, 420, 420, 420, 420, 420,
420, 420, 420, 420, 420, 420, 420, 420,
420, 420, 420, 420, 420, 420, 420, 420,
420, 420, 420, 420, 420, 420, 420, 420,
420, 420, 420, 420, 420, 420, 420, 420,
420, 420, 420, 420, 420, 420, 420, 420,
420, 420, 420, 420, 420, 420, 420, 420,
420, 420, 420, 420, 420, 420, 420, 420,
420, 420, 420, 420, 420, 420, 420, 420,
420, 420, 420, 420, 420, 420, 420, 420,
420, 420, 420, 420, 420, 420, 420, 420,
420, 420, 420, 420, 420, 420, 420, 420,
420, 420, 420, 420, 420, 420, 420, 420,
420, 420, 420, 420, 420, 420, 420, 420,
420, 420, 420, 420, 420, 420, 420, 420,
420, 420, 420, 420, 420, 420, 420, 420,
420, 420, 420, 420, 420, 420, 420, 420,
420, 420, 420, 420, 420, 420, 420, 420,
420, 420, 420, 420, 420, 420, 420, 420,
420, 420, 420, 420, 420, 420, 420, 420,
420, 420, 420, 420, 420, 420, 420, 420,
420, 420, 420, 420, 420, 420, 420, 420,
420, 420, 420, 420, 420, 420, 420, 420,
420, 420, 420, 420, 420, 420, 420, 420,
420, 420, 420, 420, 420, 420, 420, 420,
420, 420, 420, 420, 420, 420, 420, 420,
420, 420, 420, 420, 420, 420, 420, 420,
420, 420, 420, 420, 420, 420, 420, 420,
420, 420, 420, 420, 420, 420, 420, 420,
420, 420, 670, 670, 670, 670, 670, 670,
670, 670, 670, 670, 670, 670, 670, 670,
670, 670, 670, 670, 670, 670, 670, 670,
670, 670, 670, 670, 670, 670, 670, 670,
670, 670, 670, 670, 670, 670, 670, 670,
670, 670, 670, 670, 670, 670, 670, 670,
670, 670, 670, 670, 670, 670, 670, 670,
670, 670, 670, 670, 670, 670, 670, 670,
670, 670, 670, 670, 670, 670, 670, 670,
670, 670, 670, 670, 670, 670, 670, 670,
670, 670, 670, 670, 670, 670, 670, 670,
670, 670, 670, 670, 670, 670, 670, 670,
670, 670, 670, 670, 670, 670, 670, 670,
670, 670, 670, 670, 670, 670, 670, 670,
670, 670, 670, 670, 670, 670, 670, 670,
670, 670, 670, 670, 670, 670, 670, 670,
670, 670, 670, 670, 670, 670, 670, 670,
670, 670, 670, 670, 670, 670, 670, 670,
670, 670, 670, 670, 670, 670, 670, 670,
670, 670, 670, 670, 670, 670, 670, 670,
670, 670, 670, 670, 670, 670, 670, 670,
670, 670, 670, 670, 670, 670, 670, 670,
670, 670, 670, 670, 670, 670, 670, 670,
670, 670, 670, 670, 670, 670, 670, 670,
670, 670, 670, 670, 670, 670, 670, 670,
670, 670, 670, 670, 670, 670, 670, 670,
670, 670, 670, 670, 670, 670, 670, 670,
670, 670, 670, 670, 670, 670, 670, 670,
670, 670, 670, 670, 670, 670, 670, 670,
670, 670, 670, 670, 670, 670, 670, 670,
767, 767, 767, 767, 771, 771, 773, 775,
773, 773, 775, 0, 0, 781, 783, 781,
781, 783, 0, 0, 0, 843, 844, 845,
846, 844, 846, 846, 846, 850, 851, 846,
846, 846, 858, 846, 846, 888, 888, 888,
888, 888, 888, 888, 888, 888, 888, 888,
888, 888, 888, 888, 888, 888, 888, 888,
888, 888, 888, 888, 888, 888, 888, 888,
888, 888, 888, 888, 888, 888, 888, 888,
0, 1041, 1041, 1041, 1041, 1041, 1041, 1048,
1050, 1048, 1053, 1055, 1055, 1055, 0, 1064,
1067, 1069, 1071, 1071, 1071, 0, 1079, 1082,
1084, 1086, 1086, 1086,
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: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
const zcltok_start int = 948
const zcltok_first_final int = 948
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: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
const zcltok_en_stringTemplate int = 1000
const zcltok_en_heredocTemplate int = 1014
const zcltok_en_bareTemplate int = 1021
const zcltok_en_main int = 948
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: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
// line 271 "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: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
// line 304 "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: change template control sequence introducer to %{ Previously it was !{, but in real examples this looked confusing since an exclamation point after a word looks (to humans) like literal punctuation rather than syntax. % is not ideal either since it's also the marker traditionally used for printf, but has the advantage that programmers are already primed for it to be syntax.
2017-06-18 01:33:56 +00:00
// line 2814 "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: change template control sequence introducer to %{ Previously it was !{, but in real examples this looked confusing since an exclamation point after a word looks (to humans) like literal punctuation rather than syntax. % is not ideal either since it's also the marker traditionally used for printf, but has the advantage that programmers are already primed for it to be syntax.
2017-06-18 01:33:56 +00:00
// line 2822 "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: change template control sequence introducer to %{ Previously it was !{, but in real examples this looked confusing since an exclamation point after a word looks (to humans) like literal punctuation rather than syntax. % is not ideal either since it's also the marker traditionally used for printf, but has the advantage that programmers are already primed for it to be syntax.
2017-06-18 01:33:56 +00:00
// line 2846 "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: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
// line 137 "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: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
cs = 948
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: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
// line 147 "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: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
cs = 948
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: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
// line 79 "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: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
// line 221 "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: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
// line 222 "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: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
// line 137 "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: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
cs = 948
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: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
// line 147 "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: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
cs = 948
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: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
// line 220 "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: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
// line 221 "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: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
// line 222 "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: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
// line 220 "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: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
// line 222 "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: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
// line 125 "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: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
// line 230 "scan_tokens.rl"
zclsyntax: heredoc support in the scanner
2017-05-29 15:55:53 +00:00
act = 11
case 18:
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
// line 137 "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: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
cs = 948
zclsyntax: heredoc support in the scanner
2017-05-29 15:55:53 +00:00
goto _again
}
}
case 19:
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
// line 147 "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: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
cs = 948
zclsyntax: heredoc support in the scanner
2017-05-29 15:55:53 +00:00
goto _again
}
}
case 20:
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
// line 106 "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: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
// line 230 "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: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
// line 137 "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: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
cs = 948
zclsyntax: heredoc support in the scanner
2017-05-29 15:55:53 +00:00
goto _again
}
}
case 23:
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
// line 147 "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: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
cs = 948
zclsyntax: heredoc support in the scanner
2017-05-29 15:55:53 +00:00
goto _again
}
}
case 24:
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
// line 125 "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: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
// line 230 "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: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
// line 125 "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: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
// line 133 "scan_tokens.rl"
zclsyntax: heredoc support in the scanner
2017-05-29 15:55:53 +00:00
act = 14
case 29:
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
// line 237 "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: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
// line 137 "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++
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
cs = 948
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
goto _again
}
}
zclsyntax: scanning of comments
2017-05-29 16:13:35 +00:00
case 31:
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
// line 147 "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++
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
cs = 948
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
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: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
// line 133 "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: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
// line 237 "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: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
// line 137 "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++
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
cs = 948
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
goto _again
}
}
case 35:
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
// line 147 "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++
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
cs = 948
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
goto _again
}
}
case 36:
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
// line 133 "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: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
// line 237 "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: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
// line 133 "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: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +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
act = 18
case 41:
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
// line 245 "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: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
// line 256 "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: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
act = 29
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: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
// line 267 "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: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
act = 36
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: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
// line 268 "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: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
act = 37
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:
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
// line 245 "scan_tokens.rl"
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
te = p + 1
{
token(TokenComment)
}
case 46:
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
// line 246 "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: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
// line 248 "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: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
// line 249 "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: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
// line 250 "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: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
// line 251 "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: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
// line 252 "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: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
// line 253 "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: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
// line 254 "scan_tokens.rl"
zclsyntax: separate tokens for assign = and equality test ==
2017-06-04 23:00:40 +00:00
te = p + 1
{
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
token(TokenEllipsis)
zclsyntax: separate tokens for assign = and equality test ==
2017-06-04 23:00:40 +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 54:
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
// line 255 "scan_tokens.rl"
te = p + 1
{
token(TokenFatArrow)
}
case 55:
// line 256 "scan_tokens.rl"
te = p + 1
{
selfToken()
}
case 56:
// line 157 "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++
}
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
case 57:
// line 162 "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--
}
}
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
case 58:
// line 174 "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
}
}
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
case 59:
// line 74 "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: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
cs = 1000
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: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
case 60:
// line 84 "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: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
cs = 1014
zclsyntax: heredoc support in the scanner
2017-05-29 15:55:53 +00:00
goto _again
}
}
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
case 61:
// line 267 "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
}
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
case 62:
// line 268 "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
}
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
case 63:
// line 241 "scan_tokens.rl"
zclsyntax: re-organize and simplify the scanner
2017-05-28 15:38:13 +00:00
te = p
p--
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
case 64:
// line 242 "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
}
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
case 65:
// line 243 "scan_tokens.rl"
zclsyntax: identifiers in the scanner
2017-05-28 16:16:53 +00:00
te = p
p--
{
token(TokenIdent)
}
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
case 66:
// line 245 "scan_tokens.rl"
zclsyntax: scanning of comments
2017-05-29 16:13:35 +00:00
te = p
p--
{
token(TokenComment)
}
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
case 67:
// line 256 "scan_tokens.rl"
zclsyntax: scan multi-character punctuation tokens
2017-05-28 16:40:58 +00:00
te = p
p--
{
selfToken()
}
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
case 68:
// line 266 "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
}
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
case 69:
// line 267 "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
}
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
case 70:
// line 268 "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
}
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
case 71:
// line 242 "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)
}
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
case 72:
// line 243 "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)
}
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
case 73:
// line 256 "scan_tokens.rl"
zclsyntax: heredoc support in the scanner
2017-05-29 15:55:53 +00:00
p = (te) - 1
{
selfToken()
}
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
case 74:
// line 267 "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
}
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
case 75:
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: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
case 29:
zclsyntax: scanning of comments
2017-05-29 16:13:35 +00:00
{
p = (te) - 1
selfToken()
}
zclsyntax: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
case 36:
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: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
case 37:
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
}
}
zclsyntax: change template control sequence introducer to %{ Previously it was !{, but in real examples this looked confusing since an exclamation point after a word looks (to humans) like literal punctuation rather than syntax. % is not ideal either since it's also the marker traditionally used for printf, but has the advantage that programmers are already primed for it to be syntax.
2017-06-18 01:33:56 +00:00
// line 3590 "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
zclsyntax: change template control sequence introducer to %{ Previously it was !{, but in real examples this looked confusing since an exclamation point after a word looks (to humans) like literal punctuation rather than syntax. % is not ideal either since it's also the marker traditionally used for printf, but has the advantage that programmers are already primed for it to be syntax.
2017-06-18 01:33:56 +00:00
// line 3610 "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: Ellipsis and "fat arrow" tokens These will be used in the "for" expression, and later ellipsis will also be used within calls to expand tuples as args.
2017-06-13 15:50:20 +00:00
// line 327 "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