diff options
author | Nathan Dench <ndenc2@gmail.com> | 2019-05-24 15:16:44 +1000 |
---|---|---|
committer | Nathan Dench <ndenc2@gmail.com> | 2019-05-24 15:16:44 +1000 |
commit | 107c1cdb09c575aa2f61d97f48d8587eb6bada4c (patch) | |
tree | ca7d008643efc555c388baeaf1d986e0b6b3e28c /vendor/github.com/hashicorp/hcl2 | |
parent | 844b5a68d8af4791755b8f0ad293cc99f5959183 (diff) | |
download | terraform-provider-statuscake-107c1cdb09c575aa2f61d97f48d8587eb6bada4c.tar.gz terraform-provider-statuscake-107c1cdb09c575aa2f61d97f48d8587eb6bada4c.tar.zst terraform-provider-statuscake-107c1cdb09c575aa2f61d97f48d8587eb6bada4c.zip |
Upgrade to 0.12
Diffstat (limited to 'vendor/github.com/hashicorp/hcl2')
66 files changed, 9660 insertions, 3905 deletions
diff --git a/vendor/github.com/hashicorp/hcl2/ext/dynblock/README.md b/vendor/github.com/hashicorp/hcl2/ext/dynblock/README.md new file mode 100644 index 0000000..2b24fdb --- /dev/null +++ b/vendor/github.com/hashicorp/hcl2/ext/dynblock/README.md | |||
@@ -0,0 +1,184 @@ | |||
1 | # HCL Dynamic Blocks Extension | ||
2 | |||
3 | This HCL extension implements a special block type named "dynamic" that can | ||
4 | be used to dynamically generate blocks of other types by iterating over | ||
5 | collection values. | ||
6 | |||
7 | Normally the block structure in an HCL configuration file is rigid, even | ||
8 | though dynamic expressions can be used within attribute values. This is | ||
9 | convenient for most applications since it allows the overall structure of | ||
10 | the document to be decoded easily, but in some applications it is desirable | ||
11 | to allow dynamic block generation within certain portions of the configuration. | ||
12 | |||
13 | Dynamic block generation is performed using the `dynamic` block type: | ||
14 | |||
15 | ```hcl | ||
16 | toplevel { | ||
17 | nested { | ||
18 | foo = "static block 1" | ||
19 | } | ||
20 | |||
21 | dynamic "nested" { | ||
22 | for_each = ["a", "b", "c"] | ||
23 | iterator = nested | ||
24 | content { | ||
25 | foo = "dynamic block ${nested.value}" | ||
26 | } | ||
27 | } | ||
28 | |||
29 | nested { | ||
30 | foo = "static block 2" | ||
31 | } | ||
32 | } | ||
33 | ``` | ||
34 | |||
35 | The above is interpreted as if it were written as follows: | ||
36 | |||
37 | ```hcl | ||
38 | toplevel { | ||
39 | nested { | ||
40 | foo = "static block 1" | ||
41 | } | ||
42 | |||
43 | nested { | ||
44 | foo = "dynamic block a" | ||
45 | } | ||
46 | |||
47 | nested { | ||
48 | foo = "dynamic block b" | ||
49 | } | ||
50 | |||
51 | nested { | ||
52 | foo = "dynamic block c" | ||
53 | } | ||
54 | |||
55 | nested { | ||
56 | foo = "static block 2" | ||
57 | } | ||
58 | } | ||
59 | ``` | ||
60 | |||
61 | Since HCL block syntax is not normally exposed to the possibility of unknown | ||
62 | values, this extension must make some compromises when asked to iterate over | ||
63 | an unknown collection. If the length of the collection cannot be statically | ||
64 | recognized (because it is an unknown value of list, map, or set type) then | ||
65 | the `dynamic` construct will generate a _single_ dynamic block whose iterator | ||
66 | key and value are both unknown values of the dynamic pseudo-type, thus causing | ||
67 | any attribute values derived from iteration to appear as unknown values. There | ||
68 | is no explicit representation of the fact that the length of the collection may | ||
69 | eventually be different than one. | ||
70 | |||
71 | ## Usage | ||
72 | |||
73 | Pass a body to function `Expand` to obtain a new body that will, on access | ||
74 | to its content, evaluate and expand any nested `dynamic` blocks. | ||
75 | Dynamic block processing is also automatically propagated into any nested | ||
76 | blocks that are returned, allowing users to nest dynamic blocks inside | ||
77 | one another and to nest dynamic blocks inside other static blocks. | ||
78 | |||
79 | HCL structural decoding does not normally have access to an `EvalContext`, so | ||
80 | any variables and functions that should be available to the `for_each` | ||
81 | and `labels` expressions must be passed in when calling `Expand`. Expressions | ||
82 | within the `content` block are evaluated separately and so can be passed a | ||
83 | separate `EvalContext` if desired, during normal attribute expression | ||
84 | evaluation. | ||
85 | |||
86 | ## Detecting Variables | ||
87 | |||
88 | Some applications dynamically generate an `EvalContext` by analyzing which | ||
89 | variables are referenced by an expression before evaluating it. | ||
90 | |||
91 | This unfortunately requires some extra effort when this analysis is required | ||
92 | for the context passed to `Expand`: the HCL API requires a schema to be | ||
93 | provided in order to do any analysis of the blocks in a body, but the low-level | ||
94 | schema model provides a description of only one level of nested blocks at | ||
95 | a time, and thus a new schema must be provided for each additional level of | ||
96 | nesting. | ||
97 | |||
98 | To make this arduous process as convenient as possbile, this package provides | ||
99 | a helper function `WalkForEachVariables`, which returns a `WalkVariablesNode` | ||
100 | instance that can be used to find variables directly in a given body and also | ||
101 | determine which nested blocks require recursive calls. Using this mechanism | ||
102 | requires that the caller be able to look up a schema given a nested block type. | ||
103 | For _simple_ formats where a specific block type name always has the same schema | ||
104 | regardless of context, a walk can be implemented as follows: | ||
105 | |||
106 | ```go | ||
107 | func walkVariables(node dynblock.WalkVariablesNode, schema *hcl.BodySchema) []hcl.Traversal { | ||
108 | vars, children := node.Visit(schema) | ||
109 | |||
110 | for _, child := range children { | ||
111 | var childSchema *hcl.BodySchema | ||
112 | switch child.BlockTypeName { | ||
113 | case "a": | ||
114 | childSchema = &hcl.BodySchema{ | ||
115 | Blocks: []hcl.BlockHeaderSchema{ | ||
116 | { | ||
117 | Type: "b", | ||
118 | LabelNames: []string{"key"}, | ||
119 | }, | ||
120 | }, | ||
121 | } | ||
122 | case "b": | ||
123 | childSchema = &hcl.BodySchema{ | ||
124 | Attributes: []hcl.AttributeSchema{ | ||
125 | { | ||
126 | Name: "val", | ||
127 | Required: true, | ||
128 | }, | ||
129 | }, | ||
130 | } | ||
131 | default: | ||
132 | // Should never happen, because the above cases should be exhaustive | ||
133 | // for the application's configuration format. | ||
134 | panic(fmt.Errorf("can't find schema for unknown block type %q", child.BlockTypeName)) | ||
135 | } | ||
136 | |||
137 | vars = append(vars, testWalkAndAccumVars(child.Node, childSchema)...) | ||
138 | } | ||
139 | } | ||
140 | ``` | ||
141 | |||
142 | ### Detecting Variables with `hcldec` Specifications | ||
143 | |||
144 | For applications that use the higher-level `hcldec` package to decode nested | ||
145 | configuration structures into `cty` values, the same specification can be used | ||
146 | to automatically drive the recursive variable-detection walk described above. | ||
147 | |||
148 | The helper function `ForEachVariablesHCLDec` allows an entire recursive | ||
149 | configuration structure to be analyzed in a single call given a `hcldec.Spec` | ||
150 | that describes the nested block structure. This means a `hcldec`-based | ||
151 | application can support dynamic blocks with only a little additional effort: | ||
152 | |||
153 | ```go | ||
154 | func decodeBody(body hcl.Body, spec hcldec.Spec) (cty.Value, hcl.Diagnostics) { | ||
155 | // Determine which variables are needed to expand dynamic blocks | ||
156 | neededForDynamic := dynblock.ForEachVariablesHCLDec(body, spec) | ||
157 | |||
158 | // Build a suitable EvalContext and expand dynamic blocks | ||
159 | dynCtx := buildEvalContext(neededForDynamic) | ||
160 | dynBody := dynblock.Expand(body, dynCtx) | ||
161 | |||
162 | // Determine which variables are needed to fully decode the expanded body | ||
163 | // This will analyze expressions that came both from static blocks in the | ||
164 | // original body and from blocks that were dynamically added by Expand. | ||
165 | neededForDecode := hcldec.Variables(dynBody, spec) | ||
166 | |||
167 | // Build a suitable EvalContext and then fully decode the body as per the | ||
168 | // hcldec specification. | ||
169 | decCtx := buildEvalContext(neededForDecode) | ||
170 | return hcldec.Decode(dynBody, spec, decCtx) | ||
171 | } | ||
172 | |||
173 | func buildEvalContext(needed []hcl.Traversal) *hcl.EvalContext { | ||
174 | // (to be implemented by your application) | ||
175 | } | ||
176 | ``` | ||
177 | |||
178 | # Performance | ||
179 | |||
180 | This extension is going quite harshly against the grain of the HCL API, and | ||
181 | so it uses lots of wrapping objects and temporary data structures to get its | ||
182 | work done. HCL in general is not suitable for use in high-performance situations | ||
183 | or situations sensitive to memory pressure, but that is _especially_ true for | ||
184 | this extension. | ||
diff --git a/vendor/github.com/hashicorp/hcl2/ext/dynblock/expand_body.go b/vendor/github.com/hashicorp/hcl2/ext/dynblock/expand_body.go new file mode 100644 index 0000000..dd30822 --- /dev/null +++ b/vendor/github.com/hashicorp/hcl2/ext/dynblock/expand_body.go | |||
@@ -0,0 +1,262 @@ | |||
1 | package dynblock | ||
2 | |||
3 | import ( | ||
4 | "fmt" | ||
5 | |||
6 | "github.com/hashicorp/hcl2/hcl" | ||
7 | "github.com/zclconf/go-cty/cty" | ||
8 | ) | ||
9 | |||
10 | // expandBody wraps another hcl.Body and expands any "dynamic" blocks found | ||
11 | // inside whenever Content or PartialContent is called. | ||
12 | type expandBody struct { | ||
13 | original hcl.Body | ||
14 | forEachCtx *hcl.EvalContext | ||
15 | iteration *iteration // non-nil if we're nested inside another "dynamic" block | ||
16 | |||
17 | // These are used with PartialContent to produce a "remaining items" | ||
18 | // body to return. They are nil on all bodies fresh out of the transformer. | ||
19 | // | ||
20 | // Note that this is re-implemented here rather than delegating to the | ||
21 | // existing support required by the underlying body because we need to | ||
22 | // retain access to the entire original body on subsequent decode operations | ||
23 | // so we can retain any "dynamic" blocks for types we didn't take consume | ||
24 | // on the first pass. | ||
25 | hiddenAttrs map[string]struct{} | ||
26 | hiddenBlocks map[string]hcl.BlockHeaderSchema | ||
27 | } | ||
28 | |||
29 | func (b *expandBody) Content(schema *hcl.BodySchema) (*hcl.BodyContent, hcl.Diagnostics) { | ||
30 | extSchema := b.extendSchema(schema) | ||
31 | rawContent, diags := b.original.Content(extSchema) | ||
32 | |||
33 | blocks, blockDiags := b.expandBlocks(schema, rawContent.Blocks, false) | ||
34 | diags = append(diags, blockDiags...) | ||
35 | attrs := b.prepareAttributes(rawContent.Attributes) | ||
36 | |||
37 | content := &hcl.BodyContent{ | ||
38 | Attributes: attrs, | ||
39 | Blocks: blocks, | ||
40 | MissingItemRange: b.original.MissingItemRange(), | ||
41 | } | ||
42 | |||
43 | return content, diags | ||
44 | } | ||
45 | |||
46 | func (b *expandBody) PartialContent(schema *hcl.BodySchema) (*hcl.BodyContent, hcl.Body, hcl.Diagnostics) { | ||
47 | extSchema := b.extendSchema(schema) | ||
48 | rawContent, _, diags := b.original.PartialContent(extSchema) | ||
49 | // We discard the "remain" argument above because we're going to construct | ||
50 | // our own remain that also takes into account remaining "dynamic" blocks. | ||
51 | |||
52 | blocks, blockDiags := b.expandBlocks(schema, rawContent.Blocks, true) | ||
53 | diags = append(diags, blockDiags...) | ||
54 | attrs := b.prepareAttributes(rawContent.Attributes) | ||
55 | |||
56 | content := &hcl.BodyContent{ | ||
57 | Attributes: attrs, | ||
58 | Blocks: blocks, | ||
59 | MissingItemRange: b.original.MissingItemRange(), | ||
60 | } | ||
61 | |||
62 | remain := &expandBody{ | ||
63 | original: b.original, | ||
64 | forEachCtx: b.forEachCtx, | ||
65 | iteration: b.iteration, | ||
66 | hiddenAttrs: make(map[string]struct{}), | ||
67 | hiddenBlocks: make(map[string]hcl.BlockHeaderSchema), | ||
68 | } | ||
69 | for name := range b.hiddenAttrs { | ||
70 | remain.hiddenAttrs[name] = struct{}{} | ||
71 | } | ||
72 | for typeName, blockS := range b.hiddenBlocks { | ||
73 | remain.hiddenBlocks[typeName] = blockS | ||
74 | } | ||
75 | for _, attrS := range schema.Attributes { | ||
76 | remain.hiddenAttrs[attrS.Name] = struct{}{} | ||
77 | } | ||
78 | for _, blockS := range schema.Blocks { | ||
79 | remain.hiddenBlocks[blockS.Type] = blockS | ||
80 | } | ||
81 | |||
82 | return content, remain, diags | ||
83 | } | ||
84 | |||
85 | func (b *expandBody) extendSchema(schema *hcl.BodySchema) *hcl.BodySchema { | ||
86 | // We augment the requested schema to also include our special "dynamic" | ||
87 | // block type, since then we'll get instances of it interleaved with | ||
88 | // all of the literal child blocks we must also include. | ||
89 | extSchema := &hcl.BodySchema{ | ||
90 | Attributes: schema.Attributes, | ||
91 | Blocks: make([]hcl.BlockHeaderSchema, len(schema.Blocks), len(schema.Blocks)+len(b.hiddenBlocks)+1), | ||
92 | } | ||
93 | copy(extSchema.Blocks, schema.Blocks) | ||
94 | extSchema.Blocks = append(extSchema.Blocks, dynamicBlockHeaderSchema) | ||
95 | |||
96 | // If we have any hiddenBlocks then we also need to register those here | ||
97 | // so that a call to "Content" on the underlying body won't fail. | ||
98 | // (We'll filter these out again once we process the result of either | ||
99 | // Content or PartialContent.) | ||
100 | for _, blockS := range b.hiddenBlocks { | ||
101 | extSchema.Blocks = append(extSchema.Blocks, blockS) | ||
102 | } | ||
103 | |||
104 | // If we have any hiddenAttrs then we also need to register these, for | ||
105 | // the same reason as we deal with hiddenBlocks above. | ||
106 | if len(b.hiddenAttrs) != 0 { | ||
107 | newAttrs := make([]hcl.AttributeSchema, len(schema.Attributes), len(schema.Attributes)+len(b.hiddenAttrs)) | ||
108 | copy(newAttrs, extSchema.Attributes) | ||
109 | for name := range b.hiddenAttrs { | ||
110 | newAttrs = append(newAttrs, hcl.AttributeSchema{ | ||
111 | Name: name, | ||
112 | Required: false, | ||
113 | }) | ||
114 | } | ||
115 | extSchema.Attributes = newAttrs | ||
116 | } | ||
117 | |||
118 | return extSchema | ||
119 | } | ||
120 | |||
121 | func (b *expandBody) prepareAttributes(rawAttrs hcl.Attributes) hcl.Attributes { | ||
122 | if len(b.hiddenAttrs) == 0 && b.iteration == nil { | ||
123 | // Easy path: just pass through the attrs from the original body verbatim | ||
124 | return rawAttrs | ||
125 | } | ||
126 | |||
127 | // Otherwise we have some work to do: we must filter out any attributes | ||
128 | // that are hidden (since a previous PartialContent call already saw these) | ||
129 | // and wrap the expressions of the inner attributes so that they will | ||
130 | // have access to our iteration variables. | ||
131 | attrs := make(hcl.Attributes, len(rawAttrs)) | ||
132 | for name, rawAttr := range rawAttrs { | ||
133 | if _, hidden := b.hiddenAttrs[name]; hidden { | ||
134 | continue | ||
135 | } | ||
136 | if b.iteration != nil { | ||
137 | attr := *rawAttr // shallow copy so we can mutate it | ||
138 | attr.Expr = exprWrap{ | ||
139 | Expression: attr.Expr, | ||
140 | i: b.iteration, | ||
141 | } | ||
142 | attrs[name] = &attr | ||
143 | } else { | ||
144 | // If we have no active iteration then no wrapping is required. | ||
145 | attrs[name] = rawAttr | ||
146 | } | ||
147 | } | ||
148 | return attrs | ||
149 | } | ||
150 | |||
151 | func (b *expandBody) expandBlocks(schema *hcl.BodySchema, rawBlocks hcl.Blocks, partial bool) (hcl.Blocks, hcl.Diagnostics) { | ||
152 | var blocks hcl.Blocks | ||
153 | var diags hcl.Diagnostics | ||
154 | |||
155 | for _, rawBlock := range rawBlocks { | ||
156 | switch rawBlock.Type { | ||
157 | case "dynamic": | ||
158 | realBlockType := rawBlock.Labels[0] | ||
159 | if _, hidden := b.hiddenBlocks[realBlockType]; hidden { | ||
160 | continue | ||
161 | } | ||
162 | |||
163 | var blockS *hcl.BlockHeaderSchema | ||
164 | for _, candidate := range schema.Blocks { | ||
165 | if candidate.Type == realBlockType { | ||
166 | blockS = &candidate | ||
167 | break | ||
168 | } | ||
169 | } | ||
170 | if blockS == nil { | ||
171 | // Not a block type that the caller requested. | ||
172 | if !partial { | ||
173 | diags = append(diags, &hcl.Diagnostic{ | ||
174 | Severity: hcl.DiagError, | ||
175 | Summary: "Unsupported block type", | ||
176 | Detail: fmt.Sprintf("Blocks of type %q are not expected here.", realBlockType), | ||
177 | Subject: &rawBlock.LabelRanges[0], | ||
178 | }) | ||
179 | } | ||
180 | continue | ||
181 | } | ||
182 | |||
183 | spec, specDiags := b.decodeSpec(blockS, rawBlock) | ||
184 | diags = append(diags, specDiags...) | ||
185 | if specDiags.HasErrors() { | ||
186 | continue | ||
187 | } | ||
188 | |||
189 | if spec.forEachVal.IsKnown() { | ||
190 | for it := spec.forEachVal.ElementIterator(); it.Next(); { | ||
191 | key, value := it.Element() | ||
192 | i := b.iteration.MakeChild(spec.iteratorName, key, value) | ||
193 | |||
194 | block, blockDiags := spec.newBlock(i, b.forEachCtx) | ||
195 | diags = append(diags, blockDiags...) | ||
196 | if block != nil { | ||
197 | // Attach our new iteration context so that attributes | ||
198 | // and other nested blocks can refer to our iterator. | ||
199 | block.Body = b.expandChild(block.Body, i) | ||
200 | blocks = append(blocks, block) | ||
201 | } | ||
202 | } | ||
203 | } else { | ||
204 | // If our top-level iteration value isn't known then we're forced | ||
205 | // to compromise since HCL doesn't have any concept of an | ||
206 | // "unknown block". In this case then, we'll produce a single | ||
207 | // dynamic block with the iterator values set to DynamicVal, | ||
208 | // which at least makes the potential for a block visible | ||
209 | // in our result, even though it's not represented in a fully-accurate | ||
210 | // way. | ||
211 | i := b.iteration.MakeChild(spec.iteratorName, cty.DynamicVal, cty.DynamicVal) | ||
212 | block, blockDiags := spec.newBlock(i, b.forEachCtx) | ||
213 | diags = append(diags, blockDiags...) | ||
214 | if block != nil { | ||
215 | block.Body = b.expandChild(block.Body, i) | ||
216 | |||
217 | // We additionally force all of the leaf attribute values | ||
218 | // in the result to be unknown so the calling application | ||
219 | // can, if necessary, use that as a heuristic to detect | ||
220 | // when a single nested block might be standing in for | ||
221 | // multiple blocks yet to be expanded. This retains the | ||
222 | // structure of the generated body but forces all of its | ||
223 | // leaf attribute values to be unknown. | ||
224 | block.Body = unknownBody{block.Body} | ||
225 | |||
226 | blocks = append(blocks, block) | ||
227 | } | ||
228 | } | ||
229 | |||
230 | default: | ||
231 | if _, hidden := b.hiddenBlocks[rawBlock.Type]; !hidden { | ||
232 | // A static block doesn't create a new iteration context, but | ||
233 | // it does need to inherit _our own_ iteration context in | ||
234 | // case it contains expressions that refer to our inherited | ||
235 | // iterators, or nested "dynamic" blocks. | ||
236 | expandedBlock := *rawBlock // shallow copy | ||
237 | expandedBlock.Body = b.expandChild(rawBlock.Body, b.iteration) | ||
238 | blocks = append(blocks, &expandedBlock) | ||
239 | } | ||
240 | } | ||
241 | } | ||
242 | |||
243 | return blocks, diags | ||
244 | } | ||
245 | |||
246 | func (b *expandBody) expandChild(child hcl.Body, i *iteration) hcl.Body { | ||
247 | chiCtx := i.EvalContext(b.forEachCtx) | ||
248 | ret := Expand(child, chiCtx) | ||
249 | ret.(*expandBody).iteration = i | ||
250 | return ret | ||
251 | } | ||
252 | |||
253 | func (b *expandBody) JustAttributes() (hcl.Attributes, hcl.Diagnostics) { | ||
254 | // blocks aren't allowed in JustAttributes mode and this body can | ||
255 | // only produce blocks, so we'll just pass straight through to our | ||
256 | // underlying body here. | ||
257 | return b.original.JustAttributes() | ||
258 | } | ||
259 | |||
260 | func (b *expandBody) MissingItemRange() hcl.Range { | ||
261 | return b.original.MissingItemRange() | ||
262 | } | ||
diff --git a/vendor/github.com/hashicorp/hcl2/ext/dynblock/expand_spec.go b/vendor/github.com/hashicorp/hcl2/ext/dynblock/expand_spec.go new file mode 100644 index 0000000..41c0be2 --- /dev/null +++ b/vendor/github.com/hashicorp/hcl2/ext/dynblock/expand_spec.go | |||
@@ -0,0 +1,215 @@ | |||
1 | package dynblock | ||
2 | |||
3 | import ( | ||
4 | "fmt" | ||
5 | |||
6 | "github.com/hashicorp/hcl2/hcl" | ||
7 | "github.com/zclconf/go-cty/cty" | ||
8 | "github.com/zclconf/go-cty/cty/convert" | ||
9 | ) | ||
10 | |||
11 | type expandSpec struct { | ||
12 | blockType string | ||
13 | blockTypeRange hcl.Range | ||
14 | defRange hcl.Range | ||
15 | forEachVal cty.Value | ||
16 | iteratorName string | ||
17 | labelExprs []hcl.Expression | ||
18 | contentBody hcl.Body | ||
19 | inherited map[string]*iteration | ||
20 | } | ||
21 | |||
22 | func (b *expandBody) decodeSpec(blockS *hcl.BlockHeaderSchema, rawSpec *hcl.Block) (*expandSpec, hcl.Diagnostics) { | ||
23 | var diags hcl.Diagnostics | ||
24 | |||
25 | var schema *hcl.BodySchema | ||
26 | if len(blockS.LabelNames) != 0 { | ||
27 | schema = dynamicBlockBodySchemaLabels | ||
28 | } else { | ||
29 | schema = dynamicBlockBodySchemaNoLabels | ||
30 | } | ||
31 | |||
32 | specContent, specDiags := rawSpec.Body.Content(schema) | ||
33 | diags = append(diags, specDiags...) | ||
34 | if specDiags.HasErrors() { | ||
35 | return nil, diags | ||
36 | } | ||
37 | |||
38 | //// for_each attribute | ||
39 | |||
40 | eachAttr := specContent.Attributes["for_each"] | ||
41 | eachVal, eachDiags := eachAttr.Expr.Value(b.forEachCtx) | ||
42 | diags = append(diags, eachDiags...) | ||
43 | |||
44 | if !eachVal.CanIterateElements() && eachVal.Type() != cty.DynamicPseudoType { | ||
45 | // We skip this error for DynamicPseudoType because that means we either | ||
46 | // have a null (which is checked immediately below) or an unknown | ||
47 | // (which is handled in the expandBody Content methods). | ||
48 | diags = append(diags, &hcl.Diagnostic{ | ||
49 | Severity: hcl.DiagError, | ||
50 | Summary: "Invalid dynamic for_each value", | ||
51 | Detail: fmt.Sprintf("Cannot use a %s value in for_each. An iterable collection is required.", eachVal.Type().FriendlyName()), | ||
52 | Subject: eachAttr.Expr.Range().Ptr(), | ||
53 | Expression: eachAttr.Expr, | ||
54 | EvalContext: b.forEachCtx, | ||
55 | }) | ||
56 | return nil, diags | ||
57 | } | ||
58 | if eachVal.IsNull() { | ||
59 | diags = append(diags, &hcl.Diagnostic{ | ||
60 | Severity: hcl.DiagError, | ||
61 | Summary: "Invalid dynamic for_each value", | ||
62 | Detail: "Cannot use a null value in for_each.", | ||
63 | Subject: eachAttr.Expr.Range().Ptr(), | ||
64 | Expression: eachAttr.Expr, | ||
65 | EvalContext: b.forEachCtx, | ||
66 | }) | ||
67 | return nil, diags | ||
68 | } | ||
69 | |||
70 | //// iterator attribute | ||
71 | |||
72 | iteratorName := blockS.Type | ||
73 | if iteratorAttr := specContent.Attributes["iterator"]; iteratorAttr != nil { | ||
74 | itTraversal, itDiags := hcl.AbsTraversalForExpr(iteratorAttr.Expr) | ||
75 | diags = append(diags, itDiags...) | ||
76 | if itDiags.HasErrors() { | ||
77 | return nil, diags | ||
78 | } | ||
79 | |||
80 | if len(itTraversal) != 1 { | ||
81 | diags = append(diags, &hcl.Diagnostic{ | ||
82 | Severity: hcl.DiagError, | ||
83 | Summary: "Invalid dynamic iterator name", | ||
84 | Detail: "Dynamic iterator must be a single variable name.", | ||
85 | Subject: itTraversal.SourceRange().Ptr(), | ||
86 | }) | ||
87 | return nil, diags | ||
88 | } | ||
89 | |||
90 | iteratorName = itTraversal.RootName() | ||
91 | } | ||
92 | |||
93 | var labelExprs []hcl.Expression | ||
94 | if labelsAttr := specContent.Attributes["labels"]; labelsAttr != nil { | ||
95 | var labelDiags hcl.Diagnostics | ||
96 | labelExprs, labelDiags = hcl.ExprList(labelsAttr.Expr) | ||
97 | diags = append(diags, labelDiags...) | ||
98 | if labelDiags.HasErrors() { | ||
99 | return nil, diags | ||
100 | } | ||
101 | |||
102 | if len(labelExprs) > len(blockS.LabelNames) { | ||
103 | diags = append(diags, &hcl.Diagnostic{ | ||
104 | Severity: hcl.DiagError, | ||
105 | Summary: "Extraneous dynamic block label", | ||
106 | Detail: fmt.Sprintf("Blocks of type %q require %d label(s).", blockS.Type, len(blockS.LabelNames)), | ||
107 | Subject: labelExprs[len(blockS.LabelNames)].Range().Ptr(), | ||
108 | }) | ||
109 | return nil, diags | ||
110 | } else if len(labelExprs) < len(blockS.LabelNames) { | ||
111 | diags = append(diags, &hcl.Diagnostic{ | ||
112 | Severity: hcl.DiagError, | ||
113 | Summary: "Insufficient dynamic block labels", | ||
114 | Detail: fmt.Sprintf("Blocks of type %q require %d label(s).", blockS.Type, len(blockS.LabelNames)), | ||
115 | Subject: labelsAttr.Expr.Range().Ptr(), | ||
116 | }) | ||
117 | return nil, diags | ||
118 | } | ||
119 | } | ||
120 | |||
121 | // Since our schema requests only blocks of type "content", we can assume | ||
122 | // that all entries in specContent.Blocks are content blocks. | ||
123 | if len(specContent.Blocks) == 0 { | ||
124 | diags = append(diags, &hcl.Diagnostic{ | ||
125 | Severity: hcl.DiagError, | ||
126 | Summary: "Missing dynamic content block", | ||
127 | Detail: "A dynamic block must have a nested block of type \"content\" to describe the body of each generated block.", | ||
128 | Subject: &specContent.MissingItemRange, | ||
129 | }) | ||
130 | return nil, diags | ||
131 | } | ||
132 | if len(specContent.Blocks) > 1 { | ||
133 | diags = append(diags, &hcl.Diagnostic{ | ||
134 | Severity: hcl.DiagError, | ||
135 | Summary: "Extraneous dynamic content block", | ||
136 | Detail: "Only one nested content block is allowed for each dynamic block.", | ||
137 | Subject: &specContent.Blocks[1].DefRange, | ||
138 | }) | ||
139 | return nil, diags | ||
140 | } | ||
141 | |||
142 | return &expandSpec{ | ||
143 | blockType: blockS.Type, | ||
144 | blockTypeRange: rawSpec.LabelRanges[0], | ||
145 | defRange: rawSpec.DefRange, | ||
146 | forEachVal: eachVal, | ||
147 | iteratorName: iteratorName, | ||
148 | labelExprs: labelExprs, | ||
149 | contentBody: specContent.Blocks[0].Body, | ||
150 | }, diags | ||
151 | } | ||
152 | |||
153 | func (s *expandSpec) newBlock(i *iteration, ctx *hcl.EvalContext) (*hcl.Block, hcl.Diagnostics) { | ||
154 | var diags hcl.Diagnostics | ||
155 | var labels []string | ||
156 | var labelRanges []hcl.Range | ||
157 | lCtx := i.EvalContext(ctx) | ||
158 | for _, labelExpr := range s.labelExprs { | ||
159 | labelVal, labelDiags := labelExpr.Value(lCtx) | ||
160 | diags = append(diags, labelDiags...) | ||
161 | if labelDiags.HasErrors() { | ||
162 | return nil, diags | ||
163 | } | ||
164 | |||
165 | var convErr error | ||
166 | labelVal, convErr = convert.Convert(labelVal, cty.String) | ||
167 | if convErr != nil { | ||
168 | diags = append(diags, &hcl.Diagnostic{ | ||
169 | Severity: hcl.DiagError, | ||
170 | Summary: "Invalid dynamic block label", | ||
171 | Detail: fmt.Sprintf("Cannot use this value as a dynamic block label: %s.", convErr), | ||
172 | Subject: labelExpr.Range().Ptr(), | ||
173 | Expression: labelExpr, | ||
174 | EvalContext: lCtx, | ||
175 | }) | ||
176 | return nil, diags | ||
177 | } | ||
178 | if labelVal.IsNull() { | ||
179 | diags = append(diags, &hcl.Diagnostic{ | ||
180 | Severity: hcl.DiagError, | ||
181 | Summary: "Invalid dynamic block label", | ||
182 | Detail: "Cannot use a null value as a dynamic block label.", | ||
183 | Subject: labelExpr.Range().Ptr(), | ||
184 | Expression: labelExpr, | ||
185 | EvalContext: lCtx, | ||
186 | }) | ||
187 | return nil, diags | ||
188 | } | ||
189 | if !labelVal.IsKnown() { | ||
190 | diags = append(diags, &hcl.Diagnostic{ | ||
191 | Severity: hcl.DiagError, | ||
192 | Summary: "Invalid dynamic block label", | ||
193 | Detail: "This value is not yet known. Dynamic block labels must be immediately-known values.", | ||
194 | Subject: labelExpr.Range().Ptr(), | ||
195 | Expression: labelExpr, | ||
196 | EvalContext: lCtx, | ||
197 | }) | ||
198 | return nil, diags | ||
199 | } | ||
200 | |||
201 | labels = append(labels, labelVal.AsString()) | ||
202 | labelRanges = append(labelRanges, labelExpr.Range()) | ||
203 | } | ||
204 | |||
205 | block := &hcl.Block{ | ||
206 | Type: s.blockType, | ||
207 | TypeRange: s.blockTypeRange, | ||
208 | Labels: labels, | ||
209 | LabelRanges: labelRanges, | ||
210 | DefRange: s.defRange, | ||
211 | Body: s.contentBody, | ||
212 | } | ||
213 | |||
214 | return block, diags | ||
215 | } | ||
diff --git a/vendor/github.com/hashicorp/hcl2/ext/dynblock/expr_wrap.go b/vendor/github.com/hashicorp/hcl2/ext/dynblock/expr_wrap.go new file mode 100644 index 0000000..6916fc1 --- /dev/null +++ b/vendor/github.com/hashicorp/hcl2/ext/dynblock/expr_wrap.go | |||
@@ -0,0 +1,42 @@ | |||
1 | package dynblock | ||
2 | |||
3 | import ( | ||
4 | "github.com/hashicorp/hcl2/hcl" | ||
5 | "github.com/zclconf/go-cty/cty" | ||
6 | ) | ||
7 | |||
8 | type exprWrap struct { | ||
9 | hcl.Expression | ||
10 | i *iteration | ||
11 | } | ||
12 | |||
13 | func (e exprWrap) Variables() []hcl.Traversal { | ||
14 | raw := e.Expression.Variables() | ||
15 | ret := make([]hcl.Traversal, 0, len(raw)) | ||
16 | |||
17 | // Filter out traversals that refer to our iterator name or any | ||
18 | // iterator we've inherited; we're going to provide those in | ||
19 | // our Value wrapper, so the caller doesn't need to know about them. | ||
20 | for _, traversal := range raw { | ||
21 | rootName := traversal.RootName() | ||
22 | if rootName == e.i.IteratorName { | ||
23 | continue | ||
24 | } | ||
25 | if _, inherited := e.i.Inherited[rootName]; inherited { | ||
26 | continue | ||
27 | } | ||
28 | ret = append(ret, traversal) | ||
29 | } | ||
30 | return ret | ||
31 | } | ||
32 | |||
33 | func (e exprWrap) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) { | ||
34 | extCtx := e.i.EvalContext(ctx) | ||
35 | return e.Expression.Value(extCtx) | ||
36 | } | ||
37 | |||
38 | // UnwrapExpression returns the expression being wrapped by this instance. | ||
39 | // This allows the original expression to be recovered by hcl.UnwrapExpression. | ||
40 | func (e exprWrap) UnwrapExpression() hcl.Expression { | ||
41 | return e.Expression | ||
42 | } | ||
diff --git a/vendor/github.com/hashicorp/hcl2/ext/dynblock/iteration.go b/vendor/github.com/hashicorp/hcl2/ext/dynblock/iteration.go new file mode 100644 index 0000000..7056d33 --- /dev/null +++ b/vendor/github.com/hashicorp/hcl2/ext/dynblock/iteration.go | |||
@@ -0,0 +1,66 @@ | |||
1 | package dynblock | ||
2 | |||
3 | import ( | ||
4 | "github.com/hashicorp/hcl2/hcl" | ||
5 | "github.com/zclconf/go-cty/cty" | ||
6 | ) | ||
7 | |||
8 | type iteration struct { | ||
9 | IteratorName string | ||
10 | Key cty.Value | ||
11 | Value cty.Value | ||
12 | Inherited map[string]*iteration | ||
13 | } | ||
14 | |||
15 | func (s *expandSpec) MakeIteration(key, value cty.Value) *iteration { | ||
16 | return &iteration{ | ||
17 | IteratorName: s.iteratorName, | ||
18 | Key: key, | ||
19 | Value: value, | ||
20 | Inherited: s.inherited, | ||
21 | } | ||
22 | } | ||
23 | |||
24 | func (i *iteration) Object() cty.Value { | ||
25 | return cty.ObjectVal(map[string]cty.Value{ | ||
26 | "key": i.Key, | ||
27 | "value": i.Value, | ||
28 | }) | ||
29 | } | ||
30 | |||
31 | func (i *iteration) EvalContext(base *hcl.EvalContext) *hcl.EvalContext { | ||
32 | new := base.NewChild() | ||
33 | |||
34 | if i != nil { | ||
35 | new.Variables = map[string]cty.Value{} | ||
36 | for name, otherIt := range i.Inherited { | ||
37 | new.Variables[name] = otherIt.Object() | ||
38 | } | ||
39 | new.Variables[i.IteratorName] = i.Object() | ||
40 | } | ||
41 | |||
42 | return new | ||
43 | } | ||
44 | |||
45 | func (i *iteration) MakeChild(iteratorName string, key, value cty.Value) *iteration { | ||
46 | if i == nil { | ||
47 | // Create entirely new root iteration, then | ||
48 | return &iteration{ | ||
49 | IteratorName: iteratorName, | ||
50 | Key: key, | ||
51 | Value: value, | ||
52 | } | ||
53 | } | ||
54 | |||
55 | inherited := map[string]*iteration{} | ||
56 | for name, otherIt := range i.Inherited { | ||
57 | inherited[name] = otherIt | ||
58 | } | ||
59 | inherited[i.IteratorName] = i | ||
60 | return &iteration{ | ||
61 | IteratorName: iteratorName, | ||
62 | Key: key, | ||
63 | Value: value, | ||
64 | Inherited: inherited, | ||
65 | } | ||
66 | } | ||
diff --git a/vendor/github.com/hashicorp/hcl2/ext/dynblock/public.go b/vendor/github.com/hashicorp/hcl2/ext/dynblock/public.go new file mode 100644 index 0000000..b7e8ca9 --- /dev/null +++ b/vendor/github.com/hashicorp/hcl2/ext/dynblock/public.go | |||
@@ -0,0 +1,44 @@ | |||
1 | package dynblock | ||
2 | |||
3 | import ( | ||
4 | "github.com/hashicorp/hcl2/hcl" | ||
5 | ) | ||
6 | |||
7 | // Expand "dynamic" blocks in the given body, returning a new body that | ||
8 | // has those blocks expanded. | ||
9 | // | ||
10 | // The given EvalContext is used when evaluating "for_each" and "labels" | ||
11 | // attributes within dynamic blocks, allowing those expressions access to | ||
12 | // variables and functions beyond the iterator variable created by the | ||
13 | // iteration. | ||
14 | // | ||
15 | // Expand returns no diagnostics because no blocks are actually expanded | ||
16 | // until a call to Content or PartialContent on the returned body, which | ||
17 | // will then expand only the blocks selected by the schema. | ||
18 | // | ||
19 | // "dynamic" blocks are also expanded automatically within nested blocks | ||
20 | // in the given body, including within other dynamic blocks, thus allowing | ||
21 | // multi-dimensional iteration. However, it is not possible to | ||
22 | // dynamically-generate the "dynamic" blocks themselves except through nesting. | ||
23 | // | ||
24 | // parent { | ||
25 | // dynamic "child" { | ||
26 | // for_each = child_objs | ||
27 | // content { | ||
28 | // dynamic "grandchild" { | ||
29 | // for_each = child.value.children | ||
30 | // labels = [grandchild.key] | ||
31 | // content { | ||
32 | // parent_key = child.key | ||
33 | // value = grandchild.value | ||
34 | // } | ||
35 | // } | ||
36 | // } | ||
37 | // } | ||
38 | // } | ||
39 | func Expand(body hcl.Body, ctx *hcl.EvalContext) hcl.Body { | ||
40 | return &expandBody{ | ||
41 | original: body, | ||
42 | forEachCtx: ctx, | ||
43 | } | ||
44 | } | ||
diff --git a/vendor/github.com/hashicorp/hcl2/ext/dynblock/schema.go b/vendor/github.com/hashicorp/hcl2/ext/dynblock/schema.go new file mode 100644 index 0000000..dc8ed5a --- /dev/null +++ b/vendor/github.com/hashicorp/hcl2/ext/dynblock/schema.go | |||
@@ -0,0 +1,50 @@ | |||
1 | package dynblock | ||
2 | |||
3 | import "github.com/hashicorp/hcl2/hcl" | ||
4 | |||
5 | var dynamicBlockHeaderSchema = hcl.BlockHeaderSchema{ | ||
6 | Type: "dynamic", | ||
7 | LabelNames: []string{"type"}, | ||
8 | } | ||
9 | |||
10 | var dynamicBlockBodySchemaLabels = &hcl.BodySchema{ | ||
11 | Attributes: []hcl.AttributeSchema{ | ||
12 | { | ||
13 | Name: "for_each", | ||
14 | Required: true, | ||
15 | }, | ||
16 | { | ||
17 | Name: "iterator", | ||
18 | Required: false, | ||
19 | }, | ||
20 | { | ||
21 | Name: "labels", | ||
22 | Required: true, | ||
23 | }, | ||
24 | }, | ||
25 | Blocks: []hcl.BlockHeaderSchema{ | ||
26 | { | ||
27 | Type: "content", | ||
28 | LabelNames: nil, | ||
29 | }, | ||
30 | }, | ||
31 | } | ||
32 | |||
33 | var dynamicBlockBodySchemaNoLabels = &hcl.BodySchema{ | ||
34 | Attributes: []hcl.AttributeSchema{ | ||
35 | { | ||
36 | Name: "for_each", | ||
37 | Required: true, | ||
38 | }, | ||
39 | { | ||
40 | Name: "iterator", | ||
41 | Required: false, | ||
42 | }, | ||
43 | }, | ||
44 | Blocks: []hcl.BlockHeaderSchema{ | ||
45 | { | ||
46 | Type: "content", | ||
47 | LabelNames: nil, | ||
48 | }, | ||
49 | }, | ||
50 | } | ||
diff --git a/vendor/github.com/hashicorp/hcl2/ext/dynblock/unknown_body.go b/vendor/github.com/hashicorp/hcl2/ext/dynblock/unknown_body.go new file mode 100644 index 0000000..932f6a3 --- /dev/null +++ b/vendor/github.com/hashicorp/hcl2/ext/dynblock/unknown_body.go | |||
@@ -0,0 +1,84 @@ | |||
1 | package dynblock | ||
2 | |||
3 | import ( | ||
4 | "github.com/hashicorp/hcl2/hcl" | ||
5 | "github.com/zclconf/go-cty/cty" | ||
6 | ) | ||
7 | |||
8 | // unknownBody is a funny body that just reports everything inside it as | ||
9 | // unknown. It uses a given other body as a sort of template for what attributes | ||
10 | // and blocks are inside -- including source location information -- but | ||
11 | // subsitutes unknown values of unknown type for all attributes. | ||
12 | // | ||
13 | // This rather odd process is used to handle expansion of dynamic blocks whose | ||
14 | // for_each expression is unknown. Since a block cannot itself be unknown, | ||
15 | // we instead arrange for everything _inside_ the block to be unknown instead, | ||
16 | // to give the best possible approximation. | ||
17 | type unknownBody struct { | ||
18 | template hcl.Body | ||
19 | } | ||
20 | |||
21 | var _ hcl.Body = unknownBody{} | ||
22 | |||
23 | func (b unknownBody) Content(schema *hcl.BodySchema) (*hcl.BodyContent, hcl.Diagnostics) { | ||
24 | content, diags := b.template.Content(schema) | ||
25 | content = b.fixupContent(content) | ||
26 | |||
27 | // We're intentionally preserving the diagnostics reported from the | ||
28 | // inner body so that we can still report where the template body doesn't | ||
29 | // match the requested schema. | ||
30 | return content, diags | ||
31 | } | ||
32 | |||
33 | func (b unknownBody) PartialContent(schema *hcl.BodySchema) (*hcl.BodyContent, hcl.Body, hcl.Diagnostics) { | ||
34 | content, remain, diags := b.template.PartialContent(schema) | ||
35 | content = b.fixupContent(content) | ||
36 | remain = unknownBody{remain} // remaining content must also be wrapped | ||
37 | |||
38 | // We're intentionally preserving the diagnostics reported from the | ||
39 | // inner body so that we can still report where the template body doesn't | ||
40 | // match the requested schema. | ||
41 | return content, remain, diags | ||
42 | } | ||
43 | |||
44 | func (b unknownBody) JustAttributes() (hcl.Attributes, hcl.Diagnostics) { | ||
45 | attrs, diags := b.template.JustAttributes() | ||
46 | attrs = b.fixupAttrs(attrs) | ||
47 | |||
48 | // We're intentionally preserving the diagnostics reported from the | ||
49 | // inner body so that we can still report where the template body doesn't | ||
50 | // match the requested schema. | ||
51 | return attrs, diags | ||
52 | } | ||
53 | |||
54 | func (b unknownBody) MissingItemRange() hcl.Range { | ||
55 | return b.template.MissingItemRange() | ||
56 | } | ||
57 | |||
58 | func (b unknownBody) fixupContent(got *hcl.BodyContent) *hcl.BodyContent { | ||
59 | ret := &hcl.BodyContent{} | ||
60 | ret.Attributes = b.fixupAttrs(got.Attributes) | ||
61 | if len(got.Blocks) > 0 { | ||
62 | ret.Blocks = make(hcl.Blocks, 0, len(got.Blocks)) | ||
63 | for _, gotBlock := range got.Blocks { | ||
64 | new := *gotBlock // shallow copy | ||
65 | new.Body = unknownBody{gotBlock.Body} // nested content must also be marked unknown | ||
66 | ret.Blocks = append(ret.Blocks, &new) | ||
67 | } | ||
68 | } | ||
69 | |||
70 | return ret | ||
71 | } | ||
72 | |||
73 | func (b unknownBody) fixupAttrs(got hcl.Attributes) hcl.Attributes { | ||
74 | if len(got) == 0 { | ||
75 | return nil | ||
76 | } | ||
77 | ret := make(hcl.Attributes, len(got)) | ||
78 | for name, gotAttr := range got { | ||
79 | new := *gotAttr // shallow copy | ||
80 | new.Expr = hcl.StaticExpr(cty.DynamicVal, gotAttr.Expr.Range()) | ||
81 | ret[name] = &new | ||
82 | } | ||
83 | return ret | ||
84 | } | ||
diff --git a/vendor/github.com/hashicorp/hcl2/ext/dynblock/variables.go b/vendor/github.com/hashicorp/hcl2/ext/dynblock/variables.go new file mode 100644 index 0000000..ad838f3 --- /dev/null +++ b/vendor/github.com/hashicorp/hcl2/ext/dynblock/variables.go | |||
@@ -0,0 +1,209 @@ | |||
1 | package dynblock | ||
2 | |||
3 | import ( | ||
4 | "github.com/hashicorp/hcl2/hcl" | ||
5 | "github.com/zclconf/go-cty/cty" | ||
6 | ) | ||
7 | |||
8 | // WalkVariables begins the recursive process of walking all expressions and | ||
9 | // nested blocks in the given body and its child bodies while taking into | ||
10 | // account any "dynamic" blocks. | ||
11 | // | ||
12 | // This function requires that the caller walk through the nested block | ||
13 | // structure in the given body level-by-level so that an appropriate schema | ||
14 | // can be provided at each level to inform further processing. This workflow | ||
15 | // is thus easiest to use for calling applications that have some higher-level | ||
16 | // schema representation available with which to drive this multi-step | ||
17 | // process. If your application uses the hcldec package, you may be able to | ||
18 | // use VariablesHCLDec instead for a more automatic approach. | ||
19 | func WalkVariables(body hcl.Body) WalkVariablesNode { | ||
20 | return WalkVariablesNode{ | ||
21 | body: body, | ||
22 | includeContent: true, | ||
23 | } | ||
24 | } | ||
25 | |||
26 | // WalkExpandVariables is like Variables but it includes only the variables | ||
27 | // required for successful block expansion, ignoring any variables referenced | ||
28 | // inside block contents. The result is the minimal set of all variables | ||
29 | // required for a call to Expand, excluding variables that would only be | ||
30 | // needed to subsequently call Content or PartialContent on the expanded | ||
31 | // body. | ||
32 | func WalkExpandVariables(body hcl.Body) WalkVariablesNode { | ||
33 | return WalkVariablesNode{ | ||
34 | body: body, | ||
35 | } | ||
36 | } | ||
37 | |||
38 | type WalkVariablesNode struct { | ||
39 | body hcl.Body | ||
40 | it *iteration | ||
41 | |||
42 | includeContent bool | ||
43 | } | ||
44 | |||
45 | type WalkVariablesChild struct { | ||
46 | BlockTypeName string | ||
47 | Node WalkVariablesNode | ||
48 | } | ||
49 | |||
50 | // Body returns the HCL Body associated with the child node, in case the caller | ||
51 | // wants to do some sort of inspection of it in order to decide what schema | ||
52 | // to pass to Visit. | ||
53 | // | ||
54 | // Most implementations should just fetch a fixed schema based on the | ||
55 | // BlockTypeName field and not access this. Deciding on a schema dynamically | ||
56 | // based on the body is a strange thing to do and generally necessary only if | ||
57 | // your caller is already doing other bizarre things with HCL bodies. | ||
58 | func (c WalkVariablesChild) Body() hcl.Body { | ||
59 | return c.Node.body | ||
60 | } | ||
61 | |||
62 | // Visit returns the variable traversals required for any "dynamic" blocks | ||
63 | // directly in the body associated with this node, and also returns any child | ||
64 | // nodes that must be visited in order to continue the walk. | ||
65 | // | ||
66 | // Each child node has its associated block type name given in its BlockTypeName | ||
67 | // field, which the calling application should use to determine the appropriate | ||
68 | // schema for the content of each child node and pass it to the child node's | ||
69 | // own Visit method to continue the walk recursively. | ||
70 | func (n WalkVariablesNode) Visit(schema *hcl.BodySchema) (vars []hcl.Traversal, children []WalkVariablesChild) { | ||
71 | extSchema := n.extendSchema(schema) | ||
72 | container, _, _ := n.body.PartialContent(extSchema) | ||
73 | if container == nil { | ||
74 | return vars, children | ||
75 | } | ||
76 | |||
77 | children = make([]WalkVariablesChild, 0, len(container.Blocks)) | ||
78 | |||
79 | if n.includeContent { | ||
80 | for _, attr := range container.Attributes { | ||
81 | for _, traversal := range attr.Expr.Variables() { | ||
82 | var ours, inherited bool | ||
83 | if n.it != nil { | ||
84 | ours = traversal.RootName() == n.it.IteratorName | ||
85 | _, inherited = n.it.Inherited[traversal.RootName()] | ||
86 | } | ||
87 | |||
88 | if !(ours || inherited) { | ||
89 | vars = append(vars, traversal) | ||
90 | } | ||
91 | } | ||
92 | } | ||
93 | } | ||
94 | |||
95 | for _, block := range container.Blocks { | ||
96 | switch block.Type { | ||
97 | |||
98 | case "dynamic": | ||
99 | blockTypeName := block.Labels[0] | ||
100 | inner, _, _ := block.Body.PartialContent(variableDetectionInnerSchema) | ||
101 | if inner == nil { | ||
102 | continue | ||
103 | } | ||
104 | |||
105 | iteratorName := blockTypeName | ||
106 | if attr, exists := inner.Attributes["iterator"]; exists { | ||
107 | iterTraversal, _ := hcl.AbsTraversalForExpr(attr.Expr) | ||
108 | if len(iterTraversal) == 0 { | ||
109 | // Ignore this invalid dynamic block, since it'll produce | ||
110 | // an error if someone tries to extract content from it | ||
111 | // later anyway. | ||
112 | continue | ||
113 | } | ||
114 | iteratorName = iterTraversal.RootName() | ||
115 | } | ||
116 | blockIt := n.it.MakeChild(iteratorName, cty.DynamicVal, cty.DynamicVal) | ||
117 | |||
118 | if attr, exists := inner.Attributes["for_each"]; exists { | ||
119 | // Filter out iterator names inherited from parent blocks | ||
120 | for _, traversal := range attr.Expr.Variables() { | ||
121 | if _, inherited := blockIt.Inherited[traversal.RootName()]; !inherited { | ||
122 | vars = append(vars, traversal) | ||
123 | } | ||
124 | } | ||
125 | } | ||
126 | if attr, exists := inner.Attributes["labels"]; exists { | ||
127 | // Filter out both our own iterator name _and_ those inherited | ||
128 | // from parent blocks, since we provide _both_ of these to the | ||
129 | // label expressions. | ||
130 | for _, traversal := range attr.Expr.Variables() { | ||
131 | ours := traversal.RootName() == iteratorName | ||
132 | _, inherited := blockIt.Inherited[traversal.RootName()] | ||
133 | |||
134 | if !(ours || inherited) { | ||
135 | vars = append(vars, traversal) | ||
136 | } | ||
137 | } | ||
138 | } | ||
139 | |||
140 | for _, contentBlock := range inner.Blocks { | ||
141 | // We only request "content" blocks in our schema, so we know | ||
142 | // any blocks we find here will be content blocks. We require | ||
143 | // exactly one content block for actual expansion, but we'll | ||
144 | // be more liberal here so that callers can still collect | ||
145 | // variables from erroneous "dynamic" blocks. | ||
146 | children = append(children, WalkVariablesChild{ | ||
147 | BlockTypeName: blockTypeName, | ||
148 | Node: WalkVariablesNode{ | ||
149 | body: contentBlock.Body, | ||
150 | it: blockIt, | ||
151 | includeContent: n.includeContent, | ||
152 | }, | ||
153 | }) | ||
154 | } | ||
155 | |||
156 | default: | ||
157 | children = append(children, WalkVariablesChild{ | ||
158 | BlockTypeName: block.Type, | ||
159 | Node: WalkVariablesNode{ | ||
160 | body: block.Body, | ||
161 | it: n.it, | ||
162 | includeContent: n.includeContent, | ||
163 | }, | ||
164 | }) | ||
165 | |||
166 | } | ||
167 | } | ||
168 | |||
169 | return vars, children | ||
170 | } | ||
171 | |||
172 | func (n WalkVariablesNode) extendSchema(schema *hcl.BodySchema) *hcl.BodySchema { | ||
173 | // We augment the requested schema to also include our special "dynamic" | ||
174 | // block type, since then we'll get instances of it interleaved with | ||
175 | // all of the literal child blocks we must also include. | ||
176 | extSchema := &hcl.BodySchema{ | ||
177 | Attributes: schema.Attributes, | ||
178 | Blocks: make([]hcl.BlockHeaderSchema, len(schema.Blocks), len(schema.Blocks)+1), | ||
179 | } | ||
180 | copy(extSchema.Blocks, schema.Blocks) | ||
181 | extSchema.Blocks = append(extSchema.Blocks, dynamicBlockHeaderSchema) | ||
182 | |||
183 | return extSchema | ||
184 | } | ||
185 | |||
186 | // This is a more relaxed schema than what's in schema.go, since we | ||
187 | // want to maximize the amount of variables we can find even if there | ||
188 | // are erroneous blocks. | ||
189 | var variableDetectionInnerSchema = &hcl.BodySchema{ | ||
190 | Attributes: []hcl.AttributeSchema{ | ||
191 | { | ||
192 | Name: "for_each", | ||
193 | Required: false, | ||
194 | }, | ||
195 | { | ||
196 | Name: "labels", | ||
197 | Required: false, | ||
198 | }, | ||
199 | { | ||
200 | Name: "iterator", | ||
201 | Required: false, | ||
202 | }, | ||
203 | }, | ||
204 | Blocks: []hcl.BlockHeaderSchema{ | ||
205 | { | ||
206 | Type: "content", | ||
207 | }, | ||
208 | }, | ||
209 | } | ||
diff --git a/vendor/github.com/hashicorp/hcl2/ext/dynblock/variables_hcldec.go b/vendor/github.com/hashicorp/hcl2/ext/dynblock/variables_hcldec.go new file mode 100644 index 0000000..a078d91 --- /dev/null +++ b/vendor/github.com/hashicorp/hcl2/ext/dynblock/variables_hcldec.go | |||
@@ -0,0 +1,43 @@ | |||
1 | package dynblock | ||
2 | |||
3 | import ( | ||
4 | "github.com/hashicorp/hcl2/hcl" | ||
5 | "github.com/hashicorp/hcl2/hcldec" | ||
6 | ) | ||
7 | |||
8 | // VariablesHCLDec is a wrapper around WalkVariables that uses the given hcldec | ||
9 | // specification to automatically drive the recursive walk through nested | ||
10 | // blocks in the given body. | ||
11 | // | ||
12 | // This is a drop-in replacement for hcldec.Variables which is able to treat | ||
13 | // blocks of type "dynamic" in the same special way that dynblock.Expand would, | ||
14 | // exposing both the variables referenced in the "for_each" and "labels" | ||
15 | // arguments and variables used in the nested "content" block. | ||
16 | func VariablesHCLDec(body hcl.Body, spec hcldec.Spec) []hcl.Traversal { | ||
17 | rootNode := WalkVariables(body) | ||
18 | return walkVariablesWithHCLDec(rootNode, spec) | ||
19 | } | ||
20 | |||
21 | // ExpandVariablesHCLDec is like VariablesHCLDec but it includes only the | ||
22 | // minimal set of variables required to call Expand, ignoring variables that | ||
23 | // are referenced only inside normal block contents. See WalkExpandVariables | ||
24 | // for more information. | ||
25 | func ExpandVariablesHCLDec(body hcl.Body, spec hcldec.Spec) []hcl.Traversal { | ||
26 | rootNode := WalkExpandVariables(body) | ||
27 | return walkVariablesWithHCLDec(rootNode, spec) | ||
28 | } | ||
29 | |||
30 | func walkVariablesWithHCLDec(node WalkVariablesNode, spec hcldec.Spec) []hcl.Traversal { | ||
31 | vars, children := node.Visit(hcldec.ImpliedSchema(spec)) | ||
32 | |||
33 | if len(children) > 0 { | ||
34 | childSpecs := hcldec.ChildBlockTypes(spec) | ||
35 | for _, child := range children { | ||
36 | if childSpec, exists := childSpecs[child.BlockTypeName]; exists { | ||
37 | vars = append(vars, walkVariablesWithHCLDec(child.Node, childSpec)...) | ||
38 | } | ||
39 | } | ||
40 | } | ||
41 | |||
42 | return vars | ||
43 | } | ||
diff --git a/vendor/github.com/hashicorp/hcl2/ext/typeexpr/README.md b/vendor/github.com/hashicorp/hcl2/ext/typeexpr/README.md new file mode 100644 index 0000000..ff2b3f2 --- /dev/null +++ b/vendor/github.com/hashicorp/hcl2/ext/typeexpr/README.md | |||
@@ -0,0 +1,67 @@ | |||
1 | # HCL Type Expressions Extension | ||
2 | |||
3 | This HCL extension defines a convention for describing HCL types using function | ||
4 | call and variable reference syntax, allowing configuration formats to include | ||
5 | type information provided by users. | ||
6 | |||
7 | The type syntax is processed statically from a hcl.Expression, so it cannot | ||
8 | use any of the usual language operators. This is similar to type expressions | ||
9 | in statically-typed programming languages. | ||
10 | |||
11 | ```hcl | ||
12 | variable "example" { | ||
13 | type = list(string) | ||
14 | } | ||
15 | ``` | ||
16 | |||
17 | The extension is built using the `hcl.ExprAsKeyword` and `hcl.ExprCall` | ||
18 | functions, and so it relies on the underlying syntax to define how "keyword" | ||
19 | and "call" are interpreted. The above shows how they are interpreted in | ||
20 | the HCL native syntax, while the following shows the same information | ||
21 | expressed in JSON: | ||
22 | |||
23 | ```json | ||
24 | { | ||
25 | "variable": { | ||
26 | "example": { | ||
27 | "type": "list(string)" | ||
28 | } | ||
29 | } | ||
30 | } | ||
31 | ``` | ||
32 | |||
33 | Notice that since we have additional contextual information that we intend | ||
34 | to allow only calls and keywords the JSON syntax is able to parse the given | ||
35 | string directly as an expression, rather than as a template as would be | ||
36 | the case for normal expression evaluation. | ||
37 | |||
38 | For more information, see [the godoc reference](http://godoc.org/github.com/hashicorp/hcl2/ext/typeexpr). | ||
39 | |||
40 | ## Type Expression Syntax | ||
41 | |||
42 | When expressed in the native syntax, the following expressions are permitted | ||
43 | in a type expression: | ||
44 | |||
45 | * `string` - string | ||
46 | * `bool` - boolean | ||
47 | * `number` - number | ||
48 | * `any` - `cty.DynamicPseudoType` (in function `TypeConstraint` only) | ||
49 | * `list(<type_expr>)` - list of the type given as an argument | ||
50 | * `set(<type_expr>)` - set of the type given as an argument | ||
51 | * `map(<type_expr>)` - map of the type given as an argument | ||
52 | * `tuple([<type_exprs...>])` - tuple with the element types given in the single list argument | ||
53 | * `object({<attr_name>=<type_expr>, ...}` - object with the attributes and corresponding types given in the single map argument | ||
54 | |||
55 | For example: | ||
56 | |||
57 | * `list(string)` | ||
58 | * `object({name=string,age=number})` | ||
59 | * `map(object({name=string,age=number}))` | ||
60 | |||
61 | Note that the object constructor syntax is not fully-general for all possible | ||
62 | object types because it requires the attribute names to be valid identifiers. | ||
63 | In practice it is expected that any time an object type is being fixed for | ||
64 | type checking it will be one that has identifiers as its attributes; object | ||
65 | types with weird attributes generally show up only from arbitrary object | ||
66 | constructors in configuration files, which are usually treated either as maps | ||
67 | or as the dynamic pseudo-type. | ||
diff --git a/vendor/github.com/hashicorp/hcl2/ext/typeexpr/doc.go b/vendor/github.com/hashicorp/hcl2/ext/typeexpr/doc.go new file mode 100644 index 0000000..c4b3795 --- /dev/null +++ b/vendor/github.com/hashicorp/hcl2/ext/typeexpr/doc.go | |||
@@ -0,0 +1,11 @@ | |||
1 | // Package typeexpr extends HCL with a convention for describing HCL types | ||
2 | // within configuration files. | ||
3 | // | ||
4 | // The type syntax is processed statically from a hcl.Expression, so it cannot | ||
5 | // use any of the usual language operators. This is similar to type expressions | ||
6 | // in statically-typed programming languages. | ||
7 | // | ||
8 | // variable "example" { | ||
9 | // type = list(string) | ||
10 | // } | ||
11 | package typeexpr | ||
diff --git a/vendor/github.com/hashicorp/hcl2/ext/typeexpr/get_type.go b/vendor/github.com/hashicorp/hcl2/ext/typeexpr/get_type.go new file mode 100644 index 0000000..a84338a --- /dev/null +++ b/vendor/github.com/hashicorp/hcl2/ext/typeexpr/get_type.go | |||
@@ -0,0 +1,196 @@ | |||
1 | package typeexpr | ||
2 | |||
3 | import ( | ||
4 | "fmt" | ||
5 | |||
6 | "github.com/hashicorp/hcl2/hcl" | ||
7 | "github.com/zclconf/go-cty/cty" | ||
8 | ) | ||
9 | |||
10 | const invalidTypeSummary = "Invalid type specification" | ||
11 | |||
12 | // getType is the internal implementation of both Type and TypeConstraint, | ||
13 | // using the passed flag to distinguish. When constraint is false, the "any" | ||
14 | // keyword will produce an error. | ||
15 | func getType(expr hcl.Expression, constraint bool) (cty.Type, hcl.Diagnostics) { | ||
16 | // First we'll try for one of our keywords | ||
17 | kw := hcl.ExprAsKeyword(expr) | ||
18 | switch kw { | ||
19 | case "bool": | ||
20 | return cty.Bool, nil | ||
21 | case "string": | ||
22 | return cty.String, nil | ||
23 | case "number": | ||
24 | return cty.Number, nil | ||
25 | case "any": | ||
26 | if constraint { | ||
27 | return cty.DynamicPseudoType, nil | ||
28 | } | ||
29 | return cty.DynamicPseudoType, hcl.Diagnostics{{ | ||
30 | Severity: hcl.DiagError, | ||
31 | Summary: invalidTypeSummary, | ||
32 | Detail: fmt.Sprintf("The keyword %q cannot be used in this type specification: an exact type is required.", kw), | ||
33 | Subject: expr.Range().Ptr(), | ||
34 | }} | ||
35 | case "list", "map", "set": | ||
36 | return cty.DynamicPseudoType, hcl.Diagnostics{{ | ||
37 | Severity: hcl.DiagError, | ||
38 | Summary: invalidTypeSummary, | ||
39 | Detail: fmt.Sprintf("The %s type constructor requires one argument specifying the element type.", kw), | ||
40 | Subject: expr.Range().Ptr(), | ||
41 | }} | ||
42 | case "object": | ||
43 | return cty.DynamicPseudoType, hcl.Diagnostics{{ | ||
44 | Severity: hcl.DiagError, | ||
45 | Summary: invalidTypeSummary, | ||
46 | Detail: "The object type constructor requires one argument specifying the attribute types and values as a map.", | ||
47 | Subject: expr.Range().Ptr(), | ||
48 | }} | ||
49 | case "tuple": | ||
50 | return cty.DynamicPseudoType, hcl.Diagnostics{{ | ||
51 | Severity: hcl.DiagError, | ||
52 | Summary: invalidTypeSummary, | ||
53 | Detail: "The tuple type constructor requires one argument specifying the element types as a list.", | ||
54 | Subject: expr.Range().Ptr(), | ||
55 | }} | ||
56 | case "": | ||
57 | // okay! we'll fall through and try processing as a call, then. | ||
58 | default: | ||
59 | return cty.DynamicPseudoType, hcl.Diagnostics{{ | ||
60 | Severity: hcl.DiagError, | ||
61 | Summary: invalidTypeSummary, | ||
62 | Detail: fmt.Sprintf("The keyword %q is not a valid type specification.", kw), | ||
63 | Subject: expr.Range().Ptr(), | ||
64 | }} | ||
65 | } | ||
66 | |||
67 | // If we get down here then our expression isn't just a keyword, so we'll | ||
68 | // try to process it as a call instead. | ||
69 | call, diags := hcl.ExprCall(expr) | ||
70 | if diags.HasErrors() { | ||
71 | return cty.DynamicPseudoType, hcl.Diagnostics{{ | ||
72 | Severity: hcl.DiagError, | ||
73 | Summary: invalidTypeSummary, | ||
74 | Detail: "A type specification is either a primitive type keyword (bool, number, string) or a complex type constructor call, like list(string).", | ||
75 | Subject: expr.Range().Ptr(), | ||
76 | }} | ||
77 | } | ||
78 | |||
79 | switch call.Name { | ||
80 | case "bool", "string", "number", "any": | ||
81 | return cty.DynamicPseudoType, hcl.Diagnostics{{ | ||
82 | Severity: hcl.DiagError, | ||
83 | Summary: invalidTypeSummary, | ||
84 | Detail: fmt.Sprintf("Primitive type keyword %q does not expect arguments.", call.Name), | ||
85 | Subject: &call.ArgsRange, | ||
86 | }} | ||
87 | } | ||
88 | |||
89 | if len(call.Arguments) != 1 { | ||
90 | contextRange := call.ArgsRange | ||
91 | subjectRange := call.ArgsRange | ||
92 | if len(call.Arguments) > 1 { | ||
93 | // If we have too many arguments (as opposed to too _few_) then | ||
94 | // we'll highlight the extraneous arguments as the diagnostic | ||
95 | // subject. | ||
96 | subjectRange = hcl.RangeBetween(call.Arguments[1].Range(), call.Arguments[len(call.Arguments)-1].Range()) | ||
97 | } | ||
98 | |||
99 | switch call.Name { | ||
100 | case "list", "set", "map": | ||
101 | return cty.DynamicPseudoType, hcl.Diagnostics{{ | ||
102 | Severity: hcl.DiagError, | ||
103 | Summary: invalidTypeSummary, | ||
104 | Detail: fmt.Sprintf("The %s type constructor requires one argument specifying the element type.", call.Name), | ||
105 | Subject: &subjectRange, | ||
106 | Context: &contextRange, | ||
107 | }} | ||
108 | case "object": | ||
109 | return cty.DynamicPseudoType, hcl.Diagnostics{{ | ||
110 | Severity: hcl.DiagError, | ||
111 | Summary: invalidTypeSummary, | ||
112 | Detail: "The object type constructor requires one argument specifying the attribute types and values as a map.", | ||
113 | Subject: &subjectRange, | ||
114 | Context: &contextRange, | ||
115 | }} | ||
116 | case "tuple": | ||
117 | return cty.DynamicPseudoType, hcl.Diagnostics{{ | ||
118 | Severity: hcl.DiagError, | ||
119 | Summary: invalidTypeSummary, | ||
120 | Detail: "The tuple type constructor requires one argument specifying the element types as a list.", | ||
121 | Subject: &subjectRange, | ||
122 | Context: &contextRange, | ||
123 | }} | ||
124 | } | ||
125 | } | ||
126 | |||
127 | switch call.Name { | ||
128 | |||
129 | case "list": | ||
130 | ety, diags := getType(call.Arguments[0], constraint) | ||
131 | return cty.List(ety), diags | ||
132 | case "set": | ||
133 | ety, diags := getType(call.Arguments[0], constraint) | ||
134 | return cty.Set(ety), diags | ||
135 | case "map": | ||
136 | ety, diags := getType(call.Arguments[0], constraint) | ||
137 | return cty.Map(ety), diags | ||
138 | case "object": | ||
139 | attrDefs, diags := hcl.ExprMap(call.Arguments[0]) | ||
140 | if diags.HasErrors() { | ||
141 | return cty.DynamicPseudoType, hcl.Diagnostics{{ | ||
142 | Severity: hcl.DiagError, | ||
143 | Summary: invalidTypeSummary, | ||
144 | Detail: "Object type constructor requires a map whose keys are attribute names and whose values are the corresponding attribute types.", | ||
145 | Subject: call.Arguments[0].Range().Ptr(), | ||
146 | Context: expr.Range().Ptr(), | ||
147 | }} | ||
148 | } | ||
149 | |||
150 | atys := make(map[string]cty.Type) | ||
151 | for _, attrDef := range attrDefs { | ||
152 | attrName := hcl.ExprAsKeyword(attrDef.Key) | ||
153 | if attrName == "" { | ||
154 | diags = append(diags, &hcl.Diagnostic{ | ||
155 | Severity: hcl.DiagError, | ||
156 | Summary: invalidTypeSummary, | ||
157 | Detail: "Object constructor map keys must be attribute names.", | ||
158 | Subject: attrDef.Key.Range().Ptr(), | ||
159 | Context: expr.Range().Ptr(), | ||
160 | }) | ||
161 | continue | ||
162 | } | ||
163 | aty, attrDiags := getType(attrDef.Value, constraint) | ||
164 | diags = append(diags, attrDiags...) | ||
165 | atys[attrName] = aty | ||
166 | } | ||
167 | return cty.Object(atys), diags | ||
168 | case "tuple": | ||
169 | elemDefs, diags := hcl.ExprList(call.Arguments[0]) | ||
170 | if diags.HasErrors() { | ||
171 | return cty.DynamicPseudoType, hcl.Diagnostics{{ | ||
172 | Severity: hcl.DiagError, | ||
173 | Summary: invalidTypeSummary, | ||
174 | Detail: "Tuple type constructor requires a list of element types.", | ||
175 | Subject: call.Arguments[0].Range().Ptr(), | ||
176 | Context: expr.Range().Ptr(), | ||
177 | }} | ||
178 | } | ||
179 | etys := make([]cty.Type, len(elemDefs)) | ||
180 | for i, defExpr := range elemDefs { | ||
181 | ety, elemDiags := getType(defExpr, constraint) | ||
182 | diags = append(diags, elemDiags...) | ||
183 | etys[i] = ety | ||
184 | } | ||
185 | return cty.Tuple(etys), diags | ||
186 | default: | ||
187 | // Can't access call.Arguments in this path because we've not validated | ||
188 | // that it contains exactly one expression here. | ||
189 | return cty.DynamicPseudoType, hcl.Diagnostics{{ | ||
190 | Severity: hcl.DiagError, | ||
191 | Summary: invalidTypeSummary, | ||
192 | Detail: fmt.Sprintf("Keyword %q is not a valid type constructor.", call.Name), | ||
193 | Subject: expr.Range().Ptr(), | ||
194 | }} | ||
195 | } | ||
196 | } | ||
diff --git a/vendor/github.com/hashicorp/hcl2/ext/typeexpr/public.go b/vendor/github.com/hashicorp/hcl2/ext/typeexpr/public.go new file mode 100644 index 0000000..e3f5eef --- /dev/null +++ b/vendor/github.com/hashicorp/hcl2/ext/typeexpr/public.go | |||
@@ -0,0 +1,129 @@ | |||
1 | package typeexpr | ||
2 | |||
3 | import ( | ||
4 | "bytes" | ||
5 | "fmt" | ||
6 | "sort" | ||
7 | |||
8 | "github.com/hashicorp/hcl2/hcl/hclsyntax" | ||
9 | |||
10 | "github.com/hashicorp/hcl2/hcl" | ||
11 | "github.com/zclconf/go-cty/cty" | ||
12 | ) | ||
13 | |||
14 | // Type attempts to process the given expression as a type expression and, if | ||
15 | // successful, returns the resulting type. If unsuccessful, error diagnostics | ||
16 | // are returned. | ||
17 | func Type(expr hcl.Expression) (cty.Type, hcl.Diagnostics) { | ||
18 | return getType(expr, false) | ||
19 | } | ||
20 | |||
21 | // TypeConstraint attempts to parse the given expression as a type constraint | ||
22 | // and, if successful, returns the resulting type. If unsuccessful, error | ||
23 | // diagnostics are returned. | ||
24 | // | ||
25 | // A type constraint has the same structure as a type, but it additionally | ||
26 | // allows the keyword "any" to represent cty.DynamicPseudoType, which is often | ||
27 | // used as a wildcard in type checking and type conversion operations. | ||
28 | func TypeConstraint(expr hcl.Expression) (cty.Type, hcl.Diagnostics) { | ||
29 | return getType(expr, true) | ||
30 | } | ||
31 | |||
32 | // TypeString returns a string rendering of the given type as it would be | ||
33 | // expected to appear in the HCL native syntax. | ||
34 | // | ||
35 | // This is primarily intended for showing types to the user in an application | ||
36 | // that uses typexpr, where the user can be assumed to be familiar with the | ||
37 | // type expression syntax. In applications that do not use typeexpr these | ||
38 | // results may be confusing to the user and so type.FriendlyName may be | ||
39 | // preferable, even though it's less precise. | ||
40 | // | ||
41 | // TypeString produces reasonable results only for types like what would be | ||
42 | // produced by the Type and TypeConstraint functions. In particular, it cannot | ||
43 | // support capsule types. | ||
44 | func TypeString(ty cty.Type) string { | ||
45 | // Easy cases first | ||
46 | switch ty { | ||
47 | case cty.String: | ||
48 | return "string" | ||
49 | case cty.Bool: | ||
50 | return "bool" | ||
51 | case cty.Number: | ||
52 | return "number" | ||
53 | case cty.DynamicPseudoType: | ||
54 | return "any" | ||
55 | } | ||
56 | |||
57 | if ty.IsCapsuleType() { | ||
58 | panic("TypeString does not support capsule types") | ||
59 | } | ||
60 | |||
61 | if ty.IsCollectionType() { | ||
62 | ety := ty.ElementType() | ||
63 | etyString := TypeString(ety) | ||
64 | switch { | ||
65 | case ty.IsListType(): | ||
66 | return fmt.Sprintf("list(%s)", etyString) | ||
67 | case ty.IsSetType(): | ||
68 | return fmt.Sprintf("set(%s)", etyString) | ||
69 | case ty.IsMapType(): | ||
70 | return fmt.Sprintf("map(%s)", etyString) | ||
71 | default: | ||
72 | // Should never happen because the above is exhaustive | ||
73 | panic("unsupported collection type") | ||
74 | } | ||
75 | } | ||
76 | |||
77 | if ty.IsObjectType() { | ||
78 | var buf bytes.Buffer | ||
79 | buf.WriteString("object({") | ||
80 | atys := ty.AttributeTypes() | ||
81 | names := make([]string, 0, len(atys)) | ||
82 | for name := range atys { | ||
83 | names = append(names, name) | ||
84 | } | ||
85 | sort.Strings(names) | ||
86 | first := true | ||
87 | for _, name := range names { | ||
88 | aty := atys[name] | ||
89 | if !first { | ||
90 | buf.WriteByte(',') | ||
91 | } | ||
92 | if !hclsyntax.ValidIdentifier(name) { | ||
93 | // Should never happen for any type produced by this package, | ||
94 | // but we'll do something reasonable here just so we don't | ||
95 | // produce garbage if someone gives us a hand-assembled object | ||
96 | // type that has weird attribute names. | ||
97 | // Using Go-style quoting here isn't perfect, since it doesn't | ||
98 | // exactly match HCL syntax, but it's fine for an edge-case. | ||
99 | buf.WriteString(fmt.Sprintf("%q", name)) | ||
100 | } else { | ||
101 | buf.WriteString(name) | ||
102 | } | ||
103 | buf.WriteByte('=') | ||
104 | buf.WriteString(TypeString(aty)) | ||
105 | first = false | ||
106 | } | ||
107 | buf.WriteString("})") | ||
108 | return buf.String() | ||
109 | } | ||
110 | |||
111 | if ty.IsTupleType() { | ||
112 | var buf bytes.Buffer | ||
113 | buf.WriteString("tuple([") | ||
114 | etys := ty.TupleElementTypes() | ||
115 | first := true | ||
116 | for _, ety := range etys { | ||
117 | if !first { | ||
118 | buf.WriteByte(',') | ||
119 | } | ||
120 | buf.WriteString(TypeString(ety)) | ||
121 | first = false | ||
122 | } | ||
123 | buf.WriteString("])") | ||
124 | return buf.String() | ||
125 | } | ||
126 | |||
127 | // Should never happen because we covered all cases above. | ||
128 | panic(fmt.Errorf("unsupported type %#v", ty)) | ||
129 | } | ||
diff --git a/vendor/github.com/hashicorp/hcl2/gohcl/doc.go b/vendor/github.com/hashicorp/hcl2/gohcl/doc.go index 8500214..aa3c6ea 100644 --- a/vendor/github.com/hashicorp/hcl2/gohcl/doc.go +++ b/vendor/github.com/hashicorp/hcl2/gohcl/doc.go | |||
@@ -40,6 +40,10 @@ | |||
40 | // present then any attributes or blocks not matched by another valid tag | 40 | // present then any attributes or blocks not matched by another valid tag |
41 | // will cause an error diagnostic. | 41 | // will cause an error diagnostic. |
42 | // | 42 | // |
43 | // Only a subset of this tagging/typing vocabulary is supported for the | ||
44 | // "Encode" family of functions. See the EncodeIntoBody docs for full details | ||
45 | // on the constraints there. | ||
46 | // | ||
43 | // Broadly-speaking this package deals with two types of error. The first is | 47 | // Broadly-speaking this package deals with two types of error. The first is |
44 | // errors in the configuration itself, which are returned as diagnostics | 48 | // errors in the configuration itself, which are returned as diagnostics |
45 | // written with the configuration author as the target audience. The second | 49 | // written with the configuration author as the target audience. The second |
diff --git a/vendor/github.com/hashicorp/hcl2/gohcl/encode.go b/vendor/github.com/hashicorp/hcl2/gohcl/encode.go new file mode 100644 index 0000000..3cbf7e4 --- /dev/null +++ b/vendor/github.com/hashicorp/hcl2/gohcl/encode.go | |||
@@ -0,0 +1,191 @@ | |||
1 | package gohcl | ||
2 | |||
3 | import ( | ||
4 | "fmt" | ||
5 | "reflect" | ||
6 | "sort" | ||
7 | |||
8 | "github.com/hashicorp/hcl2/hclwrite" | ||
9 | "github.com/zclconf/go-cty/cty/gocty" | ||
10 | ) | ||
11 | |||
12 | // EncodeIntoBody replaces the contents of the given hclwrite Body with | ||
13 | // attributes and blocks derived from the given value, which must be a | ||
14 | // struct value or a pointer to a struct value with the struct tags defined | ||
15 | // in this package. | ||
16 | // | ||
17 | // This function can work only with fully-decoded data. It will ignore any | ||
18 | // fields tagged as "remain", any fields that decode attributes into either | ||
19 | // hcl.Attribute or hcl.Expression values, and any fields that decode blocks | ||
20 | // into hcl.Attributes values. This function does not have enough information | ||
21 | // to complete the decoding of these types. | ||
22 | // | ||
23 | // Any fields tagged as "label" are ignored by this function. Use EncodeAsBlock | ||
24 | // to produce a whole hclwrite.Block including block labels. | ||
25 | // | ||
26 | // As long as a suitable value is given to encode and the destination body | ||
27 | // is non-nil, this function will always complete. It will panic in case of | ||
28 | // any errors in the calling program, such as passing an inappropriate type | ||
29 | // or a nil body. | ||
30 | // | ||
31 | // The layout of the resulting HCL source is derived from the ordering of | ||
32 | // the struct fields, with blank lines around nested blocks of different types. | ||
33 | // Fields representing attributes should usually precede those representing | ||
34 | // blocks so that the attributes can group togather in the result. For more | ||
35 | // control, use the hclwrite API directly. | ||
36 | func EncodeIntoBody(val interface{}, dst *hclwrite.Body) { | ||
37 | rv := reflect.ValueOf(val) | ||
38 | ty := rv.Type() | ||
39 | if ty.Kind() == reflect.Ptr { | ||
40 | rv = rv.Elem() | ||
41 | ty = rv.Type() | ||
42 | } | ||
43 | if ty.Kind() != reflect.Struct { | ||
44 | panic(fmt.Sprintf("value is %s, not struct", ty.Kind())) | ||
45 | } | ||
46 | |||
47 | tags := getFieldTags(ty) | ||
48 | populateBody(rv, ty, tags, dst) | ||
49 | } | ||
50 | |||
51 | // EncodeAsBlock creates a new hclwrite.Block populated with the data from | ||
52 | // the given value, which must be a struct or pointer to struct with the | ||
53 | // struct tags defined in this package. | ||
54 | // | ||
55 | // If the given struct type has fields tagged with "label" tags then they | ||
56 | // will be used in order to annotate the created block with labels. | ||
57 | // | ||
58 | // This function has the same constraints as EncodeIntoBody and will panic | ||
59 | // if they are violated. | ||
60 | func EncodeAsBlock(val interface{}, blockType string) *hclwrite.Block { | ||
61 | rv := reflect.ValueOf(val) | ||
62 | ty := rv.Type() | ||
63 | if ty.Kind() == reflect.Ptr { | ||
64 | rv = rv.Elem() | ||
65 | ty = rv.Type() | ||
66 | } | ||
67 | if ty.Kind() != reflect.Struct { | ||
68 | panic(fmt.Sprintf("value is %s, not struct", ty.Kind())) | ||
69 | } | ||
70 | |||
71 | tags := getFieldTags(ty) | ||
72 | labels := make([]string, len(tags.Labels)) | ||
73 | for i, lf := range tags.Labels { | ||
74 | lv := rv.Field(lf.FieldIndex) | ||
75 | // We just stringify whatever we find. It should always be a string | ||
76 | // but if not then we'll still do something reasonable. | ||
77 | labels[i] = fmt.Sprintf("%s", lv.Interface()) | ||
78 | } | ||
79 | |||
80 | block := hclwrite.NewBlock(blockType, labels) | ||
81 | populateBody(rv, ty, tags, block.Body()) | ||
82 | return block | ||
83 | } | ||
84 | |||
85 | func populateBody(rv reflect.Value, ty reflect.Type, tags *fieldTags, dst *hclwrite.Body) { | ||
86 | nameIdxs := make(map[string]int, len(tags.Attributes)+len(tags.Blocks)) | ||
87 | namesOrder := make([]string, 0, len(tags.Attributes)+len(tags.Blocks)) | ||
88 | for n, i := range tags.Attributes { | ||
89 | nameIdxs[n] = i | ||
90 | namesOrder = append(namesOrder, n) | ||
91 | } | ||
92 | for n, i := range tags.Blocks { | ||
93 | nameIdxs[n] = i | ||
94 | namesOrder = append(namesOrder, n) | ||
95 | } | ||
96 | sort.SliceStable(namesOrder, func(i, j int) bool { | ||
97 | ni, nj := namesOrder[i], namesOrder[j] | ||
98 | return nameIdxs[ni] < nameIdxs[nj] | ||
99 | }) | ||
100 | |||
101 | dst.Clear() | ||
102 | |||
103 | prevWasBlock := false | ||
104 | for _, name := range namesOrder { | ||
105 | fieldIdx := nameIdxs[name] | ||
106 | field := ty.Field(fieldIdx) | ||
107 | fieldTy := field.Type | ||
108 | fieldVal := rv.Field(fieldIdx) | ||
109 | |||
110 | if fieldTy.Kind() == reflect.Ptr { | ||
111 | fieldTy = fieldTy.Elem() | ||
112 | fieldVal = fieldVal.Elem() | ||
113 | } | ||
114 | |||
115 | if _, isAttr := tags.Attributes[name]; isAttr { | ||
116 | |||
117 | if exprType.AssignableTo(fieldTy) || attrType.AssignableTo(fieldTy) { | ||
118 | continue // ignore undecoded fields | ||
119 | } | ||
120 | if !fieldVal.IsValid() { | ||
121 | continue // ignore (field value is nil pointer) | ||
122 | } | ||
123 | if fieldTy.Kind() == reflect.Ptr && fieldVal.IsNil() { | ||
124 | continue // ignore | ||
125 | } | ||
126 | if prevWasBlock { | ||
127 | dst.AppendNewline() | ||
128 | prevWasBlock = false | ||
129 | } | ||
130 | |||
131 | valTy, err := gocty.ImpliedType(fieldVal.Interface()) | ||
132 | if err != nil { | ||
133 | panic(fmt.Sprintf("cannot encode %T as HCL expression: %s", fieldVal.Interface(), err)) | ||
134 | } | ||
135 | |||
136 | val, err := gocty.ToCtyValue(fieldVal.Interface(), valTy) | ||
137 | if err != nil { | ||
138 | // This should never happen, since we should always be able | ||
139 | // to decode into the implied type. | ||
140 | panic(fmt.Sprintf("failed to encode %T as %#v: %s", fieldVal.Interface(), valTy, err)) | ||
141 | } | ||
142 | |||
143 | dst.SetAttributeValue(name, val) | ||
144 | |||
145 | } else { // must be a block, then | ||
146 | elemTy := fieldTy | ||
147 | isSeq := false | ||
148 | if elemTy.Kind() == reflect.Slice || elemTy.Kind() == reflect.Array { | ||
149 | isSeq = true | ||
150 | elemTy = elemTy.Elem() | ||
151 | } | ||
152 | |||
153 | if bodyType.AssignableTo(elemTy) || attrsType.AssignableTo(elemTy) { | ||
154 | continue // ignore undecoded fields | ||
155 | } | ||
156 | prevWasBlock = false | ||
157 | |||
158 | if isSeq { | ||
159 | l := fieldVal.Len() | ||
160 | for i := 0; i < l; i++ { | ||
161 | elemVal := fieldVal.Index(i) | ||
162 | if !elemVal.IsValid() { | ||
163 | continue // ignore (elem value is nil pointer) | ||
164 | } | ||
165 | if elemTy.Kind() == reflect.Ptr && elemVal.IsNil() { | ||
166 | continue // ignore | ||
167 | } | ||
168 | block := EncodeAsBlock(elemVal.Interface(), name) | ||
169 | if !prevWasBlock { | ||
170 | dst.AppendNewline() | ||
171 | prevWasBlock = true | ||
172 | } | ||
173 | dst.AppendBlock(block) | ||
174 | } | ||
175 | } else { | ||
176 | if !fieldVal.IsValid() { | ||
177 | continue // ignore (field value is nil pointer) | ||
178 | } | ||
179 | if elemTy.Kind() == reflect.Ptr && fieldVal.IsNil() { | ||
180 | continue // ignore | ||
181 | } | ||
182 | block := EncodeAsBlock(fieldVal.Interface(), name) | ||
183 | if !prevWasBlock { | ||
184 | dst.AppendNewline() | ||
185 | prevWasBlock = true | ||
186 | } | ||
187 | dst.AppendBlock(block) | ||
188 | } | ||
189 | } | ||
190 | } | ||
191 | } | ||
diff --git a/vendor/github.com/hashicorp/hcl2/hcl/diagnostic.go b/vendor/github.com/hashicorp/hcl2/hcl/diagnostic.go index 6ecf744..c320961 100644 --- a/vendor/github.com/hashicorp/hcl2/hcl/diagnostic.go +++ b/vendor/github.com/hashicorp/hcl2/hcl/diagnostic.go | |||
@@ -26,14 +26,43 @@ const ( | |||
26 | type Diagnostic struct { | 26 | type Diagnostic struct { |
27 | Severity DiagnosticSeverity | 27 | Severity DiagnosticSeverity |
28 | 28 | ||
29 | // Summary and detail contain the English-language description of the | 29 | // Summary and Detail contain the English-language description of the |
30 | // problem. Summary is a terse description of the general problem and | 30 | // problem. Summary is a terse description of the general problem and |
31 | // detail is a more elaborate, often-multi-sentence description of | 31 | // detail is a more elaborate, often-multi-sentence description of |
32 | // the probem and what might be done to solve it. | 32 | // the probem and what might be done to solve it. |
33 | Summary string | 33 | Summary string |
34 | Detail string | 34 | Detail string |
35 | |||
36 | // Subject and Context are both source ranges relating to the diagnostic. | ||
37 | // | ||
38 | // Subject is a tight range referring to exactly the construct that | ||
39 | // is problematic, while Context is an optional broader range (which should | ||
40 | // fully contain Subject) that ought to be shown around Subject when | ||
41 | // generating isolated source-code snippets in diagnostic messages. | ||
42 | // If Context is nil, the Subject is also the Context. | ||
43 | // | ||
44 | // Some diagnostics have no source ranges at all. If Context is set then | ||
45 | // Subject should always also be set. | ||
35 | Subject *Range | 46 | Subject *Range |
36 | Context *Range | 47 | Context *Range |
48 | |||
49 | // For diagnostics that occur when evaluating an expression, Expression | ||
50 | // may refer to that expression and EvalContext may point to the | ||
51 | // EvalContext that was active when evaluating it. This may allow for the | ||
52 | // inclusion of additional useful information when rendering a diagnostic | ||
53 | // message to the user. | ||
54 | // | ||
55 | // It is not always possible to select a single EvalContext for a | ||
56 | // diagnostic, and so in some cases this field may be nil even when an | ||
57 | // expression causes a problem. | ||
58 | // | ||
59 | // EvalContexts form a tree, so the given EvalContext may refer to a parent | ||
60 | // which in turn refers to another parent, etc. For a full picture of all | ||
61 | // of the active variables and functions the caller must walk up this | ||
62 | // chain, preferring definitions that are "closer" to the expression in | ||
63 | // case of colliding names. | ||
64 | Expression Expression | ||
65 | EvalContext *EvalContext | ||
37 | } | 66 | } |
38 | 67 | ||
39 | // Diagnostics is a list of Diagnostic instances. | 68 | // Diagnostics is a list of Diagnostic instances. |
@@ -96,6 +125,17 @@ func (d Diagnostics) HasErrors() bool { | |||
96 | return false | 125 | return false |
97 | } | 126 | } |
98 | 127 | ||
128 | func (d Diagnostics) Errs() []error { | ||
129 | var errs []error | ||
130 | for _, diag := range d { | ||
131 | if diag.Severity == DiagError { | ||
132 | errs = append(errs, diag) | ||
133 | } | ||
134 | } | ||
135 | |||
136 | return errs | ||
137 | } | ||
138 | |||
99 | // A DiagnosticWriter emits diagnostics somehow. | 139 | // A DiagnosticWriter emits diagnostics somehow. |
100 | type DiagnosticWriter interface { | 140 | type DiagnosticWriter interface { |
101 | WriteDiagnostic(*Diagnostic) error | 141 | WriteDiagnostic(*Diagnostic) error |
diff --git a/vendor/github.com/hashicorp/hcl2/hcl/diagnostic_text.go b/vendor/github.com/hashicorp/hcl2/hcl/diagnostic_text.go index dfa473a..0b4a262 100644 --- a/vendor/github.com/hashicorp/hcl2/hcl/diagnostic_text.go +++ b/vendor/github.com/hashicorp/hcl2/hcl/diagnostic_text.go | |||
@@ -2,11 +2,14 @@ package hcl | |||
2 | 2 | ||
3 | import ( | 3 | import ( |
4 | "bufio" | 4 | "bufio" |
5 | "bytes" | ||
5 | "errors" | 6 | "errors" |
6 | "fmt" | 7 | "fmt" |
7 | "io" | 8 | "io" |
9 | "sort" | ||
8 | 10 | ||
9 | wordwrap "github.com/mitchellh/go-wordwrap" | 11 | wordwrap "github.com/mitchellh/go-wordwrap" |
12 | "github.com/zclconf/go-cty/cty" | ||
10 | ) | 13 | ) |
11 | 14 | ||
12 | type diagnosticTextWriter struct { | 15 | type diagnosticTextWriter struct { |
@@ -133,6 +136,62 @@ func (w *diagnosticTextWriter) WriteDiagnostic(diag *Diagnostic) error { | |||
133 | 136 | ||
134 | w.wr.Write([]byte{'\n'}) | 137 | w.wr.Write([]byte{'\n'}) |
135 | } | 138 | } |
139 | |||
140 | if diag.Expression != nil && diag.EvalContext != nil { | ||
141 | // We will attempt to render the values for any variables | ||
142 | // referenced in the given expression as additional context, for | ||
143 | // situations where the same expression is evaluated multiple | ||
144 | // times in different scopes. | ||
145 | expr := diag.Expression | ||
146 | ctx := diag.EvalContext | ||
147 | |||
148 | vars := expr.Variables() | ||
149 | stmts := make([]string, 0, len(vars)) | ||
150 | seen := make(map[string]struct{}, len(vars)) | ||
151 | for _, traversal := range vars { | ||
152 | val, diags := traversal.TraverseAbs(ctx) | ||
153 | if diags.HasErrors() { | ||
154 | // Skip anything that generates errors, since we probably | ||
155 | // already have the same error in our diagnostics set | ||
156 | // already. | ||
157 | continue | ||
158 | } | ||
159 | |||
160 | traversalStr := w.traversalStr(traversal) | ||
161 | if _, exists := seen[traversalStr]; exists { | ||
162 | continue // don't show duplicates when the same variable is referenced multiple times | ||
163 | } | ||
164 | switch { | ||
165 | case !val.IsKnown(): | ||
166 | // Can't say anything about this yet, then. | ||
167 | continue | ||
168 | case val.IsNull(): | ||
169 | stmts = append(stmts, fmt.Sprintf("%s set to null", traversalStr)) | ||
170 | default: | ||
171 | stmts = append(stmts, fmt.Sprintf("%s as %s", traversalStr, w.valueStr(val))) | ||
172 | } | ||
173 | seen[traversalStr] = struct{}{} | ||
174 | } | ||
175 | |||
176 | sort.Strings(stmts) // FIXME: Should maybe use a traversal-aware sort that can sort numeric indexes properly? | ||
177 | last := len(stmts) - 1 | ||
178 | |||
179 | for i, stmt := range stmts { | ||
180 | switch i { | ||
181 | case 0: | ||
182 | w.wr.Write([]byte{'w', 'i', 't', 'h', ' '}) | ||
183 | default: | ||
184 | w.wr.Write([]byte{' ', ' ', ' ', ' ', ' '}) | ||
185 | } | ||
186 | w.wr.Write([]byte(stmt)) | ||
187 | switch i { | ||
188 | case last: | ||
189 | w.wr.Write([]byte{'.', '\n', '\n'}) | ||
190 | default: | ||
191 | w.wr.Write([]byte{',', '\n'}) | ||
192 | } | ||
193 | } | ||
194 | } | ||
136 | } | 195 | } |
137 | 196 | ||
138 | if diag.Detail != "" { | 197 | if diag.Detail != "" { |
@@ -156,6 +215,90 @@ func (w *diagnosticTextWriter) WriteDiagnostics(diags Diagnostics) error { | |||
156 | return nil | 215 | return nil |
157 | } | 216 | } |
158 | 217 | ||
218 | func (w *diagnosticTextWriter) traversalStr(traversal Traversal) string { | ||
219 | // This is a specialized subset of traversal rendering tailored to | ||
220 | // producing helpful contextual messages in diagnostics. It is not | ||
221 | // comprehensive nor intended to be used for other purposes. | ||
222 | |||
223 | var buf bytes.Buffer | ||
224 | for _, step := range traversal { | ||
225 | switch tStep := step.(type) { | ||
226 | case TraverseRoot: | ||
227 | buf.WriteString(tStep.Name) | ||
228 | case TraverseAttr: | ||
229 | buf.WriteByte('.') | ||
230 | buf.WriteString(tStep.Name) | ||
231 | case TraverseIndex: | ||
232 | buf.WriteByte('[') | ||
233 | if keyTy := tStep.Key.Type(); keyTy.IsPrimitiveType() { | ||
234 | buf.WriteString(w.valueStr(tStep.Key)) | ||
235 | } else { | ||
236 | // We'll just use a placeholder for more complex values, | ||
237 | // since otherwise our result could grow ridiculously long. | ||
238 | buf.WriteString("...") | ||
239 | } | ||
240 | buf.WriteByte(']') | ||
241 | } | ||
242 | } | ||
243 | return buf.String() | ||
244 | } | ||
245 | |||
246 | func (w *diagnosticTextWriter) valueStr(val cty.Value) string { | ||
247 | // This is a specialized subset of value rendering tailored to producing | ||
248 | // helpful but concise messages in diagnostics. It is not comprehensive | ||
249 | // nor intended to be used for other purposes. | ||
250 | |||
251 | ty := val.Type() | ||
252 | switch { | ||
253 | case val.IsNull(): | ||
254 | return "null" | ||
255 | case !val.IsKnown(): | ||
256 | // Should never happen here because we should filter before we get | ||
257 | // in here, but we'll do something reasonable rather than panic. | ||
258 | return "(not yet known)" | ||
259 | case ty == cty.Bool: | ||
260 | if val.True() { | ||
261 | return "true" | ||
262 | } | ||
263 | return "false" | ||
264 | case ty == cty.Number: | ||
265 | bf := val.AsBigFloat() | ||
266 | return bf.Text('g', 10) | ||
267 | case ty == cty.String: | ||
268 | // Go string syntax is not exactly the same as HCL native string syntax, | ||
269 | // but we'll accept the minor edge-cases where this is different here | ||
270 | // for now, just to get something reasonable here. | ||
271 | return fmt.Sprintf("%q", val.AsString()) | ||
272 | case ty.IsCollectionType() || ty.IsTupleType(): | ||
273 | l := val.LengthInt() | ||
274 | switch l { | ||
275 | case 0: | ||
276 | return "empty " + ty.FriendlyName() | ||
277 | case 1: | ||
278 | return ty.FriendlyName() + " with 1 element" | ||
279 | default: | ||
280 | return fmt.Sprintf("%s with %d elements", ty.FriendlyName(), l) | ||
281 | } | ||
282 | case ty.IsObjectType(): | ||
283 | atys := ty.AttributeTypes() | ||
284 | l := len(atys) | ||
285 | switch l { | ||
286 | case 0: | ||
287 | return "object with no attributes" | ||
288 | case 1: | ||
289 | var name string | ||
290 | for k := range atys { | ||
291 | name = k | ||
292 | } | ||
293 | return fmt.Sprintf("object with 1 attribute %q", name) | ||
294 | default: | ||
295 | return fmt.Sprintf("object with %d attributes", l) | ||
296 | } | ||
297 | default: | ||
298 | return ty.FriendlyName() | ||
299 | } | ||
300 | } | ||
301 | |||
159 | func contextString(file *File, offset int) string { | 302 | func contextString(file *File, offset int) string { |
160 | type contextStringer interface { | 303 | type contextStringer interface { |
161 | ContextString(offset int) string | 304 | ContextString(offset int) string |
diff --git a/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/diagnostics.go b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/diagnostics.go new file mode 100644 index 0000000..94eaf58 --- /dev/null +++ b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/diagnostics.go | |||
@@ -0,0 +1,23 @@ | |||
1 | package hclsyntax | ||
2 | |||
3 | import ( | ||
4 | "github.com/hashicorp/hcl2/hcl" | ||
5 | ) | ||
6 | |||
7 | // setDiagEvalContext is an internal helper that will impose a particular | ||
8 | // EvalContext on a set of diagnostics in-place, for any diagnostic that | ||
9 | // does not already have an EvalContext set. | ||
10 | // | ||
11 | // We generally expect diagnostics to be immutable, but this is safe to use | ||
12 | // on any Diagnostics where none of the contained Diagnostic objects have yet | ||
13 | // been seen by a caller. Its purpose is to apply additional context to a | ||
14 | // set of diagnostics produced by a "deeper" component as the stack unwinds | ||
15 | // during expression evaluation. | ||
16 | func setDiagEvalContext(diags hcl.Diagnostics, expr hcl.Expression, ctx *hcl.EvalContext) { | ||
17 | for _, diag := range diags { | ||
18 | if diag.Expression == nil { | ||
19 | diag.Expression = expr | ||
20 | diag.EvalContext = ctx | ||
21 | } | ||
22 | } | ||
23 | } | ||
diff --git a/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/expression.go b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/expression.go index cfc7cd9..26819a2 100644 --- a/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/expression.go +++ b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/expression.go | |||
@@ -2,6 +2,7 @@ package hclsyntax | |||
2 | 2 | ||
3 | import ( | 3 | import ( |
4 | "fmt" | 4 | "fmt" |
5 | "sync" | ||
5 | 6 | ||
6 | "github.com/hashicorp/hcl2/hcl" | 7 | "github.com/hashicorp/hcl2/hcl" |
7 | "github.com/zclconf/go-cty/cty" | 8 | "github.com/zclconf/go-cty/cty" |
@@ -104,7 +105,9 @@ func (e *ScopeTraversalExpr) walkChildNodes(w internalWalkFunc) { | |||
104 | } | 105 | } |
105 | 106 | ||
106 | func (e *ScopeTraversalExpr) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) { | 107 | func (e *ScopeTraversalExpr) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) { |
107 | return e.Traversal.TraverseAbs(ctx) | 108 | val, diags := e.Traversal.TraverseAbs(ctx) |
109 | setDiagEvalContext(diags, e, ctx) | ||
110 | return val, diags | ||
108 | } | 111 | } |
109 | 112 | ||
110 | func (e *ScopeTraversalExpr) Range() hcl.Range { | 113 | func (e *ScopeTraversalExpr) Range() hcl.Range { |
@@ -129,12 +132,13 @@ type RelativeTraversalExpr struct { | |||
129 | } | 132 | } |
130 | 133 | ||
131 | func (e *RelativeTraversalExpr) walkChildNodes(w internalWalkFunc) { | 134 | func (e *RelativeTraversalExpr) walkChildNodes(w internalWalkFunc) { |
132 | // Scope traversals have no child nodes | 135 | w(e.Source) |
133 | } | 136 | } |
134 | 137 | ||
135 | func (e *RelativeTraversalExpr) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) { | 138 | func (e *RelativeTraversalExpr) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) { |
136 | src, diags := e.Source.Value(ctx) | 139 | src, diags := e.Source.Value(ctx) |
137 | ret, travDiags := e.Traversal.TraverseRel(src) | 140 | ret, travDiags := e.Traversal.TraverseRel(src) |
141 | setDiagEvalContext(travDiags, e, ctx) | ||
138 | diags = append(diags, travDiags...) | 142 | diags = append(diags, travDiags...) |
139 | return ret, diags | 143 | return ret, diags |
140 | } | 144 | } |
@@ -177,8 +181,8 @@ type FunctionCallExpr struct { | |||
177 | } | 181 | } |
178 | 182 | ||
179 | func (e *FunctionCallExpr) walkChildNodes(w internalWalkFunc) { | 183 | func (e *FunctionCallExpr) walkChildNodes(w internalWalkFunc) { |
180 | for i, arg := range e.Args { | 184 | for _, arg := range e.Args { |
181 | e.Args[i] = w(arg).(Expression) | 185 | w(arg) |
182 | } | 186 | } |
183 | } | 187 | } |
184 | 188 | ||
@@ -206,10 +210,12 @@ func (e *FunctionCallExpr) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnosti | |||
206 | if !hasNonNilMap { | 210 | if !hasNonNilMap { |
207 | return cty.DynamicVal, hcl.Diagnostics{ | 211 | return cty.DynamicVal, hcl.Diagnostics{ |
208 | { | 212 | { |
209 | Severity: hcl.DiagError, | 213 | Severity: hcl.DiagError, |
210 | Summary: "Function calls not allowed", | 214 | Summary: "Function calls not allowed", |
211 | Detail: "Functions may not be called here.", | 215 | Detail: "Functions may not be called here.", |
212 | Subject: e.Range().Ptr(), | 216 | Subject: e.Range().Ptr(), |
217 | Expression: e, | ||
218 | EvalContext: ctx, | ||
213 | }, | 219 | }, |
214 | } | 220 | } |
215 | } | 221 | } |
@@ -225,11 +231,13 @@ func (e *FunctionCallExpr) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnosti | |||
225 | 231 | ||
226 | return cty.DynamicVal, hcl.Diagnostics{ | 232 | return cty.DynamicVal, hcl.Diagnostics{ |
227 | { | 233 | { |
228 | Severity: hcl.DiagError, | 234 | Severity: hcl.DiagError, |
229 | Summary: "Call to unknown function", | 235 | Summary: "Call to unknown function", |
230 | Detail: fmt.Sprintf("There is no function named %q.%s", e.Name, suggestion), | 236 | Detail: fmt.Sprintf("There is no function named %q.%s", e.Name, suggestion), |
231 | Subject: &e.NameRange, | 237 | Subject: &e.NameRange, |
232 | Context: e.Range().Ptr(), | 238 | Context: e.Range().Ptr(), |
239 | Expression: e, | ||
240 | EvalContext: ctx, | ||
233 | }, | 241 | }, |
234 | } | 242 | } |
235 | } | 243 | } |
@@ -254,11 +262,13 @@ func (e *FunctionCallExpr) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnosti | |||
254 | case expandVal.Type().IsTupleType() || expandVal.Type().IsListType() || expandVal.Type().IsSetType(): | 262 | case expandVal.Type().IsTupleType() || expandVal.Type().IsListType() || expandVal.Type().IsSetType(): |
255 | if expandVal.IsNull() { | 263 | if expandVal.IsNull() { |
256 | diags = append(diags, &hcl.Diagnostic{ | 264 | diags = append(diags, &hcl.Diagnostic{ |
257 | Severity: hcl.DiagError, | 265 | Severity: hcl.DiagError, |
258 | Summary: "Invalid expanding argument value", | 266 | Summary: "Invalid expanding argument value", |
259 | Detail: "The expanding argument (indicated by ...) must not be null.", | 267 | Detail: "The expanding argument (indicated by ...) must not be null.", |
260 | Context: expandExpr.Range().Ptr(), | 268 | Subject: expandExpr.Range().Ptr(), |
261 | Subject: e.Range().Ptr(), | 269 | Context: e.Range().Ptr(), |
270 | Expression: expandExpr, | ||
271 | EvalContext: ctx, | ||
262 | }) | 272 | }) |
263 | return cty.DynamicVal, diags | 273 | return cty.DynamicVal, diags |
264 | } | 274 | } |
@@ -279,11 +289,13 @@ func (e *FunctionCallExpr) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnosti | |||
279 | args = newArgs | 289 | args = newArgs |
280 | default: | 290 | default: |
281 | diags = append(diags, &hcl.Diagnostic{ | 291 | diags = append(diags, &hcl.Diagnostic{ |
282 | Severity: hcl.DiagError, | 292 | Severity: hcl.DiagError, |
283 | Summary: "Invalid expanding argument value", | 293 | Summary: "Invalid expanding argument value", |
284 | Detail: "The expanding argument (indicated by ...) must be of a tuple, list, or set type.", | 294 | Detail: "The expanding argument (indicated by ...) must be of a tuple, list, or set type.", |
285 | Context: expandExpr.Range().Ptr(), | 295 | Subject: expandExpr.Range().Ptr(), |
286 | Subject: e.Range().Ptr(), | 296 | Context: e.Range().Ptr(), |
297 | Expression: expandExpr, | ||
298 | EvalContext: ctx, | ||
287 | }) | 299 | }) |
288 | return cty.DynamicVal, diags | 300 | return cty.DynamicVal, diags |
289 | } | 301 | } |
@@ -303,8 +315,10 @@ func (e *FunctionCallExpr) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnosti | |||
303 | "Function %q expects%s %d argument(s). Missing value for %q.", | 315 | "Function %q expects%s %d argument(s). Missing value for %q.", |
304 | e.Name, qual, len(params), missing.Name, | 316 | e.Name, qual, len(params), missing.Name, |
305 | ), | 317 | ), |
306 | Subject: &e.CloseParenRange, | 318 | Subject: &e.CloseParenRange, |
307 | Context: e.Range().Ptr(), | 319 | Context: e.Range().Ptr(), |
320 | Expression: e, | ||
321 | EvalContext: ctx, | ||
308 | }, | 322 | }, |
309 | } | 323 | } |
310 | } | 324 | } |
@@ -318,8 +332,10 @@ func (e *FunctionCallExpr) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnosti | |||
318 | "Function %q expects only %d argument(s).", | 332 | "Function %q expects only %d argument(s).", |
319 | e.Name, len(params), | 333 | e.Name, len(params), |
320 | ), | 334 | ), |
321 | Subject: args[len(params)].StartRange().Ptr(), | 335 | Subject: args[len(params)].StartRange().Ptr(), |
322 | Context: e.Range().Ptr(), | 336 | Context: e.Range().Ptr(), |
337 | Expression: e, | ||
338 | EvalContext: ctx, | ||
323 | }, | 339 | }, |
324 | } | 340 | } |
325 | } | 341 | } |
@@ -349,8 +365,10 @@ func (e *FunctionCallExpr) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnosti | |||
349 | "Invalid value for %q parameter: %s.", | 365 | "Invalid value for %q parameter: %s.", |
350 | param.Name, err, | 366 | param.Name, err, |
351 | ), | 367 | ), |
352 | Subject: argExpr.StartRange().Ptr(), | 368 | Subject: argExpr.StartRange().Ptr(), |
353 | Context: e.Range().Ptr(), | 369 | Context: e.Range().Ptr(), |
370 | Expression: argExpr, | ||
371 | EvalContext: ctx, | ||
354 | }) | 372 | }) |
355 | } | 373 | } |
356 | 374 | ||
@@ -386,8 +404,10 @@ func (e *FunctionCallExpr) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnosti | |||
386 | "Invalid value for %q parameter: %s.", | 404 | "Invalid value for %q parameter: %s.", |
387 | param.Name, err, | 405 | param.Name, err, |
388 | ), | 406 | ), |
389 | Subject: argExpr.StartRange().Ptr(), | 407 | Subject: argExpr.StartRange().Ptr(), |
390 | Context: e.Range().Ptr(), | 408 | Context: e.Range().Ptr(), |
409 | Expression: argExpr, | ||
410 | EvalContext: ctx, | ||
391 | }) | 411 | }) |
392 | 412 | ||
393 | default: | 413 | default: |
@@ -398,8 +418,10 @@ func (e *FunctionCallExpr) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnosti | |||
398 | "Call to function %q failed: %s.", | 418 | "Call to function %q failed: %s.", |
399 | e.Name, err, | 419 | e.Name, err, |
400 | ), | 420 | ), |
401 | Subject: e.StartRange().Ptr(), | 421 | Subject: e.StartRange().Ptr(), |
402 | Context: e.Range().Ptr(), | 422 | Context: e.Range().Ptr(), |
423 | Expression: e, | ||
424 | EvalContext: ctx, | ||
403 | }) | 425 | }) |
404 | } | 426 | } |
405 | 427 | ||
@@ -441,9 +463,9 @@ type ConditionalExpr struct { | |||
441 | } | 463 | } |
442 | 464 | ||
443 | func (e *ConditionalExpr) walkChildNodes(w internalWalkFunc) { | 465 | func (e *ConditionalExpr) walkChildNodes(w internalWalkFunc) { |
444 | e.Condition = w(e.Condition).(Expression) | 466 | w(e.Condition) |
445 | e.TrueResult = w(e.TrueResult).(Expression) | 467 | w(e.TrueResult) |
446 | e.FalseResult = w(e.FalseResult).(Expression) | 468 | w(e.FalseResult) |
447 | } | 469 | } |
448 | 470 | ||
449 | func (e *ConditionalExpr) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) { | 471 | func (e *ConditionalExpr) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) { |
@@ -464,10 +486,12 @@ func (e *ConditionalExpr) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostic | |||
464 | // "These expressions are object and object respectively" if the | 486 | // "These expressions are object and object respectively" if the |
465 | // object types don't exactly match. | 487 | // object types don't exactly match. |
466 | "The true and false result expressions must have consistent types. The given expressions are %s and %s, respectively.", | 488 | "The true and false result expressions must have consistent types. The given expressions are %s and %s, respectively.", |
467 | trueResult.Type(), falseResult.Type(), | 489 | trueResult.Type().FriendlyName(), falseResult.Type().FriendlyName(), |
468 | ), | 490 | ), |
469 | Subject: hcl.RangeBetween(e.TrueResult.Range(), e.FalseResult.Range()).Ptr(), | 491 | Subject: hcl.RangeBetween(e.TrueResult.Range(), e.FalseResult.Range()).Ptr(), |
470 | Context: &e.SrcRange, | 492 | Context: &e.SrcRange, |
493 | Expression: e, | ||
494 | EvalContext: ctx, | ||
471 | }, | 495 | }, |
472 | } | 496 | } |
473 | } | 497 | } |
@@ -476,11 +500,13 @@ func (e *ConditionalExpr) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostic | |||
476 | diags = append(diags, condDiags...) | 500 | diags = append(diags, condDiags...) |
477 | if condResult.IsNull() { | 501 | if condResult.IsNull() { |
478 | diags = append(diags, &hcl.Diagnostic{ | 502 | diags = append(diags, &hcl.Diagnostic{ |
479 | Severity: hcl.DiagError, | 503 | Severity: hcl.DiagError, |
480 | Summary: "Null condition", | 504 | Summary: "Null condition", |
481 | Detail: "The condition value is null. Conditions must either be true or false.", | 505 | Detail: "The condition value is null. Conditions must either be true or false.", |
482 | Subject: e.Condition.Range().Ptr(), | 506 | Subject: e.Condition.Range().Ptr(), |
483 | Context: &e.SrcRange, | 507 | Context: &e.SrcRange, |
508 | Expression: e.Condition, | ||
509 | EvalContext: ctx, | ||
484 | }) | 510 | }) |
485 | return cty.UnknownVal(resultType), diags | 511 | return cty.UnknownVal(resultType), diags |
486 | } | 512 | } |
@@ -490,11 +516,13 @@ func (e *ConditionalExpr) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostic | |||
490 | condResult, err := convert.Convert(condResult, cty.Bool) | 516 | condResult, err := convert.Convert(condResult, cty.Bool) |
491 | if err != nil { | 517 | if err != nil { |
492 | diags = append(diags, &hcl.Diagnostic{ | 518 | diags = append(diags, &hcl.Diagnostic{ |
493 | Severity: hcl.DiagError, | 519 | Severity: hcl.DiagError, |
494 | Summary: "Incorrect condition type", | 520 | Summary: "Incorrect condition type", |
495 | Detail: fmt.Sprintf("The condition expression must be of type bool."), | 521 | Detail: fmt.Sprintf("The condition expression must be of type bool."), |
496 | Subject: e.Condition.Range().Ptr(), | 522 | Subject: e.Condition.Range().Ptr(), |
497 | Context: &e.SrcRange, | 523 | Context: &e.SrcRange, |
524 | Expression: e.Condition, | ||
525 | EvalContext: ctx, | ||
498 | }) | 526 | }) |
499 | return cty.UnknownVal(resultType), diags | 527 | return cty.UnknownVal(resultType), diags |
500 | } | 528 | } |
@@ -513,8 +541,10 @@ func (e *ConditionalExpr) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostic | |||
513 | "The true result value has the wrong type: %s.", | 541 | "The true result value has the wrong type: %s.", |
514 | err.Error(), | 542 | err.Error(), |
515 | ), | 543 | ), |
516 | Subject: e.TrueResult.Range().Ptr(), | 544 | Subject: e.TrueResult.Range().Ptr(), |
517 | Context: &e.SrcRange, | 545 | Context: &e.SrcRange, |
546 | Expression: e.TrueResult, | ||
547 | EvalContext: ctx, | ||
518 | }) | 548 | }) |
519 | trueResult = cty.UnknownVal(resultType) | 549 | trueResult = cty.UnknownVal(resultType) |
520 | } | 550 | } |
@@ -534,8 +564,10 @@ func (e *ConditionalExpr) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostic | |||
534 | "The false result value has the wrong type: %s.", | 564 | "The false result value has the wrong type: %s.", |
535 | err.Error(), | 565 | err.Error(), |
536 | ), | 566 | ), |
537 | Subject: e.TrueResult.Range().Ptr(), | 567 | Subject: e.FalseResult.Range().Ptr(), |
538 | Context: &e.SrcRange, | 568 | Context: &e.SrcRange, |
569 | Expression: e.FalseResult, | ||
570 | EvalContext: ctx, | ||
539 | }) | 571 | }) |
540 | falseResult = cty.UnknownVal(resultType) | 572 | falseResult = cty.UnknownVal(resultType) |
541 | } | 573 | } |
@@ -561,8 +593,8 @@ type IndexExpr struct { | |||
561 | } | 593 | } |
562 | 594 | ||
563 | func (e *IndexExpr) walkChildNodes(w internalWalkFunc) { | 595 | func (e *IndexExpr) walkChildNodes(w internalWalkFunc) { |
564 | e.Collection = w(e.Collection).(Expression) | 596 | w(e.Collection) |
565 | e.Key = w(e.Key).(Expression) | 597 | w(e.Key) |
566 | } | 598 | } |
567 | 599 | ||
568 | func (e *IndexExpr) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) { | 600 | func (e *IndexExpr) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) { |
@@ -572,7 +604,10 @@ func (e *IndexExpr) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) { | |||
572 | diags = append(diags, collDiags...) | 604 | diags = append(diags, collDiags...) |
573 | diags = append(diags, keyDiags...) | 605 | diags = append(diags, keyDiags...) |
574 | 606 | ||
575 | return hcl.Index(coll, key, &e.SrcRange) | 607 | val, indexDiags := hcl.Index(coll, key, &e.SrcRange) |
608 | setDiagEvalContext(indexDiags, e, ctx) | ||
609 | diags = append(diags, indexDiags...) | ||
610 | return val, diags | ||
576 | } | 611 | } |
577 | 612 | ||
578 | func (e *IndexExpr) Range() hcl.Range { | 613 | func (e *IndexExpr) Range() hcl.Range { |
@@ -591,8 +626,8 @@ type TupleConsExpr struct { | |||
591 | } | 626 | } |
592 | 627 | ||
593 | func (e *TupleConsExpr) walkChildNodes(w internalWalkFunc) { | 628 | func (e *TupleConsExpr) walkChildNodes(w internalWalkFunc) { |
594 | for i, expr := range e.Exprs { | 629 | for _, expr := range e.Exprs { |
595 | e.Exprs[i] = w(expr).(Expression) | 630 | w(expr) |
596 | } | 631 | } |
597 | } | 632 | } |
598 | 633 | ||
@@ -640,9 +675,9 @@ type ObjectConsItem struct { | |||
640 | } | 675 | } |
641 | 676 | ||
642 | func (e *ObjectConsExpr) walkChildNodes(w internalWalkFunc) { | 677 | func (e *ObjectConsExpr) walkChildNodes(w internalWalkFunc) { |
643 | for i, item := range e.Items { | 678 | for _, item := range e.Items { |
644 | e.Items[i].KeyExpr = w(item.KeyExpr).(Expression) | 679 | w(item.KeyExpr) |
645 | e.Items[i].ValueExpr = w(item.ValueExpr).(Expression) | 680 | w(item.ValueExpr) |
646 | } | 681 | } |
647 | } | 682 | } |
648 | 683 | ||
@@ -675,10 +710,12 @@ func (e *ObjectConsExpr) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics | |||
675 | 710 | ||
676 | if key.IsNull() { | 711 | if key.IsNull() { |
677 | diags = append(diags, &hcl.Diagnostic{ | 712 | diags = append(diags, &hcl.Diagnostic{ |
678 | Severity: hcl.DiagError, | 713 | Severity: hcl.DiagError, |
679 | Summary: "Null value as key", | 714 | Summary: "Null value as key", |
680 | Detail: "Can't use a null value as a key.", | 715 | Detail: "Can't use a null value as a key.", |
681 | Subject: item.ValueExpr.Range().Ptr(), | 716 | Subject: item.ValueExpr.Range().Ptr(), |
717 | Expression: item.KeyExpr, | ||
718 | EvalContext: ctx, | ||
682 | }) | 719 | }) |
683 | known = false | 720 | known = false |
684 | continue | 721 | continue |
@@ -688,10 +725,12 @@ func (e *ObjectConsExpr) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics | |||
688 | key, err = convert.Convert(key, cty.String) | 725 | key, err = convert.Convert(key, cty.String) |
689 | if err != nil { | 726 | if err != nil { |
690 | diags = append(diags, &hcl.Diagnostic{ | 727 | diags = append(diags, &hcl.Diagnostic{ |
691 | Severity: hcl.DiagError, | 728 | Severity: hcl.DiagError, |
692 | Summary: "Incorrect key type", | 729 | Summary: "Incorrect key type", |
693 | Detail: fmt.Sprintf("Can't use this value as a key: %s.", err.Error()), | 730 | Detail: fmt.Sprintf("Can't use this value as a key: %s.", err.Error()), |
694 | Subject: item.ValueExpr.Range().Ptr(), | 731 | Subject: item.KeyExpr.Range().Ptr(), |
732 | Expression: item.KeyExpr, | ||
733 | EvalContext: ctx, | ||
695 | }) | 734 | }) |
696 | known = false | 735 | known = false |
697 | continue | 736 | continue |
@@ -754,11 +793,31 @@ func (e *ObjectConsKeyExpr) walkChildNodes(w internalWalkFunc) { | |||
754 | // We only treat our wrapped expression as a real expression if we're | 793 | // We only treat our wrapped expression as a real expression if we're |
755 | // not going to interpret it as a literal. | 794 | // not going to interpret it as a literal. |
756 | if e.literalName() == "" { | 795 | if e.literalName() == "" { |
757 | e.Wrapped = w(e.Wrapped).(Expression) | 796 | w(e.Wrapped) |
758 | } | 797 | } |
759 | } | 798 | } |
760 | 799 | ||
761 | func (e *ObjectConsKeyExpr) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) { | 800 | func (e *ObjectConsKeyExpr) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) { |
801 | // Because we accept a naked identifier as a literal key rather than a | ||
802 | // reference, it's confusing to accept a traversal containing periods | ||
803 | // here since we can't tell if the user intends to create a key with | ||
804 | // periods or actually reference something. To avoid confusing downstream | ||
805 | // errors we'll just prohibit a naked multi-step traversal here and | ||
806 | // require the user to state their intent more clearly. | ||
807 | // (This is handled at evaluation time rather than parse time because | ||
808 | // an application using static analysis _can_ accept a naked multi-step | ||
809 | // traversal here, if desired.) | ||
810 | if travExpr, isTraversal := e.Wrapped.(*ScopeTraversalExpr); isTraversal && len(travExpr.Traversal) > 1 { | ||
811 | var diags hcl.Diagnostics | ||
812 | diags = append(diags, &hcl.Diagnostic{ | ||
813 | Severity: hcl.DiagError, | ||
814 | Summary: "Ambiguous attribute key", | ||
815 | Detail: "If this expression is intended to be a reference, wrap it in parentheses. If it's instead intended as a literal name containing periods, wrap it in quotes to create a string literal.", | ||
816 | Subject: e.Range().Ptr(), | ||
817 | }) | ||
818 | return cty.DynamicVal, diags | ||
819 | } | ||
820 | |||
762 | if ln := e.literalName(); ln != "" { | 821 | if ln := e.literalName(); ln != "" { |
763 | return cty.StringVal(ln), nil | 822 | return cty.StringVal(ln), nil |
764 | } | 823 | } |
@@ -818,11 +877,13 @@ func (e *ForExpr) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) { | |||
818 | 877 | ||
819 | if collVal.IsNull() { | 878 | if collVal.IsNull() { |
820 | diags = append(diags, &hcl.Diagnostic{ | 879 | diags = append(diags, &hcl.Diagnostic{ |
821 | Severity: hcl.DiagError, | 880 | Severity: hcl.DiagError, |
822 | Summary: "Iteration over null value", | 881 | Summary: "Iteration over null value", |
823 | Detail: "A null value cannot be used as the collection in a 'for' expression.", | 882 | Detail: "A null value cannot be used as the collection in a 'for' expression.", |
824 | Subject: e.CollExpr.Range().Ptr(), | 883 | Subject: e.CollExpr.Range().Ptr(), |
825 | Context: &e.SrcRange, | 884 | Context: &e.SrcRange, |
885 | Expression: e.CollExpr, | ||
886 | EvalContext: ctx, | ||
826 | }) | 887 | }) |
827 | return cty.DynamicVal, diags | 888 | return cty.DynamicVal, diags |
828 | } | 889 | } |
@@ -837,8 +898,10 @@ func (e *ForExpr) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) { | |||
837 | "A value of type %s cannot be used as the collection in a 'for' expression.", | 898 | "A value of type %s cannot be used as the collection in a 'for' expression.", |
838 | collVal.Type().FriendlyName(), | 899 | collVal.Type().FriendlyName(), |
839 | ), | 900 | ), |
840 | Subject: e.CollExpr.Range().Ptr(), | 901 | Subject: e.CollExpr.Range().Ptr(), |
841 | Context: &e.SrcRange, | 902 | Context: &e.SrcRange, |
903 | Expression: e.CollExpr, | ||
904 | EvalContext: ctx, | ||
842 | }) | 905 | }) |
843 | return cty.DynamicVal, diags | 906 | return cty.DynamicVal, diags |
844 | } | 907 | } |
@@ -846,14 +909,13 @@ func (e *ForExpr) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) { | |||
846 | return cty.DynamicVal, diags | 909 | return cty.DynamicVal, diags |
847 | } | 910 | } |
848 | 911 | ||
849 | childCtx := ctx.NewChild() | ||
850 | childCtx.Variables = map[string]cty.Value{} | ||
851 | |||
852 | // Before we start we'll do an early check to see if any CondExpr we've | 912 | // Before we start we'll do an early check to see if any CondExpr we've |
853 | // been given is of the wrong type. This isn't 100% reliable (it may | 913 | // been given is of the wrong type. This isn't 100% reliable (it may |
854 | // be DynamicVal until real values are given) but it should catch some | 914 | // be DynamicVal until real values are given) but it should catch some |
855 | // straightforward cases and prevent a barrage of repeated errors. | 915 | // straightforward cases and prevent a barrage of repeated errors. |
856 | if e.CondExpr != nil { | 916 | if e.CondExpr != nil { |
917 | childCtx := ctx.NewChild() | ||
918 | childCtx.Variables = map[string]cty.Value{} | ||
857 | if e.KeyVar != "" { | 919 | if e.KeyVar != "" { |
858 | childCtx.Variables[e.KeyVar] = cty.DynamicVal | 920 | childCtx.Variables[e.KeyVar] = cty.DynamicVal |
859 | } | 921 | } |
@@ -863,22 +925,26 @@ func (e *ForExpr) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) { | |||
863 | diags = append(diags, condDiags...) | 925 | diags = append(diags, condDiags...) |
864 | if result.IsNull() { | 926 | if result.IsNull() { |
865 | diags = append(diags, &hcl.Diagnostic{ | 927 | diags = append(diags, &hcl.Diagnostic{ |
866 | Severity: hcl.DiagError, | 928 | Severity: hcl.DiagError, |
867 | Summary: "Condition is null", | 929 | Summary: "Condition is null", |
868 | Detail: "The value of the 'if' clause must not be null.", | 930 | Detail: "The value of the 'if' clause must not be null.", |
869 | Subject: e.CondExpr.Range().Ptr(), | 931 | Subject: e.CondExpr.Range().Ptr(), |
870 | Context: &e.SrcRange, | 932 | Context: &e.SrcRange, |
933 | Expression: e.CondExpr, | ||
934 | EvalContext: ctx, | ||
871 | }) | 935 | }) |
872 | return cty.DynamicVal, diags | 936 | return cty.DynamicVal, diags |
873 | } | 937 | } |
874 | _, err := convert.Convert(result, cty.Bool) | 938 | _, err := convert.Convert(result, cty.Bool) |
875 | if err != nil { | 939 | if err != nil { |
876 | diags = append(diags, &hcl.Diagnostic{ | 940 | diags = append(diags, &hcl.Diagnostic{ |
877 | Severity: hcl.DiagError, | 941 | Severity: hcl.DiagError, |
878 | Summary: "Invalid 'for' condition", | 942 | Summary: "Invalid 'for' condition", |
879 | Detail: fmt.Sprintf("The 'if' clause value is invalid: %s.", err.Error()), | 943 | Detail: fmt.Sprintf("The 'if' clause value is invalid: %s.", err.Error()), |
880 | Subject: e.CondExpr.Range().Ptr(), | 944 | Subject: e.CondExpr.Range().Ptr(), |
881 | Context: &e.SrcRange, | 945 | Context: &e.SrcRange, |
946 | Expression: e.CondExpr, | ||
947 | EvalContext: ctx, | ||
882 | }) | 948 | }) |
883 | return cty.DynamicVal, diags | 949 | return cty.DynamicVal, diags |
884 | } | 950 | } |
@@ -902,6 +968,8 @@ func (e *ForExpr) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) { | |||
902 | known := true | 968 | known := true |
903 | for it.Next() { | 969 | for it.Next() { |
904 | k, v := it.Element() | 970 | k, v := it.Element() |
971 | childCtx := ctx.NewChild() | ||
972 | childCtx.Variables = map[string]cty.Value{} | ||
905 | if e.KeyVar != "" { | 973 | if e.KeyVar != "" { |
906 | childCtx.Variables[e.KeyVar] = k | 974 | childCtx.Variables[e.KeyVar] = k |
907 | } | 975 | } |
@@ -913,11 +981,13 @@ func (e *ForExpr) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) { | |||
913 | if includeRaw.IsNull() { | 981 | if includeRaw.IsNull() { |
914 | if known { | 982 | if known { |
915 | diags = append(diags, &hcl.Diagnostic{ | 983 | diags = append(diags, &hcl.Diagnostic{ |
916 | Severity: hcl.DiagError, | 984 | Severity: hcl.DiagError, |
917 | Summary: "Condition is null", | 985 | Summary: "Invalid 'for' condition", |
918 | Detail: "The value of the 'if' clause must not be null.", | 986 | Detail: "The value of the 'if' clause must not be null.", |
919 | Subject: e.CondExpr.Range().Ptr(), | 987 | Subject: e.CondExpr.Range().Ptr(), |
920 | Context: &e.SrcRange, | 988 | Context: &e.SrcRange, |
989 | Expression: e.CondExpr, | ||
990 | EvalContext: childCtx, | ||
921 | }) | 991 | }) |
922 | } | 992 | } |
923 | known = false | 993 | known = false |
@@ -927,11 +997,13 @@ func (e *ForExpr) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) { | |||
927 | if err != nil { | 997 | if err != nil { |
928 | if known { | 998 | if known { |
929 | diags = append(diags, &hcl.Diagnostic{ | 999 | diags = append(diags, &hcl.Diagnostic{ |
930 | Severity: hcl.DiagError, | 1000 | Severity: hcl.DiagError, |
931 | Summary: "Invalid 'for' condition", | 1001 | Summary: "Invalid 'for' condition", |
932 | Detail: fmt.Sprintf("The 'if' clause value is invalid: %s.", err.Error()), | 1002 | Detail: fmt.Sprintf("The 'if' clause value is invalid: %s.", err.Error()), |
933 | Subject: e.CondExpr.Range().Ptr(), | 1003 | Subject: e.CondExpr.Range().Ptr(), |
934 | Context: &e.SrcRange, | 1004 | Context: &e.SrcRange, |
1005 | Expression: e.CondExpr, | ||
1006 | EvalContext: childCtx, | ||
935 | }) | 1007 | }) |
936 | } | 1008 | } |
937 | known = false | 1009 | known = false |
@@ -953,11 +1025,13 @@ func (e *ForExpr) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) { | |||
953 | if keyRaw.IsNull() { | 1025 | if keyRaw.IsNull() { |
954 | if known { | 1026 | if known { |
955 | diags = append(diags, &hcl.Diagnostic{ | 1027 | diags = append(diags, &hcl.Diagnostic{ |
956 | Severity: hcl.DiagError, | 1028 | Severity: hcl.DiagError, |
957 | Summary: "Invalid object key", | 1029 | Summary: "Invalid object key", |
958 | Detail: "Key expression in 'for' expression must not produce a null value.", | 1030 | Detail: "Key expression in 'for' expression must not produce a null value.", |
959 | Subject: e.KeyExpr.Range().Ptr(), | 1031 | Subject: e.KeyExpr.Range().Ptr(), |
960 | Context: &e.SrcRange, | 1032 | Context: &e.SrcRange, |
1033 | Expression: e.KeyExpr, | ||
1034 | EvalContext: childCtx, | ||
961 | }) | 1035 | }) |
962 | } | 1036 | } |
963 | known = false | 1037 | known = false |
@@ -972,11 +1046,13 @@ func (e *ForExpr) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) { | |||
972 | if err != nil { | 1046 | if err != nil { |
973 | if known { | 1047 | if known { |
974 | diags = append(diags, &hcl.Diagnostic{ | 1048 | diags = append(diags, &hcl.Diagnostic{ |
975 | Severity: hcl.DiagError, | 1049 | Severity: hcl.DiagError, |
976 | Summary: "Invalid object key", | 1050 | Summary: "Invalid object key", |
977 | Detail: fmt.Sprintf("The key expression produced an invalid result: %s.", err.Error()), | 1051 | Detail: fmt.Sprintf("The key expression produced an invalid result: %s.", err.Error()), |
978 | Subject: e.KeyExpr.Range().Ptr(), | 1052 | Subject: e.KeyExpr.Range().Ptr(), |
979 | Context: &e.SrcRange, | 1053 | Context: &e.SrcRange, |
1054 | Expression: e.KeyExpr, | ||
1055 | EvalContext: childCtx, | ||
980 | }) | 1056 | }) |
981 | } | 1057 | } |
982 | known = false | 1058 | known = false |
@@ -996,11 +1072,13 @@ func (e *ForExpr) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) { | |||
996 | Severity: hcl.DiagError, | 1072 | Severity: hcl.DiagError, |
997 | Summary: "Duplicate object key", | 1073 | Summary: "Duplicate object key", |
998 | Detail: fmt.Sprintf( | 1074 | Detail: fmt.Sprintf( |
999 | "Two different items produced the key %q in this for expression. If duplicates are expected, use the ellipsis (...) after the value expression to enable grouping by key.", | 1075 | "Two different items produced the key %q in this 'for' expression. If duplicates are expected, use the ellipsis (...) after the value expression to enable grouping by key.", |
1000 | k, | 1076 | k, |
1001 | ), | 1077 | ), |
1002 | Subject: e.KeyExpr.Range().Ptr(), | 1078 | Subject: e.KeyExpr.Range().Ptr(), |
1003 | Context: &e.SrcRange, | 1079 | Context: &e.SrcRange, |
1080 | Expression: e.KeyExpr, | ||
1081 | EvalContext: childCtx, | ||
1004 | }) | 1082 | }) |
1005 | } else { | 1083 | } else { |
1006 | vals[key.AsString()] = val | 1084 | vals[key.AsString()] = val |
@@ -1030,6 +1108,8 @@ func (e *ForExpr) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) { | |||
1030 | known := true | 1108 | known := true |
1031 | for it.Next() { | 1109 | for it.Next() { |
1032 | k, v := it.Element() | 1110 | k, v := it.Element() |
1111 | childCtx := ctx.NewChild() | ||
1112 | childCtx.Variables = map[string]cty.Value{} | ||
1033 | if e.KeyVar != "" { | 1113 | if e.KeyVar != "" { |
1034 | childCtx.Variables[e.KeyVar] = k | 1114 | childCtx.Variables[e.KeyVar] = k |
1035 | } | 1115 | } |
@@ -1041,11 +1121,13 @@ func (e *ForExpr) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) { | |||
1041 | if includeRaw.IsNull() { | 1121 | if includeRaw.IsNull() { |
1042 | if known { | 1122 | if known { |
1043 | diags = append(diags, &hcl.Diagnostic{ | 1123 | diags = append(diags, &hcl.Diagnostic{ |
1044 | Severity: hcl.DiagError, | 1124 | Severity: hcl.DiagError, |
1045 | Summary: "Condition is null", | 1125 | Summary: "Invalid 'for' condition", |
1046 | Detail: "The value of the 'if' clause must not be null.", | 1126 | Detail: "The value of the 'if' clause must not be null.", |
1047 | Subject: e.CondExpr.Range().Ptr(), | 1127 | Subject: e.CondExpr.Range().Ptr(), |
1048 | Context: &e.SrcRange, | 1128 | Context: &e.SrcRange, |
1129 | Expression: e.CondExpr, | ||
1130 | EvalContext: childCtx, | ||
1049 | }) | 1131 | }) |
1050 | } | 1132 | } |
1051 | known = false | 1133 | known = false |
@@ -1063,11 +1145,13 @@ func (e *ForExpr) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) { | |||
1063 | if err != nil { | 1145 | if err != nil { |
1064 | if known { | 1146 | if known { |
1065 | diags = append(diags, &hcl.Diagnostic{ | 1147 | diags = append(diags, &hcl.Diagnostic{ |
1066 | Severity: hcl.DiagError, | 1148 | Severity: hcl.DiagError, |
1067 | Summary: "Invalid 'for' condition", | 1149 | Summary: "Invalid 'for' condition", |
1068 | Detail: fmt.Sprintf("The 'if' clause value is invalid: %s.", err.Error()), | 1150 | Detail: fmt.Sprintf("The 'if' clause value is invalid: %s.", err.Error()), |
1069 | Subject: e.CondExpr.Range().Ptr(), | 1151 | Subject: e.CondExpr.Range().Ptr(), |
1070 | Context: &e.SrcRange, | 1152 | Context: &e.SrcRange, |
1153 | Expression: e.CondExpr, | ||
1154 | EvalContext: childCtx, | ||
1071 | }) | 1155 | }) |
1072 | } | 1156 | } |
1073 | known = false | 1157 | known = false |
@@ -1094,7 +1178,7 @@ func (e *ForExpr) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) { | |||
1094 | } | 1178 | } |
1095 | 1179 | ||
1096 | func (e *ForExpr) walkChildNodes(w internalWalkFunc) { | 1180 | func (e *ForExpr) walkChildNodes(w internalWalkFunc) { |
1097 | e.CollExpr = w(e.CollExpr).(Expression) | 1181 | w(e.CollExpr) |
1098 | 1182 | ||
1099 | scopeNames := map[string]struct{}{} | 1183 | scopeNames := map[string]struct{}{} |
1100 | if e.KeyVar != "" { | 1184 | if e.KeyVar != "" { |
@@ -1107,17 +1191,17 @@ func (e *ForExpr) walkChildNodes(w internalWalkFunc) { | |||
1107 | if e.KeyExpr != nil { | 1191 | if e.KeyExpr != nil { |
1108 | w(ChildScope{ | 1192 | w(ChildScope{ |
1109 | LocalNames: scopeNames, | 1193 | LocalNames: scopeNames, |
1110 | Expr: &e.KeyExpr, | 1194 | Expr: e.KeyExpr, |
1111 | }) | 1195 | }) |
1112 | } | 1196 | } |
1113 | w(ChildScope{ | 1197 | w(ChildScope{ |
1114 | LocalNames: scopeNames, | 1198 | LocalNames: scopeNames, |
1115 | Expr: &e.ValExpr, | 1199 | Expr: e.ValExpr, |
1116 | }) | 1200 | }) |
1117 | if e.CondExpr != nil { | 1201 | if e.CondExpr != nil { |
1118 | w(ChildScope{ | 1202 | w(ChildScope{ |
1119 | LocalNames: scopeNames, | 1203 | LocalNames: scopeNames, |
1120 | Expr: &e.CondExpr, | 1204 | Expr: e.CondExpr, |
1121 | }) | 1205 | }) |
1122 | } | 1206 | } |
1123 | } | 1207 | } |
@@ -1151,26 +1235,78 @@ func (e *SplatExpr) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) { | |||
1151 | return cty.DynamicVal, diags | 1235 | return cty.DynamicVal, diags |
1152 | } | 1236 | } |
1153 | 1237 | ||
1238 | sourceTy := sourceVal.Type() | ||
1239 | if sourceTy == cty.DynamicPseudoType { | ||
1240 | // If we don't even know the _type_ of our source value yet then | ||
1241 | // we'll need to defer all processing, since we can't decide our | ||
1242 | // result type either. | ||
1243 | return cty.DynamicVal, diags | ||
1244 | } | ||
1245 | |||
1246 | // A "special power" of splat expressions is that they can be applied | ||
1247 | // both to tuples/lists and to other values, and in the latter case | ||
1248 | // the value will be treated as an implicit single-item tuple, or as | ||
1249 | // an empty tuple if the value is null. | ||
1250 | autoUpgrade := !(sourceTy.IsTupleType() || sourceTy.IsListType() || sourceTy.IsSetType()) | ||
1251 | |||
1154 | if sourceVal.IsNull() { | 1252 | if sourceVal.IsNull() { |
1253 | if autoUpgrade { | ||
1254 | return cty.EmptyTupleVal, diags | ||
1255 | } | ||
1155 | diags = append(diags, &hcl.Diagnostic{ | 1256 | diags = append(diags, &hcl.Diagnostic{ |
1156 | Severity: hcl.DiagError, | 1257 | Severity: hcl.DiagError, |
1157 | Summary: "Splat of null value", | 1258 | Summary: "Splat of null value", |
1158 | Detail: "Splat expressions (with the * symbol) cannot be applied to null values.", | 1259 | Detail: "Splat expressions (with the * symbol) cannot be applied to null sequences.", |
1159 | Subject: e.Source.Range().Ptr(), | 1260 | Subject: e.Source.Range().Ptr(), |
1160 | Context: hcl.RangeBetween(e.Source.Range(), e.MarkerRange).Ptr(), | 1261 | Context: hcl.RangeBetween(e.Source.Range(), e.MarkerRange).Ptr(), |
1262 | Expression: e.Source, | ||
1263 | EvalContext: ctx, | ||
1161 | }) | 1264 | }) |
1162 | return cty.DynamicVal, diags | 1265 | return cty.DynamicVal, diags |
1163 | } | 1266 | } |
1164 | if !sourceVal.IsKnown() { | 1267 | |
1165 | return cty.DynamicVal, diags | 1268 | if autoUpgrade { |
1269 | sourceVal = cty.TupleVal([]cty.Value{sourceVal}) | ||
1270 | sourceTy = sourceVal.Type() | ||
1166 | } | 1271 | } |
1167 | 1272 | ||
1168 | // A "special power" of splat expressions is that they can be applied | 1273 | // We'll compute our result type lazily if we need it. In the normal case |
1169 | // both to tuples/lists and to other values, and in the latter case | 1274 | // it's inferred automatically from the value we construct. |
1170 | // the value will be treated as an implicit single-value list. We'll | 1275 | resultTy := func() (cty.Type, hcl.Diagnostics) { |
1171 | // deal with that here first. | 1276 | chiCtx := ctx.NewChild() |
1172 | if !(sourceVal.Type().IsTupleType() || sourceVal.Type().IsListType()) { | 1277 | var diags hcl.Diagnostics |
1173 | sourceVal = cty.ListVal([]cty.Value{sourceVal}) | 1278 | switch { |
1279 | case sourceTy.IsListType() || sourceTy.IsSetType(): | ||
1280 | ety := sourceTy.ElementType() | ||
1281 | e.Item.setValue(chiCtx, cty.UnknownVal(ety)) | ||
1282 | val, itemDiags := e.Each.Value(chiCtx) | ||
1283 | diags = append(diags, itemDiags...) | ||
1284 | e.Item.clearValue(chiCtx) // clean up our temporary value | ||
1285 | return cty.List(val.Type()), diags | ||
1286 | case sourceTy.IsTupleType(): | ||
1287 | etys := sourceTy.TupleElementTypes() | ||
1288 | resultTys := make([]cty.Type, 0, len(etys)) | ||
1289 | for _, ety := range etys { | ||
1290 | e.Item.setValue(chiCtx, cty.UnknownVal(ety)) | ||
1291 | val, itemDiags := e.Each.Value(chiCtx) | ||
1292 | diags = append(diags, itemDiags...) | ||
1293 | e.Item.clearValue(chiCtx) // clean up our temporary value | ||
1294 | resultTys = append(resultTys, val.Type()) | ||
1295 | } | ||
1296 | return cty.Tuple(resultTys), diags | ||
1297 | default: | ||
1298 | // Should never happen because of our promotion to list above. | ||
1299 | return cty.DynamicPseudoType, diags | ||
1300 | } | ||
1301 | } | ||
1302 | |||
1303 | if !sourceVal.IsKnown() { | ||
1304 | // We can't produce a known result in this case, but we'll still | ||
1305 | // indicate what the result type would be, allowing any downstream type | ||
1306 | // checking to proceed. | ||
1307 | ty, tyDiags := resultTy() | ||
1308 | diags = append(diags, tyDiags...) | ||
1309 | return cty.UnknownVal(ty), diags | ||
1174 | } | 1310 | } |
1175 | 1311 | ||
1176 | vals := make([]cty.Value, 0, sourceVal.LengthInt()) | 1312 | vals := make([]cty.Value, 0, sourceVal.LengthInt()) |
@@ -1194,15 +1330,28 @@ func (e *SplatExpr) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) { | |||
1194 | e.Item.clearValue(ctx) // clean up our temporary value | 1330 | e.Item.clearValue(ctx) // clean up our temporary value |
1195 | 1331 | ||
1196 | if !isKnown { | 1332 | if !isKnown { |
1197 | return cty.DynamicVal, diags | 1333 | // We'll ingore the resultTy diagnostics in this case since they |
1334 | // will just be the same errors we saw while iterating above. | ||
1335 | ty, _ := resultTy() | ||
1336 | return cty.UnknownVal(ty), diags | ||
1198 | } | 1337 | } |
1199 | 1338 | ||
1200 | return cty.TupleVal(vals), diags | 1339 | switch { |
1340 | case sourceTy.IsListType() || sourceTy.IsSetType(): | ||
1341 | if len(vals) == 0 { | ||
1342 | ty, tyDiags := resultTy() | ||
1343 | diags = append(diags, tyDiags...) | ||
1344 | return cty.ListValEmpty(ty.ElementType()), diags | ||
1345 | } | ||
1346 | return cty.ListVal(vals), diags | ||
1347 | default: | ||
1348 | return cty.TupleVal(vals), diags | ||
1349 | } | ||
1201 | } | 1350 | } |
1202 | 1351 | ||
1203 | func (e *SplatExpr) walkChildNodes(w internalWalkFunc) { | 1352 | func (e *SplatExpr) walkChildNodes(w internalWalkFunc) { |
1204 | e.Source = w(e.Source).(Expression) | 1353 | w(e.Source) |
1205 | e.Each = w(e.Each).(Expression) | 1354 | w(e.Each) |
1206 | } | 1355 | } |
1207 | 1356 | ||
1208 | func (e *SplatExpr) Range() hcl.Range { | 1357 | func (e *SplatExpr) Range() hcl.Range { |
@@ -1226,13 +1375,24 @@ func (e *SplatExpr) StartRange() hcl.Range { | |||
1226 | // assigns it a value. | 1375 | // assigns it a value. |
1227 | type AnonSymbolExpr struct { | 1376 | type AnonSymbolExpr struct { |
1228 | SrcRange hcl.Range | 1377 | SrcRange hcl.Range |
1229 | values map[*hcl.EvalContext]cty.Value | 1378 | |
1379 | // values and its associated lock are used to isolate concurrent | ||
1380 | // evaluations of a symbol from one another. It is the calling application's | ||
1381 | // responsibility to ensure that the same splat expression is not evalauted | ||
1382 | // concurrently within the _same_ EvalContext, but it is fine and safe to | ||
1383 | // do cuncurrent evaluations with distinct EvalContexts. | ||
1384 | values map[*hcl.EvalContext]cty.Value | ||
1385 | valuesLock sync.RWMutex | ||
1230 | } | 1386 | } |
1231 | 1387 | ||
1232 | func (e *AnonSymbolExpr) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) { | 1388 | func (e *AnonSymbolExpr) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) { |
1233 | if ctx == nil { | 1389 | if ctx == nil { |
1234 | return cty.DynamicVal, nil | 1390 | return cty.DynamicVal, nil |
1235 | } | 1391 | } |
1392 | |||
1393 | e.valuesLock.RLock() | ||
1394 | defer e.valuesLock.RUnlock() | ||
1395 | |||
1236 | val, exists := e.values[ctx] | 1396 | val, exists := e.values[ctx] |
1237 | if !exists { | 1397 | if !exists { |
1238 | return cty.DynamicVal, nil | 1398 | return cty.DynamicVal, nil |
@@ -1243,6 +1403,9 @@ func (e *AnonSymbolExpr) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics | |||
1243 | // setValue sets a temporary local value for the expression when evaluated | 1403 | // setValue sets a temporary local value for the expression when evaluated |
1244 | // in the given context, which must be non-nil. | 1404 | // in the given context, which must be non-nil. |
1245 | func (e *AnonSymbolExpr) setValue(ctx *hcl.EvalContext, val cty.Value) { | 1405 | func (e *AnonSymbolExpr) setValue(ctx *hcl.EvalContext, val cty.Value) { |
1406 | e.valuesLock.Lock() | ||
1407 | defer e.valuesLock.Unlock() | ||
1408 | |||
1246 | if e.values == nil { | 1409 | if e.values == nil { |
1247 | e.values = make(map[*hcl.EvalContext]cty.Value) | 1410 | e.values = make(map[*hcl.EvalContext]cty.Value) |
1248 | } | 1411 | } |
@@ -1253,6 +1416,9 @@ func (e *AnonSymbolExpr) setValue(ctx *hcl.EvalContext, val cty.Value) { | |||
1253 | } | 1416 | } |
1254 | 1417 | ||
1255 | func (e *AnonSymbolExpr) clearValue(ctx *hcl.EvalContext) { | 1418 | func (e *AnonSymbolExpr) clearValue(ctx *hcl.EvalContext) { |
1419 | e.valuesLock.Lock() | ||
1420 | defer e.valuesLock.Unlock() | ||
1421 | |||
1256 | if e.values == nil { | 1422 | if e.values == nil { |
1257 | return | 1423 | return |
1258 | } | 1424 | } |
diff --git a/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/expression_ops.go b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/expression_ops.go index 9a5da04..7f59f1a 100644 --- a/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/expression_ops.go +++ b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/expression_ops.go | |||
@@ -129,8 +129,8 @@ type BinaryOpExpr struct { | |||
129 | } | 129 | } |
130 | 130 | ||
131 | func (e *BinaryOpExpr) walkChildNodes(w internalWalkFunc) { | 131 | func (e *BinaryOpExpr) walkChildNodes(w internalWalkFunc) { |
132 | e.LHS = w(e.LHS).(Expression) | 132 | w(e.LHS) |
133 | e.RHS = w(e.RHS).(Expression) | 133 | w(e.RHS) |
134 | } | 134 | } |
135 | 135 | ||
136 | func (e *BinaryOpExpr) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) { | 136 | func (e *BinaryOpExpr) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) { |
@@ -149,21 +149,25 @@ func (e *BinaryOpExpr) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) | |||
149 | lhsVal, err := convert.Convert(givenLHSVal, lhsParam.Type) | 149 | lhsVal, err := convert.Convert(givenLHSVal, lhsParam.Type) |
150 | if err != nil { | 150 | if err != nil { |
151 | diags = append(diags, &hcl.Diagnostic{ | 151 | diags = append(diags, &hcl.Diagnostic{ |
152 | Severity: hcl.DiagError, | 152 | Severity: hcl.DiagError, |
153 | Summary: "Invalid operand", | 153 | Summary: "Invalid operand", |
154 | Detail: fmt.Sprintf("Unsuitable value for left operand: %s.", err), | 154 | Detail: fmt.Sprintf("Unsuitable value for left operand: %s.", err), |
155 | Subject: e.LHS.Range().Ptr(), | 155 | Subject: e.LHS.Range().Ptr(), |
156 | Context: &e.SrcRange, | 156 | Context: &e.SrcRange, |
157 | Expression: e.LHS, | ||
158 | EvalContext: ctx, | ||
157 | }) | 159 | }) |
158 | } | 160 | } |
159 | rhsVal, err := convert.Convert(givenRHSVal, rhsParam.Type) | 161 | rhsVal, err := convert.Convert(givenRHSVal, rhsParam.Type) |
160 | if err != nil { | 162 | if err != nil { |
161 | diags = append(diags, &hcl.Diagnostic{ | 163 | diags = append(diags, &hcl.Diagnostic{ |
162 | Severity: hcl.DiagError, | 164 | Severity: hcl.DiagError, |
163 | Summary: "Invalid operand", | 165 | Summary: "Invalid operand", |
164 | Detail: fmt.Sprintf("Unsuitable value for right operand: %s.", err), | 166 | Detail: fmt.Sprintf("Unsuitable value for right operand: %s.", err), |
165 | Subject: e.RHS.Range().Ptr(), | 167 | Subject: e.RHS.Range().Ptr(), |
166 | Context: &e.SrcRange, | 168 | Context: &e.SrcRange, |
169 | Expression: e.RHS, | ||
170 | EvalContext: ctx, | ||
167 | }) | 171 | }) |
168 | } | 172 | } |
169 | 173 | ||
@@ -178,10 +182,12 @@ func (e *BinaryOpExpr) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) | |||
178 | if err != nil { | 182 | if err != nil { |
179 | diags = append(diags, &hcl.Diagnostic{ | 183 | diags = append(diags, &hcl.Diagnostic{ |
180 | // FIXME: This diagnostic is useless. | 184 | // FIXME: This diagnostic is useless. |
181 | Severity: hcl.DiagError, | 185 | Severity: hcl.DiagError, |
182 | Summary: "Operation failed", | 186 | Summary: "Operation failed", |
183 | Detail: fmt.Sprintf("Error during operation: %s.", err), | 187 | Detail: fmt.Sprintf("Error during operation: %s.", err), |
184 | Subject: &e.SrcRange, | 188 | Subject: &e.SrcRange, |
189 | Expression: e, | ||
190 | EvalContext: ctx, | ||
185 | }) | 191 | }) |
186 | return cty.UnknownVal(e.Op.Type), diags | 192 | return cty.UnknownVal(e.Op.Type), diags |
187 | } | 193 | } |
@@ -206,7 +212,7 @@ type UnaryOpExpr struct { | |||
206 | } | 212 | } |
207 | 213 | ||
208 | func (e *UnaryOpExpr) walkChildNodes(w internalWalkFunc) { | 214 | func (e *UnaryOpExpr) walkChildNodes(w internalWalkFunc) { |
209 | e.Val = w(e.Val).(Expression) | 215 | w(e.Val) |
210 | } | 216 | } |
211 | 217 | ||
212 | func (e *UnaryOpExpr) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) { | 218 | func (e *UnaryOpExpr) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) { |
@@ -219,11 +225,13 @@ func (e *UnaryOpExpr) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) { | |||
219 | val, err := convert.Convert(givenVal, param.Type) | 225 | val, err := convert.Convert(givenVal, param.Type) |
220 | if err != nil { | 226 | if err != nil { |
221 | diags = append(diags, &hcl.Diagnostic{ | 227 | diags = append(diags, &hcl.Diagnostic{ |
222 | Severity: hcl.DiagError, | 228 | Severity: hcl.DiagError, |
223 | Summary: "Invalid operand", | 229 | Summary: "Invalid operand", |
224 | Detail: fmt.Sprintf("Unsuitable value for unary operand: %s.", err), | 230 | Detail: fmt.Sprintf("Unsuitable value for unary operand: %s.", err), |
225 | Subject: e.Val.Range().Ptr(), | 231 | Subject: e.Val.Range().Ptr(), |
226 | Context: &e.SrcRange, | 232 | Context: &e.SrcRange, |
233 | Expression: e.Val, | ||
234 | EvalContext: ctx, | ||
227 | }) | 235 | }) |
228 | } | 236 | } |
229 | 237 | ||
@@ -238,10 +246,12 @@ func (e *UnaryOpExpr) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) { | |||
238 | if err != nil { | 246 | if err != nil { |
239 | diags = append(diags, &hcl.Diagnostic{ | 247 | diags = append(diags, &hcl.Diagnostic{ |
240 | // FIXME: This diagnostic is useless. | 248 | // FIXME: This diagnostic is useless. |
241 | Severity: hcl.DiagError, | 249 | Severity: hcl.DiagError, |
242 | Summary: "Operation failed", | 250 | Summary: "Operation failed", |
243 | Detail: fmt.Sprintf("Error during operation: %s.", err), | 251 | Detail: fmt.Sprintf("Error during operation: %s.", err), |
244 | Subject: &e.SrcRange, | 252 | Subject: &e.SrcRange, |
253 | Expression: e, | ||
254 | EvalContext: ctx, | ||
245 | }) | 255 | }) |
246 | return cty.UnknownVal(e.Op.Type), diags | 256 | return cty.UnknownVal(e.Op.Type), diags |
247 | } | 257 | } |
diff --git a/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/expression_template.go b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/expression_template.go index a1c4727..fa79e3d 100644 --- a/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/expression_template.go +++ b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/expression_template.go | |||
@@ -16,8 +16,8 @@ type TemplateExpr struct { | |||
16 | } | 16 | } |
17 | 17 | ||
18 | func (e *TemplateExpr) walkChildNodes(w internalWalkFunc) { | 18 | func (e *TemplateExpr) walkChildNodes(w internalWalkFunc) { |
19 | for i, part := range e.Parts { | 19 | for _, part := range e.Parts { |
20 | e.Parts[i] = w(part).(Expression) | 20 | w(part) |
21 | } | 21 | } |
22 | } | 22 | } |
23 | 23 | ||
@@ -37,8 +37,10 @@ func (e *TemplateExpr) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) | |||
37 | Detail: fmt.Sprintf( | 37 | Detail: fmt.Sprintf( |
38 | "The expression result is null. Cannot include a null value in a string template.", | 38 | "The expression result is null. Cannot include a null value in a string template.", |
39 | ), | 39 | ), |
40 | Subject: part.Range().Ptr(), | 40 | Subject: part.Range().Ptr(), |
41 | Context: &e.SrcRange, | 41 | Context: &e.SrcRange, |
42 | Expression: part, | ||
43 | EvalContext: ctx, | ||
42 | }) | 44 | }) |
43 | continue | 45 | continue |
44 | } | 46 | } |
@@ -61,8 +63,10 @@ func (e *TemplateExpr) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) | |||
61 | "Cannot include the given value in a string template: %s.", | 63 | "Cannot include the given value in a string template: %s.", |
62 | err.Error(), | 64 | err.Error(), |
63 | ), | 65 | ), |
64 | Subject: part.Range().Ptr(), | 66 | Subject: part.Range().Ptr(), |
65 | Context: &e.SrcRange, | 67 | Context: &e.SrcRange, |
68 | Expression: part, | ||
69 | EvalContext: ctx, | ||
66 | }) | 70 | }) |
67 | continue | 71 | continue |
68 | } | 72 | } |
@@ -94,7 +98,7 @@ type TemplateJoinExpr struct { | |||
94 | } | 98 | } |
95 | 99 | ||
96 | func (e *TemplateJoinExpr) walkChildNodes(w internalWalkFunc) { | 100 | func (e *TemplateJoinExpr) walkChildNodes(w internalWalkFunc) { |
97 | e.Tuple = w(e.Tuple).(Expression) | 101 | w(e.Tuple) |
98 | } | 102 | } |
99 | 103 | ||
100 | func (e *TemplateJoinExpr) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) { | 104 | func (e *TemplateJoinExpr) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) { |
@@ -127,7 +131,9 @@ func (e *TemplateJoinExpr) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnosti | |||
127 | Detail: fmt.Sprintf( | 131 | Detail: fmt.Sprintf( |
128 | "An iteration result is null. Cannot include a null value in a string template.", | 132 | "An iteration result is null. Cannot include a null value in a string template.", |
129 | ), | 133 | ), |
130 | Subject: e.Range().Ptr(), | 134 | Subject: e.Range().Ptr(), |
135 | Expression: e, | ||
136 | EvalContext: ctx, | ||
131 | }) | 137 | }) |
132 | continue | 138 | continue |
133 | } | 139 | } |
@@ -143,7 +149,9 @@ func (e *TemplateJoinExpr) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnosti | |||
143 | "Cannot include one of the interpolation results into the string template: %s.", | 149 | "Cannot include one of the interpolation results into the string template: %s.", |
144 | err.Error(), | 150 | err.Error(), |
145 | ), | 151 | ), |
146 | Subject: e.Range().Ptr(), | 152 | Subject: e.Range().Ptr(), |
153 | Expression: e, | ||
154 | EvalContext: ctx, | ||
147 | }) | 155 | }) |
148 | continue | 156 | continue |
149 | } | 157 | } |
@@ -176,7 +184,7 @@ type TemplateWrapExpr struct { | |||
176 | } | 184 | } |
177 | 185 | ||
178 | func (e *TemplateWrapExpr) walkChildNodes(w internalWalkFunc) { | 186 | func (e *TemplateWrapExpr) walkChildNodes(w internalWalkFunc) { |
179 | e.Wrapped = w(e.Wrapped).(Expression) | 187 | w(e.Wrapped) |
180 | } | 188 | } |
181 | 189 | ||
182 | func (e *TemplateWrapExpr) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) { | 190 | func (e *TemplateWrapExpr) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) { |
diff --git a/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/navigation.go b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/navigation.go index 4d41b6b..c8c97f3 100644 --- a/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/navigation.go +++ b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/navigation.go | |||
@@ -3,6 +3,8 @@ package hclsyntax | |||
3 | import ( | 3 | import ( |
4 | "bytes" | 4 | "bytes" |
5 | "fmt" | 5 | "fmt" |
6 | |||
7 | "github.com/hashicorp/hcl2/hcl" | ||
6 | ) | 8 | ) |
7 | 9 | ||
8 | type navigation struct { | 10 | type navigation struct { |
@@ -39,3 +41,19 @@ func (n navigation) ContextString(offset int) string { | |||
39 | } | 41 | } |
40 | return buf.String() | 42 | return buf.String() |
41 | } | 43 | } |
44 | |||
45 | func (n navigation) ContextDefRange(offset int) hcl.Range { | ||
46 | var block *Block | ||
47 | for _, candidate := range n.root.Blocks { | ||
48 | if candidate.Range().ContainsOffset(offset) { | ||
49 | block = candidate | ||
50 | break | ||
51 | } | ||
52 | } | ||
53 | |||
54 | if block == nil { | ||
55 | return hcl.Range{} | ||
56 | } | ||
57 | |||
58 | return block.DefRange() | ||
59 | } | ||
diff --git a/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/node.go b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/node.go index fd426d4..75812e6 100644 --- a/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/node.go +++ b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/node.go | |||
@@ -19,4 +19,4 @@ type Node interface { | |||
19 | Range() hcl.Range | 19 | Range() hcl.Range |
20 | } | 20 | } |
21 | 21 | ||
22 | type internalWalkFunc func(Node) Node | 22 | type internalWalkFunc func(Node) |
diff --git a/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/parser.go b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/parser.go index 002858f..253ad50 100644 --- a/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/parser.go +++ b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/parser.go | |||
@@ -9,7 +9,6 @@ import ( | |||
9 | "github.com/apparentlymart/go-textseg/textseg" | 9 | "github.com/apparentlymart/go-textseg/textseg" |
10 | "github.com/hashicorp/hcl2/hcl" | 10 | "github.com/hashicorp/hcl2/hcl" |
11 | "github.com/zclconf/go-cty/cty" | 11 | "github.com/zclconf/go-cty/cty" |
12 | "github.com/zclconf/go-cty/cty/convert" | ||
13 | ) | 12 | ) |
14 | 13 | ||
15 | type parser struct { | 14 | type parser struct { |
@@ -55,7 +54,7 @@ Token: | |||
55 | Severity: hcl.DiagError, | 54 | Severity: hcl.DiagError, |
56 | Summary: "Attribute redefined", | 55 | Summary: "Attribute redefined", |
57 | Detail: fmt.Sprintf( | 56 | Detail: fmt.Sprintf( |
58 | "The attribute %q was already defined at %s. Each attribute may be defined only once.", | 57 | "The argument %q was already set at %s. Each argument may be set only once.", |
59 | titem.Name, existing.NameRange.String(), | 58 | titem.Name, existing.NameRange.String(), |
60 | ), | 59 | ), |
61 | Subject: &titem.NameRange, | 60 | Subject: &titem.NameRange, |
@@ -80,15 +79,15 @@ Token: | |||
80 | if bad.Type == TokenOQuote { | 79 | if bad.Type == TokenOQuote { |
81 | diags = append(diags, &hcl.Diagnostic{ | 80 | diags = append(diags, &hcl.Diagnostic{ |
82 | Severity: hcl.DiagError, | 81 | Severity: hcl.DiagError, |
83 | Summary: "Invalid attribute name", | 82 | Summary: "Invalid argument name", |
84 | Detail: "Attribute names must not be quoted.", | 83 | Detail: "Argument names must not be quoted.", |
85 | Subject: &bad.Range, | 84 | Subject: &bad.Range, |
86 | }) | 85 | }) |
87 | } else { | 86 | } else { |
88 | diags = append(diags, &hcl.Diagnostic{ | 87 | diags = append(diags, &hcl.Diagnostic{ |
89 | Severity: hcl.DiagError, | 88 | Severity: hcl.DiagError, |
90 | Summary: "Attribute or block definition required", | 89 | Summary: "Argument or block definition required", |
91 | Detail: "An attribute or block definition is required here.", | 90 | Detail: "An argument or block definition is required here.", |
92 | Subject: &bad.Range, | 91 | Subject: &bad.Range, |
93 | }) | 92 | }) |
94 | } | 93 | } |
@@ -120,8 +119,8 @@ func (p *parser) ParseBodyItem() (Node, hcl.Diagnostics) { | |||
120 | return nil, hcl.Diagnostics{ | 119 | return nil, hcl.Diagnostics{ |
121 | { | 120 | { |
122 | Severity: hcl.DiagError, | 121 | Severity: hcl.DiagError, |
123 | Summary: "Attribute or block definition required", | 122 | Summary: "Argument or block definition required", |
124 | Detail: "An attribute or block definition is required here.", | 123 | Detail: "An argument or block definition is required here.", |
125 | Subject: &ident.Range, | 124 | Subject: &ident.Range, |
126 | }, | 125 | }, |
127 | } | 126 | } |
@@ -131,7 +130,7 @@ func (p *parser) ParseBodyItem() (Node, hcl.Diagnostics) { | |||
131 | 130 | ||
132 | switch next.Type { | 131 | switch next.Type { |
133 | case TokenEqual: | 132 | case TokenEqual: |
134 | return p.finishParsingBodyAttribute(ident) | 133 | return p.finishParsingBodyAttribute(ident, false) |
135 | case TokenOQuote, TokenOBrace, TokenIdent: | 134 | case TokenOQuote, TokenOBrace, TokenIdent: |
136 | return p.finishParsingBodyBlock(ident) | 135 | return p.finishParsingBodyBlock(ident) |
137 | default: | 136 | default: |
@@ -139,8 +138,8 @@ func (p *parser) ParseBodyItem() (Node, hcl.Diagnostics) { | |||
139 | return nil, hcl.Diagnostics{ | 138 | return nil, hcl.Diagnostics{ |
140 | { | 139 | { |
141 | Severity: hcl.DiagError, | 140 | Severity: hcl.DiagError, |
142 | Summary: "Attribute or block definition required", | 141 | Summary: "Argument or block definition required", |
143 | Detail: "An attribute or block definition is required here. To define an attribute, use the equals sign \"=\" to introduce the attribute value.", | 142 | Detail: "An argument or block definition is required here. To set an argument, use the equals sign \"=\" to introduce the argument value.", |
144 | Subject: &ident.Range, | 143 | Subject: &ident.Range, |
145 | }, | 144 | }, |
146 | } | 145 | } |
@@ -149,7 +148,72 @@ func (p *parser) ParseBodyItem() (Node, hcl.Diagnostics) { | |||
149 | return nil, nil | 148 | return nil, nil |
150 | } | 149 | } |
151 | 150 | ||
152 | func (p *parser) finishParsingBodyAttribute(ident Token) (Node, hcl.Diagnostics) { | 151 | // parseSingleAttrBody is a weird variant of ParseBody that deals with the |
152 | // body of a nested block containing only one attribute value all on a single | ||
153 | // line, like foo { bar = baz } . It expects to find a single attribute item | ||
154 | // immediately followed by the end token type with no intervening newlines. | ||
155 | func (p *parser) parseSingleAttrBody(end TokenType) (*Body, hcl.Diagnostics) { | ||
156 | ident := p.Read() | ||
157 | if ident.Type != TokenIdent { | ||
158 | p.recoverAfterBodyItem() | ||
159 | return nil, hcl.Diagnostics{ | ||
160 | { | ||
161 | Severity: hcl.DiagError, | ||
162 | Summary: "Argument or block definition required", | ||
163 | Detail: "An argument or block definition is required here.", | ||
164 | Subject: &ident.Range, | ||
165 | }, | ||
166 | } | ||
167 | } | ||
168 | |||
169 | var attr *Attribute | ||
170 | var diags hcl.Diagnostics | ||
171 | |||
172 | next := p.Peek() | ||
173 | |||
174 | switch next.Type { | ||
175 | case TokenEqual: | ||
176 | node, attrDiags := p.finishParsingBodyAttribute(ident, true) | ||
177 | diags = append(diags, attrDiags...) | ||
178 | attr = node.(*Attribute) | ||
179 | case TokenOQuote, TokenOBrace, TokenIdent: | ||
180 | p.recoverAfterBodyItem() | ||
181 | return nil, hcl.Diagnostics{ | ||
182 | { | ||
183 | Severity: hcl.DiagError, | ||
184 | Summary: "Argument definition required", | ||
185 | Detail: fmt.Sprintf("A single-line block definition can contain only a single argument. If you meant to define argument %q, use an equals sign to assign it a value. To define a nested block, place it on a line of its own within its parent block.", ident.Bytes), | ||
186 | Subject: hcl.RangeBetween(ident.Range, next.Range).Ptr(), | ||
187 | }, | ||
188 | } | ||
189 | default: | ||
190 | p.recoverAfterBodyItem() | ||
191 | return nil, hcl.Diagnostics{ | ||
192 | { | ||
193 | Severity: hcl.DiagError, | ||
194 | Summary: "Argument or block definition required", | ||
195 | Detail: "An argument or block definition is required here. To set an argument, use the equals sign \"=\" to introduce the argument value.", | ||
196 | Subject: &ident.Range, | ||
197 | }, | ||
198 | } | ||
199 | } | ||
200 | |||
201 | return &Body{ | ||
202 | Attributes: Attributes{ | ||
203 | string(ident.Bytes): attr, | ||
204 | }, | ||
205 | |||
206 | SrcRange: attr.SrcRange, | ||
207 | EndRange: hcl.Range{ | ||
208 | Filename: attr.SrcRange.Filename, | ||
209 | Start: attr.SrcRange.End, | ||
210 | End: attr.SrcRange.End, | ||
211 | }, | ||
212 | }, diags | ||
213 | |||
214 | } | ||
215 | |||
216 | func (p *parser) finishParsingBodyAttribute(ident Token, singleLine bool) (Node, hcl.Diagnostics) { | ||
153 | eqTok := p.Read() // eat equals token | 217 | eqTok := p.Read() // eat equals token |
154 | if eqTok.Type != TokenEqual { | 218 | if eqTok.Type != TokenEqual { |
155 | // should never happen if caller behaves | 219 | // should never happen if caller behaves |
@@ -166,22 +230,33 @@ func (p *parser) finishParsingBodyAttribute(ident Token) (Node, hcl.Diagnostics) | |||
166 | endRange = p.PrevRange() | 230 | endRange = p.PrevRange() |
167 | p.recoverAfterBodyItem() | 231 | p.recoverAfterBodyItem() |
168 | } else { | 232 | } else { |
169 | end := p.Peek() | 233 | endRange = p.PrevRange() |
170 | if end.Type != TokenNewline && end.Type != TokenEOF { | 234 | if !singleLine { |
171 | if !p.recovery { | 235 | end := p.Peek() |
172 | diags = append(diags, &hcl.Diagnostic{ | 236 | if end.Type != TokenNewline && end.Type != TokenEOF { |
173 | Severity: hcl.DiagError, | 237 | if !p.recovery { |
174 | Summary: "Missing newline after attribute definition", | 238 | summary := "Missing newline after argument" |
175 | Detail: "An attribute definition must end with a newline.", | 239 | detail := "An argument definition must end with a newline." |
176 | Subject: &end.Range, | 240 | |
177 | Context: hcl.RangeBetween(ident.Range, end.Range).Ptr(), | 241 | if end.Type == TokenComma { |
178 | }) | 242 | summary = "Unexpected comma after argument" |
243 | detail = "Argument definitions must be separated by newlines, not commas. " + detail | ||
244 | } | ||
245 | |||
246 | diags = append(diags, &hcl.Diagnostic{ | ||
247 | Severity: hcl.DiagError, | ||
248 | Summary: summary, | ||
249 | Detail: detail, | ||
250 | Subject: &end.Range, | ||
251 | Context: hcl.RangeBetween(ident.Range, end.Range).Ptr(), | ||
252 | }) | ||
253 | } | ||
254 | endRange = p.PrevRange() | ||
255 | p.recoverAfterBodyItem() | ||
256 | } else { | ||
257 | endRange = p.PrevRange() | ||
258 | p.Read() // eat newline | ||
179 | } | 259 | } |
180 | endRange = p.PrevRange() | ||
181 | p.recoverAfterBodyItem() | ||
182 | } else { | ||
183 | endRange = p.PrevRange() | ||
184 | p.Read() // eat newline | ||
185 | } | 260 | } |
186 | } | 261 | } |
187 | 262 | ||
@@ -218,19 +293,9 @@ Token: | |||
218 | diags = append(diags, labelDiags...) | 293 | diags = append(diags, labelDiags...) |
219 | labels = append(labels, label) | 294 | labels = append(labels, label) |
220 | labelRanges = append(labelRanges, labelRange) | 295 | labelRanges = append(labelRanges, labelRange) |
221 | if labelDiags.HasErrors() { | 296 | // parseQuoteStringLiteral recovers up to the closing quote |
222 | p.recoverAfterBodyItem() | 297 | // if it encounters problems, so we can continue looking for |
223 | return &Block{ | 298 | // more labels and eventually the block body even. |
224 | Type: blockType, | ||
225 | Labels: labels, | ||
226 | Body: nil, | ||
227 | |||
228 | TypeRange: ident.Range, | ||
229 | LabelRanges: labelRanges, | ||
230 | OpenBraceRange: ident.Range, // placeholder | ||
231 | CloseBraceRange: ident.Range, // placeholder | ||
232 | }, diags | ||
233 | } | ||
234 | 299 | ||
235 | case TokenIdent: | 300 | case TokenIdent: |
236 | tok = p.Read() // eat token | 301 | tok = p.Read() // eat token |
@@ -244,7 +309,7 @@ Token: | |||
244 | diags = append(diags, &hcl.Diagnostic{ | 309 | diags = append(diags, &hcl.Diagnostic{ |
245 | Severity: hcl.DiagError, | 310 | Severity: hcl.DiagError, |
246 | Summary: "Invalid block definition", | 311 | Summary: "Invalid block definition", |
247 | Detail: "The equals sign \"=\" indicates an attribute definition, and must not be used when defining a block.", | 312 | Detail: "The equals sign \"=\" indicates an argument definition, and must not be used when defining a block.", |
248 | Subject: &tok.Range, | 313 | Subject: &tok.Range, |
249 | Context: hcl.RangeBetween(ident.Range, tok.Range).Ptr(), | 314 | Context: hcl.RangeBetween(ident.Range, tok.Range).Ptr(), |
250 | }) | 315 | }) |
@@ -273,7 +338,10 @@ Token: | |||
273 | return &Block{ | 338 | return &Block{ |
274 | Type: blockType, | 339 | Type: blockType, |
275 | Labels: labels, | 340 | Labels: labels, |
276 | Body: nil, | 341 | Body: &Body{ |
342 | SrcRange: ident.Range, | ||
343 | EndRange: ident.Range, | ||
344 | }, | ||
277 | 345 | ||
278 | TypeRange: ident.Range, | 346 | TypeRange: ident.Range, |
279 | LabelRanges: labelRanges, | 347 | LabelRanges: labelRanges, |
@@ -285,7 +353,51 @@ Token: | |||
285 | 353 | ||
286 | // Once we fall out here, the peeker is pointed just after our opening | 354 | // Once we fall out here, the peeker is pointed just after our opening |
287 | // brace, so we can begin our nested body parsing. | 355 | // brace, so we can begin our nested body parsing. |
288 | body, bodyDiags := p.ParseBody(TokenCBrace) | 356 | var body *Body |
357 | var bodyDiags hcl.Diagnostics | ||
358 | switch p.Peek().Type { | ||
359 | case TokenNewline, TokenEOF, TokenCBrace: | ||
360 | body, bodyDiags = p.ParseBody(TokenCBrace) | ||
361 | default: | ||
362 | // Special one-line, single-attribute block parsing mode. | ||
363 | body, bodyDiags = p.parseSingleAttrBody(TokenCBrace) | ||
364 | switch p.Peek().Type { | ||
365 | case TokenCBrace: | ||
366 | p.Read() // the happy path - just consume the closing brace | ||
367 | case TokenComma: | ||
368 | // User seems to be trying to use the object-constructor | ||
369 | // comma-separated style, which isn't permitted for blocks. | ||
370 | diags = append(diags, &hcl.Diagnostic{ | ||
371 | Severity: hcl.DiagError, | ||
372 | Summary: "Invalid single-argument block definition", | ||
373 | Detail: "Single-line block syntax can include only one argument definition. To define multiple arguments, use the multi-line block syntax with one argument definition per line.", | ||
374 | Subject: p.Peek().Range.Ptr(), | ||
375 | }) | ||
376 | p.recover(TokenCBrace) | ||
377 | case TokenNewline: | ||
378 | // We don't allow weird mixtures of single and multi-line syntax. | ||
379 | diags = append(diags, &hcl.Diagnostic{ | ||
380 | Severity: hcl.DiagError, | ||
381 | Summary: "Invalid single-argument block definition", | ||
382 | Detail: "An argument definition on the same line as its containing block creates a single-line block definition, which must also be closed on the same line. Place the block's closing brace immediately after the argument definition.", | ||
383 | Subject: p.Peek().Range.Ptr(), | ||
384 | }) | ||
385 | p.recover(TokenCBrace) | ||
386 | default: | ||
387 | // Some other weird thing is going on. Since we can't guess a likely | ||
388 | // user intent for this one, we'll skip it if we're already in | ||
389 | // recovery mode. | ||
390 | if !p.recovery { | ||
391 | diags = append(diags, &hcl.Diagnostic{ | ||
392 | Severity: hcl.DiagError, | ||
393 | Summary: "Invalid single-argument block definition", | ||
394 | Detail: "A single-line block definition must end with a closing brace immediately after its single argument definition.", | ||
395 | Subject: p.Peek().Range.Ptr(), | ||
396 | }) | ||
397 | } | ||
398 | p.recover(TokenCBrace) | ||
399 | } | ||
400 | } | ||
289 | diags = append(diags, bodyDiags...) | 401 | diags = append(diags, bodyDiags...) |
290 | cBraceRange := p.PrevRange() | 402 | cBraceRange := p.PrevRange() |
291 | 403 | ||
@@ -305,6 +417,17 @@ Token: | |||
305 | p.recoverAfterBodyItem() | 417 | p.recoverAfterBodyItem() |
306 | } | 418 | } |
307 | 419 | ||
420 | // We must never produce a nil body, since the caller may attempt to | ||
421 | // do analysis of a partial result when there's an error, so we'll | ||
422 | // insert a placeholder if we otherwise failed to produce a valid | ||
423 | // body due to one of the syntax error paths above. | ||
424 | if body == nil && diags.HasErrors() { | ||
425 | body = &Body{ | ||
426 | SrcRange: hcl.RangeBetween(oBrace.Range, cBraceRange), | ||
427 | EndRange: cBraceRange, | ||
428 | } | ||
429 | } | ||
430 | |||
308 | return &Block{ | 431 | return &Block{ |
309 | Type: blockType, | 432 | Type: blockType, |
310 | Labels: labels, | 433 | Labels: labels, |
@@ -459,7 +582,14 @@ func (p *parser) parseBinaryOps(ops []map[TokenType]*Operation) (Expression, hcl | |||
459 | 582 | ||
460 | func (p *parser) parseExpressionWithTraversals() (Expression, hcl.Diagnostics) { | 583 | func (p *parser) parseExpressionWithTraversals() (Expression, hcl.Diagnostics) { |
461 | term, diags := p.parseExpressionTerm() | 584 | term, diags := p.parseExpressionTerm() |
462 | ret := term | 585 | ret, moreDiags := p.parseExpressionTraversals(term) |
586 | diags = append(diags, moreDiags...) | ||
587 | return ret, diags | ||
588 | } | ||
589 | |||
590 | func (p *parser) parseExpressionTraversals(from Expression) (Expression, hcl.Diagnostics) { | ||
591 | var diags hcl.Diagnostics | ||
592 | ret := from | ||
463 | 593 | ||
464 | Traversal: | 594 | Traversal: |
465 | for { | 595 | for { |
@@ -657,44 +787,81 @@ Traversal: | |||
657 | // the key value is something constant. | 787 | // the key value is something constant. |
658 | 788 | ||
659 | open := p.Read() | 789 | open := p.Read() |
660 | // TODO: If we have a TokenStar inside our brackets, parse as | 790 | switch p.Peek().Type { |
661 | // a Splat expression: foo[*].baz[0]. | 791 | case TokenStar: |
662 | var close Token | 792 | // This is a full splat expression, like foo[*], which consumes |
663 | p.PushIncludeNewlines(false) // arbitrary newlines allowed in brackets | 793 | // the rest of the traversal steps after it using a recursive |
664 | keyExpr, keyDiags := p.ParseExpression() | 794 | // call to this function. |
665 | diags = append(diags, keyDiags...) | 795 | p.Read() // consume star |
666 | if p.recovery && keyDiags.HasErrors() { | 796 | close := p.Read() |
667 | close = p.recover(TokenCBrack) | ||
668 | } else { | ||
669 | close = p.Read() | ||
670 | if close.Type != TokenCBrack && !p.recovery { | 797 | if close.Type != TokenCBrack && !p.recovery { |
671 | diags = append(diags, &hcl.Diagnostic{ | 798 | diags = append(diags, &hcl.Diagnostic{ |
672 | Severity: hcl.DiagError, | 799 | Severity: hcl.DiagError, |
673 | Summary: "Missing close bracket on index", | 800 | Summary: "Missing close bracket on splat index", |
674 | Detail: "The index operator must end with a closing bracket (\"]\").", | 801 | Detail: "The star for a full splat operator must be immediately followed by a closing bracket (\"]\").", |
675 | Subject: &close.Range, | 802 | Subject: &close.Range, |
676 | }) | 803 | }) |
677 | close = p.recover(TokenCBrack) | 804 | close = p.recover(TokenCBrack) |
678 | } | 805 | } |
679 | } | 806 | // Splat expressions use a special "anonymous symbol" as a |
680 | p.PopIncludeNewlines() | 807 | // placeholder in an expression to be evaluated once for each |
808 | // item in the source expression. | ||
809 | itemExpr := &AnonSymbolExpr{ | ||
810 | SrcRange: hcl.RangeBetween(open.Range, close.Range), | ||
811 | } | ||
812 | // Now we'll recursively call this same function to eat any | ||
813 | // remaining traversal steps against the anonymous symbol. | ||
814 | travExpr, nestedDiags := p.parseExpressionTraversals(itemExpr) | ||
815 | diags = append(diags, nestedDiags...) | ||
681 | 816 | ||
682 | if lit, isLit := keyExpr.(*LiteralValueExpr); isLit { | 817 | ret = &SplatExpr{ |
683 | litKey, _ := lit.Value(nil) | 818 | Source: ret, |
684 | rng := hcl.RangeBetween(open.Range, close.Range) | 819 | Each: travExpr, |
685 | step := hcl.TraverseIndex{ | 820 | Item: itemExpr, |
686 | Key: litKey, | 821 | |
687 | SrcRange: rng, | 822 | SrcRange: hcl.RangeBetween(open.Range, travExpr.Range()), |
823 | MarkerRange: hcl.RangeBetween(open.Range, close.Range), | ||
688 | } | 824 | } |
689 | ret = makeRelativeTraversal(ret, step, rng) | ||
690 | } else { | ||
691 | rng := hcl.RangeBetween(open.Range, close.Range) | ||
692 | ret = &IndexExpr{ | ||
693 | Collection: ret, | ||
694 | Key: keyExpr, | ||
695 | 825 | ||
696 | SrcRange: rng, | 826 | default: |
697 | OpenRange: open.Range, | 827 | |
828 | var close Token | ||
829 | p.PushIncludeNewlines(false) // arbitrary newlines allowed in brackets | ||
830 | keyExpr, keyDiags := p.ParseExpression() | ||
831 | diags = append(diags, keyDiags...) | ||
832 | if p.recovery && keyDiags.HasErrors() { | ||
833 | close = p.recover(TokenCBrack) | ||
834 | } else { | ||
835 | close = p.Read() | ||
836 | if close.Type != TokenCBrack && !p.recovery { | ||
837 | diags = append(diags, &hcl.Diagnostic{ | ||
838 | Severity: hcl.DiagError, | ||
839 | Summary: "Missing close bracket on index", | ||
840 | Detail: "The index operator must end with a closing bracket (\"]\").", | ||
841 | Subject: &close.Range, | ||
842 | }) | ||
843 | close = p.recover(TokenCBrack) | ||
844 | } | ||
845 | } | ||
846 | p.PopIncludeNewlines() | ||
847 | |||
848 | if lit, isLit := keyExpr.(*LiteralValueExpr); isLit { | ||
849 | litKey, _ := lit.Value(nil) | ||
850 | rng := hcl.RangeBetween(open.Range, close.Range) | ||
851 | step := hcl.TraverseIndex{ | ||
852 | Key: litKey, | ||
853 | SrcRange: rng, | ||
854 | } | ||
855 | ret = makeRelativeTraversal(ret, step, rng) | ||
856 | } else { | ||
857 | rng := hcl.RangeBetween(open.Range, close.Range) | ||
858 | ret = &IndexExpr{ | ||
859 | Collection: ret, | ||
860 | Key: keyExpr, | ||
861 | |||
862 | SrcRange: rng, | ||
863 | OpenRange: open.Range, | ||
864 | } | ||
698 | } | 865 | } |
699 | } | 866 | } |
700 | 867 | ||
@@ -813,7 +980,7 @@ func (p *parser) parseExpressionTerm() (Expression, hcl.Diagnostics) { | |||
813 | case TokenOQuote, TokenOHeredoc: | 980 | case TokenOQuote, TokenOHeredoc: |
814 | open := p.Read() // eat opening marker | 981 | open := p.Read() // eat opening marker |
815 | closer := p.oppositeBracket(open.Type) | 982 | closer := p.oppositeBracket(open.Type) |
816 | exprs, passthru, _, diags := p.parseTemplateInner(closer) | 983 | exprs, passthru, _, diags := p.parseTemplateInner(closer, tokenOpensFlushHeredoc(open)) |
817 | 984 | ||
818 | closeRange := p.PrevRange() | 985 | closeRange := p.PrevRange() |
819 | 986 | ||
@@ -891,11 +1058,10 @@ func (p *parser) parseExpressionTerm() (Expression, hcl.Diagnostics) { | |||
891 | } | 1058 | } |
892 | 1059 | ||
893 | func (p *parser) numberLitValue(tok Token) (cty.Value, hcl.Diagnostics) { | 1060 | func (p *parser) numberLitValue(tok Token) (cty.Value, hcl.Diagnostics) { |
894 | // We'll lean on the cty converter to do the conversion, to ensure that | 1061 | // The cty.ParseNumberVal is always the same behavior as converting a |
895 | // the behavior is the same as what would happen if converting a | 1062 | // string to a number, ensuring we always interpret decimal numbers in |
896 | // non-literal string to a number. | 1063 | // the same way. |
897 | numStrVal := cty.StringVal(string(tok.Bytes)) | 1064 | numVal, err := cty.ParseNumberVal(string(tok.Bytes)) |
898 | numVal, err := convert.Convert(numStrVal, cty.Number) | ||
899 | if err != nil { | 1065 | if err != nil { |
900 | ret := cty.UnknownVal(cty.Number) | 1066 | ret := cty.UnknownVal(cty.Number) |
901 | return ret, hcl.Diagnostics{ | 1067 | return ret, hcl.Diagnostics{ |
@@ -1087,13 +1253,19 @@ func (p *parser) parseObjectCons() (Expression, hcl.Diagnostics) { | |||
1087 | panic("parseObjectCons called without peeker pointing to open brace") | 1253 | panic("parseObjectCons called without peeker pointing to open brace") |
1088 | } | 1254 | } |
1089 | 1255 | ||
1090 | p.PushIncludeNewlines(true) | 1256 | // We must temporarily stop looking at newlines here while we check for |
1091 | defer p.PopIncludeNewlines() | 1257 | // a "for" keyword, since for expressions are _not_ newline-sensitive, |
1092 | 1258 | // even though object constructors are. | |
1093 | if forKeyword.TokenMatches(p.Peek()) { | 1259 | p.PushIncludeNewlines(false) |
1260 | isFor := forKeyword.TokenMatches(p.Peek()) | ||
1261 | p.PopIncludeNewlines() | ||
1262 | if isFor { | ||
1094 | return p.finishParsingForExpr(open) | 1263 | return p.finishParsingForExpr(open) |
1095 | } | 1264 | } |
1096 | 1265 | ||
1266 | p.PushIncludeNewlines(true) | ||
1267 | defer p.PopIncludeNewlines() | ||
1268 | |||
1097 | var close Token | 1269 | var close Token |
1098 | 1270 | ||
1099 | var diags hcl.Diagnostics | 1271 | var diags hcl.Diagnostics |
@@ -1132,19 +1304,36 @@ func (p *parser) parseObjectCons() (Expression, hcl.Diagnostics) { | |||
1132 | next = p.Peek() | 1304 | next = p.Peek() |
1133 | if next.Type != TokenEqual && next.Type != TokenColon { | 1305 | if next.Type != TokenEqual && next.Type != TokenColon { |
1134 | if !p.recovery { | 1306 | if !p.recovery { |
1135 | if next.Type == TokenNewline || next.Type == TokenComma { | 1307 | switch next.Type { |
1308 | case TokenNewline, TokenComma: | ||
1136 | diags = append(diags, &hcl.Diagnostic{ | 1309 | diags = append(diags, &hcl.Diagnostic{ |
1137 | Severity: hcl.DiagError, | 1310 | Severity: hcl.DiagError, |
1138 | Summary: "Missing item value", | 1311 | Summary: "Missing attribute value", |
1139 | Detail: "Expected an item value, introduced by an equals sign (\"=\").", | 1312 | Detail: "Expected an attribute value, introduced by an equals sign (\"=\").", |
1140 | Subject: &next.Range, | 1313 | Subject: &next.Range, |
1141 | Context: hcl.RangeBetween(open.Range, next.Range).Ptr(), | 1314 | Context: hcl.RangeBetween(open.Range, next.Range).Ptr(), |
1142 | }) | 1315 | }) |
1143 | } else { | 1316 | case TokenIdent: |
1317 | // Although this might just be a plain old missing equals | ||
1318 | // sign before a reference, one way to get here is to try | ||
1319 | // to write an attribute name containing a period followed | ||
1320 | // by a digit, which was valid in HCL1, like this: | ||
1321 | // foo1.2_bar = "baz" | ||
1322 | // We can't know exactly what the user intended here, but | ||
1323 | // we'll augment our message with an extra hint in this case | ||
1324 | // in case it is helpful. | ||
1144 | diags = append(diags, &hcl.Diagnostic{ | 1325 | diags = append(diags, &hcl.Diagnostic{ |
1145 | Severity: hcl.DiagError, | 1326 | Severity: hcl.DiagError, |
1146 | Summary: "Missing key/value separator", | 1327 | Summary: "Missing key/value separator", |
1147 | Detail: "Expected an equals sign (\"=\") to mark the beginning of the item value.", | 1328 | Detail: "Expected an equals sign (\"=\") to mark the beginning of the attribute value. If you intended to given an attribute name containing periods or spaces, write the name in quotes to create a string literal.", |
1329 | Subject: &next.Range, | ||
1330 | Context: hcl.RangeBetween(open.Range, next.Range).Ptr(), | ||
1331 | }) | ||
1332 | default: | ||
1333 | diags = append(diags, &hcl.Diagnostic{ | ||
1334 | Severity: hcl.DiagError, | ||
1335 | Summary: "Missing key/value separator", | ||
1336 | Detail: "Expected an equals sign (\"=\") to mark the beginning of the attribute value.", | ||
1148 | Subject: &next.Range, | 1337 | Subject: &next.Range, |
1149 | Context: hcl.RangeBetween(open.Range, next.Range).Ptr(), | 1338 | Context: hcl.RangeBetween(open.Range, next.Range).Ptr(), |
1150 | }) | 1339 | }) |
@@ -1182,8 +1371,8 @@ func (p *parser) parseObjectCons() (Expression, hcl.Diagnostics) { | |||
1182 | if !p.recovery { | 1371 | if !p.recovery { |
1183 | diags = append(diags, &hcl.Diagnostic{ | 1372 | diags = append(diags, &hcl.Diagnostic{ |
1184 | Severity: hcl.DiagError, | 1373 | Severity: hcl.DiagError, |
1185 | Summary: "Missing item separator", | 1374 | Summary: "Missing attribute separator", |
1186 | Detail: "Expected a newline or comma to mark the beginning of the next item.", | 1375 | Detail: "Expected a newline or comma to mark the beginning of the next attribute.", |
1187 | Subject: &next.Range, | 1376 | Subject: &next.Range, |
1188 | Context: hcl.RangeBetween(open.Range, next.Range).Ptr(), | 1377 | Context: hcl.RangeBetween(open.Range, next.Range).Ptr(), |
1189 | }) | 1378 | }) |
@@ -1205,6 +1394,8 @@ func (p *parser) parseObjectCons() (Expression, hcl.Diagnostics) { | |||
1205 | } | 1394 | } |
1206 | 1395 | ||
1207 | func (p *parser) finishParsingForExpr(open Token) (Expression, hcl.Diagnostics) { | 1396 | func (p *parser) finishParsingForExpr(open Token) (Expression, hcl.Diagnostics) { |
1397 | p.PushIncludeNewlines(false) | ||
1398 | defer p.PopIncludeNewlines() | ||
1208 | introducer := p.Read() | 1399 | introducer := p.Read() |
1209 | if !forKeyword.TokenMatches(introducer) { | 1400 | if !forKeyword.TokenMatches(introducer) { |
1210 | // Should never happen if callers are behaving | 1401 | // Should never happen if callers are behaving |
@@ -1277,7 +1468,7 @@ func (p *parser) finishParsingForExpr(open Token) (Expression, hcl.Diagnostics) | |||
1277 | diags = append(diags, &hcl.Diagnostic{ | 1468 | diags = append(diags, &hcl.Diagnostic{ |
1278 | Severity: hcl.DiagError, | 1469 | Severity: hcl.DiagError, |
1279 | Summary: "Invalid 'for' expression", | 1470 | Summary: "Invalid 'for' expression", |
1280 | Detail: "For expression requires 'in' keyword after names.", | 1471 | Detail: "For expression requires the 'in' keyword after its name declarations.", |
1281 | Subject: p.Peek().Range.Ptr(), | 1472 | Subject: p.Peek().Range.Ptr(), |
1282 | Context: hcl.RangeBetween(open.Range, p.Peek().Range).Ptr(), | 1473 | Context: hcl.RangeBetween(open.Range, p.Peek().Range).Ptr(), |
1283 | }) | 1474 | }) |
@@ -1305,7 +1496,7 @@ func (p *parser) finishParsingForExpr(open Token) (Expression, hcl.Diagnostics) | |||
1305 | diags = append(diags, &hcl.Diagnostic{ | 1496 | diags = append(diags, &hcl.Diagnostic{ |
1306 | Severity: hcl.DiagError, | 1497 | Severity: hcl.DiagError, |
1307 | Summary: "Invalid 'for' expression", | 1498 | Summary: "Invalid 'for' expression", |
1308 | Detail: "For expression requires colon after collection expression.", | 1499 | Detail: "For expression requires a colon after the collection expression.", |
1309 | Subject: p.Peek().Range.Ptr(), | 1500 | Subject: p.Peek().Range.Ptr(), |
1310 | Context: hcl.RangeBetween(open.Range, p.Peek().Range).Ptr(), | 1501 | Context: hcl.RangeBetween(open.Range, p.Peek().Range).Ptr(), |
1311 | }) | 1502 | }) |
@@ -1459,7 +1650,7 @@ Token: | |||
1459 | case TokenTemplateControl, TokenTemplateInterp: | 1650 | case TokenTemplateControl, TokenTemplateInterp: |
1460 | which := "$" | 1651 | which := "$" |
1461 | if tok.Type == TokenTemplateControl { | 1652 | if tok.Type == TokenTemplateControl { |
1462 | which = "!" | 1653 | which = "%" |
1463 | } | 1654 | } |
1464 | 1655 | ||
1465 | diags = append(diags, &hcl.Diagnostic{ | 1656 | diags = append(diags, &hcl.Diagnostic{ |
@@ -1472,7 +1663,16 @@ Token: | |||
1472 | Subject: &tok.Range, | 1663 | Subject: &tok.Range, |
1473 | Context: hcl.RangeBetween(oQuote.Range, tok.Range).Ptr(), | 1664 | Context: hcl.RangeBetween(oQuote.Range, tok.Range).Ptr(), |
1474 | }) | 1665 | }) |
1475 | p.recover(TokenTemplateSeqEnd) | 1666 | |
1667 | // Now that we're returning an error callers won't attempt to use | ||
1668 | // the result for any real operations, but they might try to use | ||
1669 | // the partial AST for other analyses, so we'll leave a marker | ||
1670 | // to indicate that there was something invalid in the string to | ||
1671 | // help avoid misinterpretation of the partial result | ||
1672 | ret.WriteString(which) | ||
1673 | ret.WriteString("{ ... }") | ||
1674 | |||
1675 | p.recover(TokenTemplateSeqEnd) // we'll try to keep parsing after the sequence ends | ||
1476 | 1676 | ||
1477 | case TokenEOF: | 1677 | case TokenEOF: |
1478 | diags = append(diags, &hcl.Diagnostic{ | 1678 | diags = append(diags, &hcl.Diagnostic{ |
@@ -1493,7 +1693,7 @@ Token: | |||
1493 | Subject: &tok.Range, | 1693 | Subject: &tok.Range, |
1494 | Context: hcl.RangeBetween(oQuote.Range, tok.Range).Ptr(), | 1694 | Context: hcl.RangeBetween(oQuote.Range, tok.Range).Ptr(), |
1495 | }) | 1695 | }) |
1496 | p.recover(TokenOQuote) | 1696 | p.recover(TokenCQuote) |
1497 | break Token | 1697 | break Token |
1498 | 1698 | ||
1499 | } | 1699 | } |
diff --git a/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/parser_template.go b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/parser_template.go index 3711067..a141626 100644 --- a/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/parser_template.go +++ b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/parser_template.go | |||
@@ -5,16 +5,17 @@ import ( | |||
5 | "strings" | 5 | "strings" |
6 | "unicode" | 6 | "unicode" |
7 | 7 | ||
8 | "github.com/apparentlymart/go-textseg/textseg" | ||
8 | "github.com/hashicorp/hcl2/hcl" | 9 | "github.com/hashicorp/hcl2/hcl" |
9 | "github.com/zclconf/go-cty/cty" | 10 | "github.com/zclconf/go-cty/cty" |
10 | ) | 11 | ) |
11 | 12 | ||
12 | func (p *parser) ParseTemplate() (Expression, hcl.Diagnostics) { | 13 | func (p *parser) ParseTemplate() (Expression, hcl.Diagnostics) { |
13 | return p.parseTemplate(TokenEOF) | 14 | return p.parseTemplate(TokenEOF, false) |
14 | } | 15 | } |
15 | 16 | ||
16 | func (p *parser) parseTemplate(end TokenType) (Expression, hcl.Diagnostics) { | 17 | func (p *parser) parseTemplate(end TokenType, flushHeredoc bool) (Expression, hcl.Diagnostics) { |
17 | exprs, passthru, rng, diags := p.parseTemplateInner(end) | 18 | exprs, passthru, rng, diags := p.parseTemplateInner(end, flushHeredoc) |
18 | 19 | ||
19 | if passthru { | 20 | if passthru { |
20 | if len(exprs) != 1 { | 21 | if len(exprs) != 1 { |
@@ -32,8 +33,11 @@ func (p *parser) parseTemplate(end TokenType) (Expression, hcl.Diagnostics) { | |||
32 | }, diags | 33 | }, diags |
33 | } | 34 | } |
34 | 35 | ||
35 | func (p *parser) parseTemplateInner(end TokenType) ([]Expression, bool, hcl.Range, hcl.Diagnostics) { | 36 | func (p *parser) parseTemplateInner(end TokenType, flushHeredoc bool) ([]Expression, bool, hcl.Range, hcl.Diagnostics) { |
36 | parts, diags := p.parseTemplateParts(end) | 37 | parts, diags := p.parseTemplateParts(end) |
38 | if flushHeredoc { | ||
39 | flushHeredocTemplateParts(parts) // Trim off leading spaces on lines per the flush heredoc spec | ||
40 | } | ||
37 | tp := templateParser{ | 41 | tp := templateParser{ |
38 | Tokens: parts.Tokens, | 42 | Tokens: parts.Tokens, |
39 | SrcRange: parts.SrcRange, | 43 | SrcRange: parts.SrcRange, |
@@ -649,6 +653,73 @@ Token: | |||
649 | return ret, diags | 653 | return ret, diags |
650 | } | 654 | } |
651 | 655 | ||
656 | // flushHeredocTemplateParts modifies in-place the line-leading literal strings | ||
657 | // to apply the flush heredoc processing rule: find the line with the smallest | ||
658 | // number of whitespace characters as prefix and then trim that number of | ||
659 | // characters from all of the lines. | ||
660 | // | ||
661 | // This rule is applied to static tokens rather than to the rendered result, | ||
662 | // so interpolating a string with leading whitespace cannot affect the chosen | ||
663 | // prefix length. | ||
664 | func flushHeredocTemplateParts(parts *templateParts) { | ||
665 | if len(parts.Tokens) == 0 { | ||
666 | // Nothing to do | ||
667 | return | ||
668 | } | ||
669 | |||
670 | const maxInt = int((^uint(0)) >> 1) | ||
671 | |||
672 | minSpaces := maxInt | ||
673 | newline := true | ||
674 | var adjust []*templateLiteralToken | ||
675 | for _, ttok := range parts.Tokens { | ||
676 | if newline { | ||
677 | newline = false | ||
678 | var spaces int | ||
679 | if lit, ok := ttok.(*templateLiteralToken); ok { | ||
680 | orig := lit.Val | ||
681 | trimmed := strings.TrimLeftFunc(orig, unicode.IsSpace) | ||
682 | // If a token is entirely spaces and ends with a newline | ||
683 | // then it's a "blank line" and thus not considered for | ||
684 | // space-prefix-counting purposes. | ||
685 | if len(trimmed) == 0 && strings.HasSuffix(orig, "\n") { | ||
686 | spaces = maxInt | ||
687 | } else { | ||
688 | spaceBytes := len(lit.Val) - len(trimmed) | ||
689 | spaces, _ = textseg.TokenCount([]byte(orig[:spaceBytes]), textseg.ScanGraphemeClusters) | ||
690 | adjust = append(adjust, lit) | ||
691 | } | ||
692 | } else if _, ok := ttok.(*templateEndToken); ok { | ||
693 | break // don't process the end token since it never has spaces before it | ||
694 | } | ||
695 | if spaces < minSpaces { | ||
696 | minSpaces = spaces | ||
697 | } | ||
698 | } | ||
699 | if lit, ok := ttok.(*templateLiteralToken); ok { | ||
700 | if strings.HasSuffix(lit.Val, "\n") { | ||
701 | newline = true // The following token, if any, begins a new line | ||
702 | } | ||
703 | } | ||
704 | } | ||
705 | |||
706 | for _, lit := range adjust { | ||
707 | // Since we want to count space _characters_ rather than space _bytes_, | ||
708 | // we can't just do a straightforward slice operation here and instead | ||
709 | // need to hunt for the split point with a scanner. | ||
710 | valBytes := []byte(lit.Val) | ||
711 | spaceByteCount := 0 | ||
712 | for i := 0; i < minSpaces; i++ { | ||
713 | adv, _, _ := textseg.ScanGraphemeClusters(valBytes, true) | ||
714 | spaceByteCount += adv | ||
715 | valBytes = valBytes[adv:] | ||
716 | } | ||
717 | lit.Val = lit.Val[spaceByteCount:] | ||
718 | lit.SrcRange.Start.Column += minSpaces | ||
719 | lit.SrcRange.Start.Byte += spaceByteCount | ||
720 | } | ||
721 | } | ||
722 | |||
652 | type templateParts struct { | 723 | type templateParts struct { |
653 | Tokens []templateToken | 724 | Tokens []templateToken |
654 | SrcRange hcl.Range | 725 | SrcRange hcl.Range |
diff --git a/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/scan_string_lit.go b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/scan_string_lit.go index de1f524..2895ade 100644 --- a/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/scan_string_lit.go +++ b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/scan_string_lit.go | |||
@@ -1,10 +1,10 @@ | |||
1 | // line 1 "scan_string_lit.rl" | 1 | //line scan_string_lit.rl:1 |
2 | 2 | ||
3 | package hclsyntax | 3 | package hclsyntax |
4 | 4 | ||
5 | // This file is generated from scan_string_lit.rl. DO NOT EDIT. | 5 | // This file is generated from scan_string_lit.rl. DO NOT EDIT. |
6 | 6 | ||
7 | // line 9 "scan_string_lit.go" | 7 | //line scan_string_lit.go:9 |
8 | var _hclstrtok_actions []byte = []byte{ | 8 | var _hclstrtok_actions []byte = []byte{ |
9 | 0, 1, 0, 1, 1, 2, 1, 0, | 9 | 0, 1, 0, 1, 1, 2, 1, 0, |
10 | } | 10 | } |
@@ -114,12 +114,12 @@ const hclstrtok_error int = 0 | |||
114 | const hclstrtok_en_quoted int = 10 | 114 | const hclstrtok_en_quoted int = 10 |
115 | const hclstrtok_en_unquoted int = 4 | 115 | const hclstrtok_en_unquoted int = 4 |
116 | 116 | ||
117 | // line 10 "scan_string_lit.rl" | 117 | //line scan_string_lit.rl:10 |
118 | 118 | ||
119 | func scanStringLit(data []byte, quoted bool) [][]byte { | 119 | func scanStringLit(data []byte, quoted bool) [][]byte { |
120 | var ret [][]byte | 120 | var ret [][]byte |
121 | 121 | ||
122 | // line 61 "scan_string_lit.rl" | 122 | //line scan_string_lit.rl:61 |
123 | 123 | ||
124 | // Ragel state | 124 | // Ragel state |
125 | p := 0 // "Pointer" into data | 125 | p := 0 // "Pointer" into data |
@@ -144,11 +144,11 @@ func scanStringLit(data []byte, quoted bool) [][]byte { | |||
144 | ret = append(ret, data[ts:te]) | 144 | ret = append(ret, data[ts:te]) |
145 | }*/ | 145 | }*/ |
146 | 146 | ||
147 | // line 154 "scan_string_lit.go" | 147 | //line scan_string_lit.go:154 |
148 | { | 148 | { |
149 | } | 149 | } |
150 | 150 | ||
151 | // line 158 "scan_string_lit.go" | 151 | //line scan_string_lit.go:158 |
152 | { | 152 | { |
153 | var _klen int | 153 | var _klen int |
154 | var _trans int | 154 | var _trans int |
@@ -229,7 +229,7 @@ func scanStringLit(data []byte, quoted bool) [][]byte { | |||
229 | _acts++ | 229 | _acts++ |
230 | switch _hclstrtok_actions[_acts-1] { | 230 | switch _hclstrtok_actions[_acts-1] { |
231 | case 0: | 231 | case 0: |
232 | // line 40 "scan_string_lit.rl" | 232 | //line scan_string_lit.rl:40 |
233 | 233 | ||
234 | // If te is behind p then we've skipped over some literal | 234 | // If te is behind p then we've skipped over some literal |
235 | // characters which we must now return. | 235 | // characters which we must now return. |
@@ -239,12 +239,12 @@ func scanStringLit(data []byte, quoted bool) [][]byte { | |||
239 | ts = p | 239 | ts = p |
240 | 240 | ||
241 | case 1: | 241 | case 1: |
242 | // line 48 "scan_string_lit.rl" | 242 | //line scan_string_lit.rl:48 |
243 | 243 | ||
244 | te = p | 244 | te = p |
245 | ret = append(ret, data[ts:te]) | 245 | ret = append(ret, data[ts:te]) |
246 | 246 | ||
247 | // line 255 "scan_string_lit.go" | 247 | //line scan_string_lit.go:253 |
248 | } | 248 | } |
249 | } | 249 | } |
250 | 250 | ||
@@ -267,12 +267,12 @@ func scanStringLit(data []byte, quoted bool) [][]byte { | |||
267 | __acts++ | 267 | __acts++ |
268 | switch _hclstrtok_actions[__acts-1] { | 268 | switch _hclstrtok_actions[__acts-1] { |
269 | case 1: | 269 | case 1: |
270 | // line 48 "scan_string_lit.rl" | 270 | //line scan_string_lit.rl:48 |
271 | 271 | ||
272 | te = p | 272 | te = p |
273 | ret = append(ret, data[ts:te]) | 273 | ret = append(ret, data[ts:te]) |
274 | 274 | ||
275 | // line 281 "scan_string_lit.go" | 275 | //line scan_string_lit.go:278 |
276 | } | 276 | } |
277 | } | 277 | } |
278 | } | 278 | } |
@@ -282,7 +282,7 @@ func scanStringLit(data []byte, quoted bool) [][]byte { | |||
282 | } | 282 | } |
283 | } | 283 | } |
284 | 284 | ||
285 | // line 89 "scan_string_lit.rl" | 285 | //line scan_string_lit.rl:89 |
286 | 286 | ||
287 | if te < p { | 287 | if te < p { |
288 | // Collect any leftover literal characters at the end of the input | 288 | // Collect any leftover literal characters at the end of the input |
diff --git a/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/scan_tokens.go b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/scan_tokens.go index 395e9c1..581e35e 100644 --- a/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/scan_tokens.go +++ b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/scan_tokens.go | |||
@@ -1,4 +1,4 @@ | |||
1 | // line 1 "scan_tokens.rl" | 1 | //line scan_tokens.rl:1 |
2 | 2 | ||
3 | package hclsyntax | 3 | package hclsyntax |
4 | 4 | ||
@@ -10,570 +10,256 @@ import ( | |||
10 | 10 | ||
11 | // This file is generated from scan_tokens.rl. DO NOT EDIT. | 11 | // This file is generated from scan_tokens.rl. DO NOT EDIT. |
12 | 12 | ||
13 | // line 15 "scan_tokens.go" | 13 | //line scan_tokens.go:15 |
14 | var _hcltok_actions []byte = []byte{ | 14 | var _hcltok_actions []byte = []byte{ |
15 | 0, 1, 0, 1, 1, 1, 2, 1, 3, | 15 | 0, 1, 0, 1, 1, 1, 3, 1, 4, |
16 | 1, 4, 1, 6, 1, 7, 1, 8, | 16 | 1, 7, 1, 8, 1, 9, 1, 10, |
17 | 1, 9, 1, 10, 1, 11, 1, 12, | 17 | 1, 11, 1, 12, 1, 13, 1, 14, |
18 | 1, 13, 1, 14, 1, 15, 1, 16, | 18 | 1, 15, 1, 16, 1, 17, 1, 18, |
19 | 1, 17, 1, 18, 1, 19, 1, 22, | 19 | 1, 19, 1, 20, 1, 23, 1, 24, |
20 | 1, 23, 1, 24, 1, 25, 1, 26, | 20 | 1, 25, 1, 26, 1, 27, 1, 28, |
21 | 1, 27, 1, 28, 1, 29, 1, 30, | 21 | 1, 29, 1, 30, 1, 31, 1, 32, |
22 | 1, 31, 1, 34, 1, 35, 1, 36, | 22 | 1, 35, 1, 36, 1, 37, 1, 38, |
23 | 1, 37, 1, 38, 1, 39, 1, 40, | 23 | 1, 39, 1, 40, 1, 41, 1, 42, |
24 | 1, 41, 1, 42, 1, 43, 1, 46, | 24 | 1, 43, 1, 44, 1, 47, 1, 48, |
25 | 1, 47, 1, 48, 1, 49, 1, 50, | 25 | 1, 49, 1, 50, 1, 51, 1, 52, |
26 | 1, 51, 1, 52, 1, 58, 1, 59, | 26 | 1, 53, 1, 56, 1, 57, 1, 58, |
27 | 1, 60, 1, 61, 1, 62, 1, 63, | 27 | 1, 59, 1, 60, 1, 61, 1, 62, |
28 | 1, 64, 1, 65, 1, 66, 1, 67, | 28 | 1, 63, 1, 64, 1, 65, 1, 66, |
29 | 1, 68, 1, 69, 1, 70, 1, 71, | 29 | 1, 67, 1, 68, 1, 69, 1, 70, |
30 | 1, 72, 1, 73, 1, 74, 1, 75, | 30 | 1, 71, 1, 72, 1, 73, 1, 74, |
31 | 1, 76, 1, 77, 1, 78, 1, 79, | 31 | 1, 75, 1, 76, 1, 77, 1, 78, |
32 | 1, 80, 1, 81, 1, 82, 1, 83, | 32 | 1, 79, 1, 80, 1, 81, 1, 82, |
33 | 1, 84, 1, 85, 1, 86, 1, 87, | 33 | 1, 83, 1, 84, 1, 85, 2, 0, |
34 | 2, 0, 15, 2, 1, 15, 2, 2, | 34 | 14, 2, 0, 25, 2, 0, 29, 2, |
35 | 24, 2, 2, 28, 2, 3, 24, 2, | 35 | 0, 37, 2, 0, 41, 2, 1, 2, |
36 | 3, 28, 2, 4, 5, 2, 7, 0, | 36 | 2, 4, 5, 2, 4, 6, 2, 4, |
37 | 2, 7, 1, 2, 7, 20, 2, 7, | 37 | 21, 2, 4, 22, 2, 4, 33, 2, |
38 | 21, 2, 7, 32, 2, 7, 33, 2, | 38 | 4, 34, 2, 4, 45, 2, 4, 46, |
39 | 7, 44, 2, 7, 45, 2, 7, 53, | 39 | 2, 4, 54, 2, 4, 55, |
40 | 2, 7, 54, 2, 7, 55, 2, 7, | ||
41 | 56, 2, 7, 57, 3, 7, 2, 20, | ||
42 | 3, 7, 3, 20, | ||
43 | } | 40 | } |
44 | 41 | ||
45 | var _hcltok_key_offsets []int16 = []int16{ | 42 | var _hcltok_key_offsets []int16 = []int16{ |
46 | 0, 0, 1, 2, 3, 5, 10, 14, | 43 | 0, 0, 1, 2, 4, 9, 13, 15, |
47 | 16, 58, 99, 145, 146, 150, 156, 156, | 44 | 57, 98, 144, 145, 149, 155, 155, 157, |
48 | 158, 160, 169, 175, 182, 183, 186, 187, | 45 | 159, 168, 174, 181, 182, 185, 186, 190, |
49 | 191, 196, 205, 209, 213, 221, 223, 225, | 46 | 195, 204, 208, 212, 220, 222, 224, 226, |
50 | 227, 230, 262, 264, 266, 270, 274, 277, | 47 | 229, 261, 263, 265, 269, 273, 276, 287, |
51 | 288, 301, 320, 333, 349, 361, 377, 392, | 48 | 300, 319, 332, 348, 360, 376, 391, 412, |
52 | 413, 423, 435, 446, 460, 475, 485, 497, | 49 | 422, 434, 445, 459, 474, 484, 496, 505, |
53 | 506, 518, 520, 524, 545, 554, 564, 570, | 50 | 517, 519, 523, 544, 553, 563, 569, 575, |
54 | 576, 577, 626, 628, 632, 634, 640, 647, | 51 | 576, 625, 627, 631, 633, 639, 646, 654, |
55 | 655, 662, 665, 671, 675, 679, 681, 685, | 52 | 661, 664, 670, 674, 678, 680, 684, 688, |
56 | 689, 693, 699, 707, 715, 721, 723, 727, | 53 | 692, 698, 706, 714, 720, 722, 726, 728, |
57 | 729, 735, 739, 743, 747, 751, 756, 763, | 54 | 734, 738, 742, 746, 750, 755, 762, 768, |
58 | 769, 771, 773, 777, 779, 785, 789, 793, | 55 | 770, 772, 776, 778, 784, 788, 792, 802, |
59 | 803, 808, 822, 837, 839, 847, 849, 854, | 56 | 807, 821, 836, 838, 846, 848, 853, 867, |
60 | 868, 873, 875, 879, 880, 884, 890, 896, | 57 | 872, 874, 878, 879, 883, 889, 895, 905, |
61 | 906, 916, 927, 935, 938, 941, 945, 949, | 58 | 915, 926, 934, 937, 940, 944, 948, 950, |
62 | 951, 954, 954, 957, 959, 989, 991, 993, | 59 | 953, 953, 956, 958, 988, 990, 992, 996, |
63 | 997, 1002, 1006, 1011, 1013, 1015, 1017, 1026, | 60 | 1001, 1005, 1010, 1012, 1014, 1016, 1025, 1029, |
64 | 1030, 1034, 1040, 1042, 1050, 1058, 1070, 1073, | 61 | 1033, 1039, 1041, 1049, 1057, 1069, 1072, 1078, |
65 | 1079, 1083, 1085, 1089, 1109, 1111, 1113, 1124, | 62 | 1082, 1084, 1088, 1108, 1110, 1112, 1123, 1129, |
66 | 1130, 1132, 1134, 1136, 1140, 1146, 1152, 1154, | 63 | 1131, 1133, 1135, 1139, 1145, 1151, 1153, 1158, |
67 | 1159, 1163, 1165, 1173, 1191, 1231, 1241, 1245, | 64 | 1162, 1164, 1172, 1190, 1230, 1240, 1244, 1246, |
68 | 1247, 1249, 1250, 1254, 1258, 1262, 1266, 1270, | 65 | 1248, 1249, 1253, 1257, 1261, 1265, 1269, 1274, |
69 | 1275, 1279, 1283, 1287, 1289, 1291, 1295, 1305, | 66 | 1278, 1282, 1286, 1288, 1290, 1294, 1304, 1308, |
70 | 1309, 1311, 1315, 1319, 1323, 1336, 1338, 1340, | 67 | 1310, 1314, 1318, 1322, 1335, 1337, 1339, 1343, |
71 | 1344, 1346, 1350, 1352, 1354, 1384, 1388, 1392, | 68 | 1345, 1349, 1351, 1353, 1383, 1387, 1391, 1395, |
72 | 1396, 1399, 1406, 1411, 1422, 1426, 1442, 1456, | 69 | 1398, 1405, 1410, 1421, 1425, 1441, 1455, 1459, |
73 | 1460, 1465, 1469, 1473, 1479, 1481, 1487, 1489, | 70 | 1464, 1468, 1472, 1478, 1480, 1486, 1488, 1492, |
74 | 1493, 1495, 1501, 1506, 1511, 1521, 1523, 1525, | 71 | 1494, 1500, 1505, 1510, 1520, 1522, 1524, 1528, |
75 | 1529, 1533, 1535, 1548, 1550, 1554, 1558, 1566, | 72 | 1532, 1534, 1547, 1549, 1553, 1557, 1565, 1567, |
76 | 1568, 1572, 1574, 1575, 1578, 1583, 1585, 1587, | 73 | 1571, 1573, 1574, 1577, 1582, 1584, 1586, 1590, |
77 | 1591, 1593, 1597, 1603, 1623, 1629, 1635, 1637, | 74 | 1592, 1596, 1602, 1622, 1628, 1634, 1636, 1637, |
78 | 1638, 1648, 1649, 1657, 1664, 1666, 1669, 1671, | 75 | 1647, 1648, 1656, 1663, 1665, 1668, 1670, 1672, |
79 | 1673, 1675, 1680, 1684, 1688, 1693, 1703, 1713, | 76 | 1674, 1679, 1683, 1687, 1692, 1702, 1712, 1716, |
80 | 1717, 1721, 1735, 1761, 1771, 1773, 1775, 1778, | 77 | 1720, 1734, 1760, 1770, 1772, 1774, 1777, 1779, |
81 | 1780, 1783, 1785, 1789, 1791, 1792, 1796, 1798, | 78 | 1782, 1784, 1788, 1790, 1791, 1795, 1797, 1800, |
82 | 1801, 1808, 1816, 1818, 1820, 1824, 1826, 1832, | 79 | 1807, 1815, 1817, 1819, 1823, 1825, 1831, 1842, |
83 | 1843, 1846, 1848, 1852, 1857, 1887, 1892, 1894, | 80 | 1845, 1847, 1851, 1856, 1886, 1891, 1893, 1896, |
84 | 1897, 1902, 1916, 1923, 1937, 1942, 1955, 1959, | 81 | 1901, 1915, 1922, 1936, 1941, 1954, 1958, 1971, |
85 | 1972, 1977, 1995, 1996, 2005, 2009, 2021, 2026, | 82 | 1976, 1994, 1995, 2004, 2008, 2020, 2025, 2032, |
86 | 2033, 2040, 2047, 2049, 2053, 2075, 2080, 2081, | 83 | 2039, 2046, 2048, 2052, 2074, 2079, 2080, 2084, |
87 | 2085, 2087, 2137, 2140, 2151, 2155, 2157, 2163, | 84 | 2086, 2136, 2139, 2150, 2154, 2156, 2162, 2168, |
88 | 2169, 2171, 2176, 2178, 2182, 2184, 2185, 2187, | 85 | 2170, 2175, 2177, 2181, 2183, 2184, 2186, 2188, |
89 | 2189, 2195, 2197, 2199, 2203, 2209, 2222, 2224, | 86 | 2194, 2196, 2198, 2202, 2208, 2221, 2223, 2229, |
90 | 2230, 2234, 2242, 2253, 2261, 2264, 2294, 2300, | 87 | 2233, 2241, 2252, 2260, 2263, 2293, 2299, 2302, |
91 | 2303, 2308, 2310, 2314, 2318, 2322, 2324, 2331, | 88 | 2307, 2309, 2313, 2317, 2321, 2323, 2330, 2332, |
92 | 2333, 2342, 2349, 2357, 2359, 2379, 2391, 2395, | 89 | 2341, 2348, 2356, 2358, 2378, 2390, 2394, 2396, |
93 | 2397, 2415, 2454, 2456, 2460, 2462, 2469, 2473, | 90 | 2414, 2453, 2455, 2459, 2461, 2468, 2472, 2500, |
94 | 2501, 2503, 2505, 2507, 2509, 2512, 2514, 2518, | 91 | 2502, 2504, 2506, 2508, 2511, 2513, 2517, 2521, |
95 | 2522, 2524, 2527, 2529, 2531, 2534, 2536, 2538, | 92 | 2523, 2526, 2528, 2530, 2533, 2535, 2537, 2538, |
96 | 2539, 2541, 2543, 2547, 2551, 2554, 2567, 2569, | 93 | 2540, 2542, 2546, 2550, 2553, 2566, 2568, 2574, |
97 | 2575, 2579, 2581, 2585, 2589, 2603, 2606, 2615, | 94 | 2578, 2580, 2584, 2588, 2602, 2605, 2614, 2616, |
98 | 2617, 2621, 2627, 2627, 2629, 2631, 2640, 2646, | 95 | 2620, 2626, 2626, 2628, 2630, 2639, 2645, 2652, |
99 | 2653, 2654, 2657, 2658, 2662, 2667, 2676, 2680, | 96 | 2653, 2656, 2657, 2661, 2666, 2675, 2679, 2683, |
100 | 2684, 2692, 2694, 2696, 2698, 2701, 2733, 2735, | 97 | 2691, 2693, 2695, 2697, 2700, 2732, 2734, 2736, |
101 | 2737, 2741, 2745, 2748, 2759, 2772, 2791, 2804, | 98 | 2740, 2744, 2747, 2758, 2771, 2790, 2803, 2819, |
102 | 2820, 2832, 2848, 2863, 2884, 2894, 2906, 2917, | 99 | 2831, 2847, 2862, 2883, 2893, 2905, 2916, 2930, |
103 | 2931, 2946, 2956, 2968, 2977, 2989, 2991, 2995, | 100 | 2945, 2955, 2967, 2976, 2988, 2990, 2994, 3015, |
104 | 3016, 3025, 3035, 3041, 3047, 3048, 3097, 3099, | 101 | 3024, 3034, 3040, 3046, 3047, 3096, 3098, 3102, |
105 | 3103, 3105, 3111, 3118, 3126, 3133, 3136, 3142, | 102 | 3104, 3110, 3117, 3125, 3132, 3135, 3141, 3145, |
106 | 3146, 3150, 3152, 3156, 3160, 3164, 3170, 3178, | 103 | 3149, 3151, 3155, 3159, 3163, 3169, 3177, 3185, |
107 | 3186, 3192, 3194, 3198, 3200, 3206, 3210, 3214, | 104 | 3191, 3193, 3197, 3199, 3205, 3209, 3213, 3217, |
108 | 3218, 3222, 3227, 3234, 3240, 3242, 3244, 3248, | 105 | 3221, 3226, 3233, 3239, 3241, 3243, 3247, 3249, |
109 | 3250, 3256, 3260, 3264, 3274, 3279, 3293, 3308, | 106 | 3255, 3259, 3263, 3273, 3278, 3292, 3307, 3309, |
110 | 3310, 3318, 3320, 3325, 3339, 3344, 3346, 3350, | 107 | 3317, 3319, 3324, 3338, 3343, 3345, 3349, 3350, |
111 | 3351, 3355, 3361, 3367, 3377, 3387, 3398, 3406, | 108 | 3354, 3360, 3366, 3376, 3386, 3397, 3405, 3408, |
112 | 3409, 3412, 3416, 3420, 3422, 3425, 3425, 3428, | 109 | 3411, 3415, 3419, 3421, 3424, 3424, 3427, 3429, |
113 | 3430, 3460, 3462, 3464, 3468, 3473, 3477, 3482, | 110 | 3459, 3461, 3463, 3467, 3472, 3476, 3481, 3483, |
114 | 3484, 3486, 3488, 3497, 3501, 3505, 3511, 3513, | 111 | 3485, 3487, 3496, 3500, 3504, 3510, 3512, 3520, |
115 | 3521, 3529, 3541, 3544, 3550, 3554, 3556, 3560, | 112 | 3528, 3540, 3543, 3549, 3553, 3555, 3559, 3579, |
116 | 3580, 3582, 3584, 3595, 3601, 3603, 3605, 3607, | 113 | 3581, 3583, 3594, 3600, 3602, 3604, 3606, 3610, |
117 | 3611, 3617, 3623, 3625, 3630, 3634, 3636, 3644, | 114 | 3616, 3622, 3624, 3629, 3633, 3635, 3643, 3661, |
118 | 3662, 3702, 3712, 3716, 3718, 3720, 3721, 3725, | 115 | 3701, 3711, 3715, 3717, 3719, 3720, 3724, 3728, |
119 | 3729, 3733, 3737, 3741, 3746, 3750, 3754, 3758, | 116 | 3732, 3736, 3740, 3745, 3749, 3753, 3757, 3759, |
120 | 3760, 3762, 3766, 3776, 3780, 3782, 3786, 3790, | 117 | 3761, 3765, 3775, 3779, 3781, 3785, 3789, 3793, |
121 | 3794, 3807, 3809, 3811, 3815, 3817, 3821, 3823, | 118 | 3806, 3808, 3810, 3814, 3816, 3820, 3822, 3824, |
122 | 3825, 3855, 3859, 3863, 3867, 3870, 3877, 3882, | 119 | 3854, 3858, 3862, 3866, 3869, 3876, 3881, 3892, |
123 | 3893, 3897, 3913, 3927, 3931, 3936, 3940, 3944, | 120 | 3896, 3912, 3926, 3930, 3935, 3939, 3943, 3949, |
124 | 3950, 3952, 3958, 3960, 3964, 3966, 3972, 3977, | 121 | 3951, 3957, 3959, 3963, 3965, 3971, 3976, 3981, |
125 | 3982, 3992, 3994, 3996, 4000, 4004, 4006, 4019, | 122 | 3991, 3993, 3995, 3999, 4003, 4005, 4018, 4020, |
126 | 4021, 4025, 4029, 4037, 4039, 4043, 4045, 4046, | 123 | 4024, 4028, 4036, 4038, 4042, 4044, 4045, 4048, |
127 | 4049, 4054, 4056, 4058, 4062, 4064, 4068, 4074, | 124 | 4053, 4055, 4057, 4061, 4063, 4067, 4073, 4093, |
128 | 4094, 4100, 4106, 4108, 4109, 4119, 4120, 4128, | 125 | 4099, 4105, 4107, 4108, 4118, 4119, 4127, 4134, |
129 | 4135, 4137, 4140, 4142, 4144, 4146, 4151, 4155, | 126 | 4136, 4139, 4141, 4143, 4145, 4150, 4154, 4158, |
130 | 4159, 4164, 4174, 4184, 4188, 4192, 4206, 4232, | 127 | 4163, 4173, 4183, 4187, 4191, 4205, 4231, 4241, |
131 | 4242, 4244, 4246, 4249, 4251, 4254, 4256, 4260, | 128 | 4243, 4245, 4248, 4250, 4253, 4255, 4259, 4261, |
132 | 4262, 4263, 4267, 4269, 4271, 4278, 4282, 4289, | 129 | 4262, 4266, 4268, 4270, 4277, 4281, 4288, 4295, |
133 | 4296, 4305, 4321, 4333, 4351, 4362, 4374, 4382, | 130 | 4304, 4320, 4332, 4350, 4361, 4373, 4381, 4399, |
134 | 4400, 4408, 4438, 4441, 4451, 4461, 4473, 4484, | 131 | 4407, 4437, 4440, 4450, 4460, 4472, 4483, 4492, |
135 | 4493, 4506, 4518, 4522, 4528, 4555, 4564, 4567, | 132 | 4505, 4517, 4521, 4527, 4554, 4563, 4566, 4571, |
136 | 4572, 4578, 4583, 4604, 4608, 4614, 4614, 4621, | 133 | 4577, 4582, 4603, 4607, 4613, 4613, 4620, 4629, |
137 | 4630, 4638, 4641, 4645, 4651, 4657, 4660, 4664, | 134 | 4637, 4640, 4644, 4650, 4656, 4659, 4663, 4670, |
138 | 4671, 4677, 4686, 4695, 4699, 4703, 4707, 4711, | 135 | 4676, 4685, 4694, 4698, 4702, 4706, 4710, 4717, |
139 | 4718, 4722, 4726, 4736, 4742, 4746, 4752, 4756, | 136 | 4721, 4725, 4735, 4741, 4745, 4751, 4755, 4758, |
140 | 4759, 4765, 4771, 4783, 4787, 4791, 4801, 4805, | 137 | 4764, 4770, 4782, 4786, 4790, 4800, 4804, 4815, |
141 | 4816, 4818, 4820, 4824, 4836, 4841, 4865, 4869, | 138 | 4817, 4819, 4823, 4835, 4840, 4864, 4868, 4874, |
142 | 4875, 4897, 4906, 4910, 4913, 4914, 4922, 4930, | 139 | 4896, 4905, 4909, 4912, 4913, 4921, 4929, 4935, |
143 | 4936, 4946, 4953, 4971, 4974, 4977, 4985, 4991, | 140 | 4945, 4952, 4970, 4973, 4976, 4984, 4990, 4994, |
144 | 4995, 4999, 5003, 5009, 5017, 5022, 5028, 5032, | 141 | 4998, 5002, 5008, 5016, 5021, 5027, 5031, 5039, |
145 | 5040, 5047, 5051, 5058, 5064, 5072, 5080, 5086, | 142 | 5046, 5050, 5057, 5063, 5071, 5079, 5085, 5091, |
146 | 5092, 5103, 5107, 5119, 5128, 5145, 5162, 5165, | 143 | 5102, 5106, 5118, 5127, 5144, 5161, 5164, 5168, |
147 | 5169, 5171, 5177, 5179, 5183, 5198, 5202, 5206, | 144 | 5170, 5176, 5178, 5182, 5197, 5201, 5205, 5209, |
148 | 5210, 5214, 5218, 5220, 5226, 5231, 5235, 5241, | 145 | 5213, 5217, 5219, 5225, 5230, 5234, 5240, 5247, |
149 | 5248, 5251, 5269, 5271, 5316, 5322, 5328, 5332, | 146 | 5250, 5268, 5270, 5315, 5321, 5327, 5331, 5335, |
150 | 5336, 5342, 5346, 5352, 5358, 5365, 5367, 5373, | 147 | 5341, 5345, 5351, 5357, 5364, 5366, 5372, 5378, |
151 | 5379, 5383, 5387, 5395, 5408, 5414, 5421, 5429, | 148 | 5382, 5386, 5394, 5407, 5413, 5420, 5428, 5434, |
152 | 5435, 5444, 5450, 5454, 5459, 5463, 5471, 5475, | 149 | 5443, 5449, 5453, 5458, 5462, 5470, 5474, 5478, |
153 | 5479, 5509, 5515, 5521, 5527, 5533, 5540, 5546, | 150 | 5508, 5514, 5520, 5526, 5532, 5539, 5545, 5552, |
154 | 5553, 5558, 5568, 5572, 5579, 5585, 5589, 5596, | 151 | 5557, 5567, 5571, 5578, 5584, 5588, 5595, 5599, |
155 | 5600, 5606, 5609, 5613, 5617, 5621, 5625, 5630, | 152 | 5605, 5608, 5612, 5616, 5620, 5624, 5629, 5634, |
156 | 5635, 5639, 5650, 5654, 5658, 5664, 5672, 5676, | 153 | 5638, 5649, 5653, 5657, 5663, 5671, 5675, 5692, |
157 | 5693, 5697, 5703, 5713, 5719, 5725, 5728, 5733, | 154 | 5696, 5702, 5712, 5718, 5724, 5727, 5732, 5741, |
158 | 5742, 5746, 5750, 5756, 5760, 5766, 5774, 5792, | 155 | 5745, 5749, 5755, 5759, 5765, 5773, 5791, 5792, |
159 | 5793, 5803, 5804, 5813, 5821, 5823, 5826, 5828, | 156 | 5802, 5803, 5812, 5820, 5822, 5825, 5827, 5829, |
160 | 5830, 5832, 5837, 5850, 5854, 5869, 5898, 5909, | 157 | 5831, 5836, 5849, 5853, 5868, 5897, 5908, 5910, |
161 | 5911, 5915, 5919, 5924, 5928, 5930, 5937, 5941, | 158 | 5914, 5918, 5923, 5927, 5929, 5936, 5940, 5948, |
162 | 5949, 5953, 5954, 5955, 5957, 5959, 5961, 5963, | 159 | 5952, 5964, 5966, 5968, 5970, 5972, 5974, 5975, |
163 | 5965, 5966, 5967, 5968, 5970, 5972, 5974, 5975, | 160 | 5977, 5979, 5981, 5983, 5985, 5986, 5988, 5990, |
164 | 5976, 5977, 5978, 5980, 5982, 5984, 5985, 5986, | 161 | 5992, 5994, 5996, 6000, 6006, 6006, 6008, 6010, |
165 | 5990, 5996, 5996, 5998, 6000, 6009, 6015, 6022, | 162 | 6019, 6025, 6032, 6033, 6036, 6037, 6041, 6046, |
166 | 6023, 6026, 6027, 6031, 6036, 6045, 6049, 6053, | 163 | 6055, 6059, 6063, 6071, 6073, 6075, 6077, 6080, |
167 | 6061, 6063, 6065, 6067, 6070, 6102, 6104, 6106, | 164 | 6112, 6114, 6116, 6120, 6124, 6127, 6138, 6151, |
168 | 6110, 6114, 6117, 6128, 6141, 6160, 6173, 6189, | 165 | 6170, 6183, 6199, 6211, 6227, 6242, 6263, 6273, |
169 | 6201, 6217, 6232, 6253, 6263, 6275, 6286, 6300, | 166 | 6285, 6296, 6310, 6325, 6335, 6347, 6356, 6368, |
170 | 6315, 6325, 6337, 6346, 6358, 6360, 6364, 6385, | 167 | 6370, 6374, 6395, 6404, 6414, 6420, 6426, 6427, |
171 | 6394, 6404, 6410, 6416, 6417, 6466, 6468, 6472, | 168 | 6476, 6478, 6482, 6484, 6490, 6497, 6505, 6512, |
172 | 6474, 6480, 6487, 6495, 6502, 6505, 6511, 6515, | 169 | 6515, 6521, 6525, 6529, 6531, 6535, 6539, 6543, |
173 | 6519, 6521, 6525, 6529, 6533, 6539, 6547, 6555, | 170 | 6549, 6557, 6565, 6571, 6573, 6577, 6579, 6585, |
174 | 6561, 6563, 6567, 6569, 6575, 6579, 6583, 6587, | 171 | 6589, 6593, 6597, 6601, 6606, 6613, 6619, 6621, |
175 | 6591, 6596, 6603, 6609, 6611, 6613, 6617, 6619, | 172 | 6623, 6627, 6629, 6635, 6639, 6643, 6653, 6658, |
176 | 6625, 6629, 6633, 6643, 6648, 6662, 6677, 6679, | 173 | 6672, 6687, 6689, 6697, 6699, 6704, 6718, 6723, |
177 | 6687, 6689, 6694, 6708, 6713, 6715, 6719, 6720, | 174 | 6725, 6729, 6730, 6734, 6740, 6746, 6756, 6766, |
178 | 6724, 6730, 6736, 6746, 6756, 6767, 6775, 6778, | 175 | 6777, 6785, 6788, 6791, 6795, 6799, 6801, 6804, |
179 | 6781, 6785, 6789, 6791, 6794, 6794, 6797, 6799, | 176 | 6804, 6807, 6809, 6839, 6841, 6843, 6847, 6852, |
180 | 6829, 6831, 6833, 6837, 6842, 6846, 6851, 6853, | 177 | 6856, 6861, 6863, 6865, 6867, 6876, 6880, 6884, |
181 | 6855, 6857, 6866, 6870, 6874, 6880, 6882, 6890, | 178 | 6890, 6892, 6900, 6908, 6920, 6923, 6929, 6933, |
182 | 6898, 6910, 6913, 6919, 6923, 6925, 6929, 6949, | 179 | 6935, 6939, 6959, 6961, 6963, 6974, 6980, 6982, |
183 | 6951, 6953, 6964, 6970, 6972, 6974, 6976, 6980, | 180 | 6984, 6986, 6990, 6996, 7002, 7004, 7009, 7013, |
184 | 6986, 6992, 6994, 6999, 7003, 7005, 7013, 7031, | 181 | 7015, 7023, 7041, 7081, 7091, 7095, 7097, 7099, |
185 | 7071, 7081, 7085, 7087, 7089, 7090, 7094, 7098, | 182 | 7100, 7104, 7108, 7112, 7116, 7120, 7125, 7129, |
186 | 7102, 7106, 7110, 7115, 7119, 7123, 7127, 7129, | 183 | 7133, 7137, 7139, 7141, 7145, 7155, 7159, 7161, |
187 | 7131, 7135, 7145, 7149, 7151, 7155, 7159, 7163, | 184 | 7165, 7169, 7173, 7186, 7188, 7190, 7194, 7196, |
188 | 7176, 7178, 7180, 7184, 7186, 7190, 7192, 7194, | 185 | 7200, 7202, 7204, 7234, 7238, 7242, 7246, 7249, |
189 | 7224, 7228, 7232, 7236, 7239, 7246, 7251, 7262, | 186 | 7256, 7261, 7272, 7276, 7292, 7306, 7310, 7315, |
190 | 7266, 7282, 7296, 7300, 7305, 7309, 7313, 7319, | 187 | 7319, 7323, 7329, 7331, 7337, 7339, 7343, 7345, |
191 | 7321, 7327, 7329, 7333, 7335, 7341, 7346, 7351, | 188 | 7351, 7356, 7361, 7371, 7373, 7375, 7379, 7383, |
192 | 7361, 7363, 7365, 7369, 7373, 7375, 7388, 7390, | 189 | 7385, 7398, 7400, 7404, 7408, 7416, 7418, 7422, |
193 | 7394, 7398, 7406, 7408, 7412, 7414, 7415, 7418, | 190 | 7424, 7425, 7428, 7433, 7435, 7437, 7441, 7443, |
194 | 7423, 7425, 7427, 7431, 7433, 7437, 7443, 7463, | 191 | 7447, 7453, 7473, 7479, 7485, 7487, 7488, 7498, |
195 | 7469, 7475, 7477, 7478, 7488, 7489, 7497, 7504, | 192 | 7499, 7507, 7514, 7516, 7519, 7521, 7523, 7525, |
196 | 7506, 7509, 7511, 7513, 7515, 7520, 7524, 7528, | 193 | 7530, 7534, 7538, 7543, 7553, 7563, 7567, 7571, |
197 | 7533, 7543, 7553, 7557, 7561, 7575, 7601, 7611, | 194 | 7585, 7611, 7621, 7623, 7625, 7628, 7630, 7633, |
198 | 7613, 7615, 7618, 7620, 7623, 7625, 7629, 7631, | 195 | 7635, 7639, 7641, 7642, 7646, 7648, 7650, 7657, |
199 | 7632, 7636, 7638, 7640, 7647, 7651, 7658, 7665, | 196 | 7661, 7668, 7675, 7684, 7700, 7712, 7730, 7741, |
200 | 7674, 7690, 7702, 7720, 7731, 7743, 7751, 7769, | 197 | 7753, 7761, 7779, 7787, 7817, 7820, 7830, 7840, |
201 | 7777, 7807, 7810, 7820, 7830, 7842, 7853, 7862, | 198 | 7852, 7863, 7872, 7885, 7897, 7901, 7907, 7934, |
202 | 7875, 7887, 7891, 7897, 7924, 7933, 7936, 7941, | 199 | 7943, 7946, 7951, 7957, 7962, 7983, 7987, 7993, |
203 | 7947, 7952, 7973, 7977, 7983, 7983, 7990, 7999, | 200 | 7993, 8000, 8009, 8017, 8020, 8024, 8030, 8036, |
204 | 8007, 8010, 8014, 8020, 8026, 8029, 8033, 8040, | 201 | 8039, 8043, 8050, 8056, 8065, 8074, 8078, 8082, |
205 | 8046, 8055, 8064, 8068, 8072, 8076, 8080, 8087, | 202 | 8086, 8090, 8097, 8101, 8105, 8115, 8121, 8125, |
206 | 8091, 8095, 8105, 8111, 8115, 8121, 8125, 8128, | 203 | 8131, 8135, 8138, 8144, 8150, 8162, 8166, 8170, |
207 | 8134, 8140, 8152, 8156, 8160, 8170, 8174, 8185, | 204 | 8180, 8184, 8195, 8197, 8199, 8203, 8215, 8220, |
208 | 8187, 8189, 8193, 8205, 8210, 8234, 8238, 8244, | 205 | 8244, 8248, 8254, 8276, 8285, 8289, 8292, 8293, |
209 | 8266, 8275, 8279, 8282, 8283, 8291, 8299, 8305, | 206 | 8301, 8309, 8315, 8325, 8332, 8350, 8353, 8356, |
210 | 8315, 8322, 8340, 8343, 8346, 8354, 8360, 8364, | 207 | 8364, 8370, 8374, 8378, 8382, 8388, 8396, 8401, |
211 | 8368, 8372, 8378, 8386, 8391, 8397, 8401, 8409, | 208 | 8407, 8411, 8419, 8426, 8430, 8437, 8443, 8451, |
212 | 8416, 8420, 8427, 8433, 8441, 8449, 8455, 8461, | 209 | 8459, 8465, 8471, 8482, 8486, 8498, 8507, 8524, |
213 | 8472, 8476, 8488, 8497, 8514, 8531, 8534, 8538, | 210 | 8541, 8544, 8548, 8550, 8556, 8558, 8562, 8577, |
214 | 8540, 8546, 8548, 8552, 8567, 8571, 8575, 8579, | 211 | 8581, 8585, 8589, 8593, 8597, 8599, 8605, 8610, |
215 | 8583, 8587, 8589, 8595, 8600, 8604, 8610, 8617, | 212 | 8614, 8620, 8627, 8630, 8648, 8650, 8695, 8701, |
216 | 8620, 8638, 8640, 8685, 8691, 8697, 8701, 8705, | 213 | 8707, 8711, 8715, 8721, 8725, 8731, 8737, 8744, |
217 | 8711, 8715, 8721, 8727, 8734, 8736, 8742, 8748, | 214 | 8746, 8752, 8758, 8762, 8766, 8774, 8787, 8793, |
218 | 8752, 8756, 8764, 8777, 8783, 8790, 8798, 8804, | 215 | 8800, 8808, 8814, 8823, 8829, 8833, 8838, 8842, |
219 | 8813, 8819, 8823, 8828, 8832, 8840, 8844, 8848, | 216 | 8850, 8854, 8858, 8888, 8894, 8900, 8906, 8912, |
220 | 8878, 8884, 8890, 8896, 8902, 8909, 8915, 8922, | 217 | 8919, 8925, 8932, 8937, 8947, 8951, 8958, 8964, |
221 | 8927, 8937, 8941, 8948, 8954, 8958, 8965, 8969, | 218 | 8968, 8975, 8979, 8985, 8988, 8992, 8996, 9000, |
222 | 8975, 8978, 8982, 8986, 8990, 8994, 8999, 9004, | 219 | 9004, 9009, 9014, 9018, 9029, 9033, 9037, 9043, |
223 | 9008, 9019, 9023, 9027, 9033, 9041, 9045, 9062, | 220 | 9051, 9055, 9072, 9076, 9082, 9092, 9098, 9104, |
224 | 9066, 9072, 9082, 9088, 9094, 9097, 9102, 9111, | 221 | 9107, 9112, 9121, 9125, 9129, 9135, 9139, 9145, |
225 | 9115, 9119, 9125, 9129, 9135, 9143, 9161, 9162, | 222 | 9153, 9171, 9172, 9182, 9183, 9192, 9200, 9202, |
226 | 9172, 9173, 9182, 9190, 9192, 9195, 9197, 9199, | 223 | 9205, 9207, 9209, 9211, 9216, 9229, 9233, 9248, |
227 | 9201, 9206, 9219, 9223, 9238, 9267, 9278, 9280, | 224 | 9277, 9288, 9290, 9294, 9298, 9303, 9307, 9309, |
228 | 9284, 9288, 9293, 9297, 9299, 9306, 9310, 9318, | 225 | 9316, 9320, 9328, 9332, 9407, 9409, 9410, 9411, |
229 | 9322, 9398, 9400, 9401, 9402, 9403, 9404, 9405, | 226 | 9412, 9413, 9414, 9416, 9421, 9423, 9425, 9426, |
230 | 9407, 9408, 9413, 9415, 9417, 9418, 9462, 9463, | 227 | 9470, 9471, 9472, 9474, 9479, 9483, 9483, 9485, |
231 | 9464, 9466, 9471, 9475, 9475, 9477, 9479, 9490, | 228 | 9487, 9498, 9508, 9516, 9517, 9519, 9520, 9524, |
232 | 9500, 9508, 9509, 9511, 9512, 9516, 9520, 9530, | 229 | 9528, 9538, 9542, 9549, 9560, 9567, 9571, 9577, |
233 | 9534, 9541, 9552, 9559, 9563, 9569, 9580, 9612, | 230 | 9588, 9620, 9669, 9684, 9699, 9704, 9706, 9711, |
234 | 9661, 9676, 9691, 9696, 9698, 9703, 9735, 9743, | 231 | 9743, 9751, 9753, 9775, 9797, 9799, 9815, 9831, |
235 | 9745, 9767, 9789, 9791, 9807, 9823, 9839, 9855, | 232 | 9833, 9835, 9835, 9836, 9837, 9838, 9840, 9841, |
236 | 9870, 9880, 9897, 9914, 9931, 9947, 9957, 9974, | 233 | 9853, 9855, 9857, 9859, 9873, 9887, 9889, 9892, |
237 | 9990, 10006, 10022, 10038, 10054, 10070, 10086, 10087, | 234 | 9895, 9897, 9898, 9899, 9901, 9903, 9905, 9919, |
238 | 10088, 10089, 10090, 10092, 10094, 10096, 10110, 10124, | 235 | 9933, 9935, 9938, 9941, 9943, 9944, 9945, 9947, |
239 | 10138, 10152, 10153, 10154, 10156, 10158, 10160, 10174, | 236 | 9949, 9951, 10000, 10044, 10046, 10051, 10055, 10055, |
240 | 10188, 10189, 10190, 10192, 10194, 10196, 10245, 10289, | 237 | 10057, 10059, 10070, 10080, 10088, 10089, 10091, 10092, |
241 | 10291, 10296, 10300, 10300, 10302, 10304, 10315, 10325, | 238 | 10096, 10100, 10110, 10114, 10121, 10132, 10139, 10143, |
242 | 10333, 10334, 10336, 10337, 10341, 10345, 10355, 10359, | 239 | 10149, 10160, 10192, 10241, 10256, 10271, 10276, 10278, |
243 | 10366, 10377, 10384, 10388, 10394, 10405, 10437, 10486, | 240 | 10283, 10315, 10323, 10325, 10347, 10369, |
244 | 10501, 10516, 10521, 10523, 10528, 10560, 10568, 10570, | ||
245 | 10592, 10614, | ||
246 | } | 241 | } |
247 | 242 | ||
248 | var _hcltok_trans_keys []byte = []byte{ | 243 | var _hcltok_trans_keys []byte = []byte{ |
249 | 10, 46, 42, 42, 47, 46, 69, 101, | 244 | 46, 42, 42, 47, 46, 69, 101, 48, |
250 | 48, 57, 43, 45, 48, 57, 48, 57, | 245 | 57, 43, 45, 48, 57, 48, 57, 45, |
251 | 45, 95, 194, 195, 198, 199, 203, 205, | 246 | 95, 194, 195, 198, 199, 203, 205, 206, |
247 | 207, 210, 212, 213, 214, 215, 216, 217, | ||
248 | 219, 220, 221, 222, 223, 224, 225, 226, | ||
249 | 227, 228, 233, 234, 237, 239, 240, 65, | ||
250 | 90, 97, 122, 196, 202, 208, 218, 229, | ||
251 | 236, 95, 194, 195, 198, 199, 203, 205, | ||
252 | 206, 207, 210, 212, 213, 214, 215, 216, | 252 | 206, 207, 210, 212, 213, 214, 215, 216, |
253 | 217, 219, 220, 221, 222, 223, 224, 225, | 253 | 217, 219, 220, 221, 222, 223, 224, 225, |
254 | 226, 227, 228, 233, 234, 237, 239, 240, | 254 | 226, 227, 228, 233, 234, 237, 239, 240, |
255 | 65, 90, 97, 122, 196, 202, 208, 218, | 255 | 65, 90, 97, 122, 196, 202, 208, 218, |
256 | 229, 236, 95, 194, 195, 198, 199, 203, | 256 | 229, 236, 10, 13, 45, 95, 194, 195, |
257 | 205, 206, 207, 210, 212, 213, 214, 215, | 257 | 198, 199, 203, 204, 205, 206, 207, 210, |
258 | 216, 217, 219, 220, 221, 222, 223, 224, | 258 | 212, 213, 214, 215, 216, 217, 219, 220, |
259 | 225, 226, 227, 228, 233, 234, 237, 239, | 259 | 221, 222, 223, 224, 225, 226, 227, 228, |
260 | 240, 65, 90, 97, 122, 196, 202, 208, | 260 | 233, 234, 237, 239, 240, 243, 48, 57, |
261 | 218, 229, 236, 10, 13, 45, 95, 194, | 261 | 65, 90, 97, 122, 196, 218, 229, 236, |
262 | 195, 198, 199, 203, 204, 205, 206, 207, | 262 | 10, 170, 181, 183, 186, 128, 150, 152, |
263 | 210, 212, 213, 214, 215, 216, 217, 219, | ||
264 | 220, 221, 222, 223, 224, 225, 226, 227, | ||
265 | 228, 233, 234, 237, 239, 240, 243, 48, | ||
266 | 57, 65, 90, 97, 122, 196, 218, 229, | ||
267 | 236, 10, 170, 181, 183, 186, 128, 150, | ||
268 | 152, 182, 184, 255, 192, 255, 0, 127, | ||
269 | 173, 130, 133, 146, 159, 165, 171, 175, | ||
270 | 255, 181, 190, 184, 185, 192, 255, 140, | ||
271 | 134, 138, 142, 161, 163, 255, 182, 130, | ||
272 | 136, 137, 176, 151, 152, 154, 160, 190, | ||
273 | 136, 144, 192, 255, 135, 129, 130, 132, | ||
274 | 133, 144, 170, 176, 178, 144, 154, 160, | ||
275 | 191, 128, 169, 174, 255, 148, 169, 157, | ||
276 | 158, 189, 190, 192, 255, 144, 255, 139, | ||
277 | 140, 178, 255, 186, 128, 181, 160, 161, | ||
278 | 162, 163, 164, 165, 166, 167, 168, 169, | ||
279 | 170, 171, 172, 173, 174, 175, 176, 177, | ||
280 | 178, 179, 180, 181, 182, 183, 184, 185, | ||
281 | 186, 187, 188, 189, 190, 191, 128, 173, | ||
282 | 128, 155, 160, 180, 182, 189, 148, 161, | ||
283 | 163, 255, 176, 164, 165, 132, 169, 177, | ||
284 | 141, 142, 145, 146, 179, 181, 186, 187, | ||
285 | 158, 133, 134, 137, 138, 143, 150, 152, | ||
286 | 155, 164, 165, 178, 255, 188, 129, 131, | ||
287 | 133, 138, 143, 144, 147, 168, 170, 176, | ||
288 | 178, 179, 181, 182, 184, 185, 190, 255, | ||
289 | 157, 131, 134, 137, 138, 142, 144, 146, | ||
290 | 152, 159, 165, 182, 255, 129, 131, 133, | ||
291 | 141, 143, 145, 147, 168, 170, 176, 178, | ||
292 | 179, 181, 185, 188, 255, 134, 138, 142, | ||
293 | 143, 145, 159, 164, 165, 176, 184, 186, | ||
294 | 255, 129, 131, 133, 140, 143, 144, 147, | ||
295 | 168, 170, 176, 178, 179, 181, 185, 188, | ||
296 | 191, 177, 128, 132, 135, 136, 139, 141, | ||
297 | 150, 151, 156, 157, 159, 163, 166, 175, | ||
298 | 156, 130, 131, 133, 138, 142, 144, 146, | ||
299 | 149, 153, 154, 158, 159, 163, 164, 168, | ||
300 | 170, 174, 185, 190, 191, 144, 151, 128, | ||
301 | 130, 134, 136, 138, 141, 166, 175, 128, | ||
302 | 131, 133, 140, 142, 144, 146, 168, 170, | ||
303 | 185, 189, 255, 133, 137, 151, 142, 148, | ||
304 | 155, 159, 164, 165, 176, 255, 128, 131, | ||
305 | 133, 140, 142, 144, 146, 168, 170, 179, | ||
306 | 181, 185, 188, 191, 158, 128, 132, 134, | ||
307 | 136, 138, 141, 149, 150, 160, 163, 166, | ||
308 | 175, 177, 178, 129, 131, 133, 140, 142, | ||
309 | 144, 146, 186, 189, 255, 133, 137, 143, | ||
310 | 147, 152, 158, 164, 165, 176, 185, 192, | ||
311 | 255, 189, 130, 131, 133, 150, 154, 177, | ||
312 | 179, 187, 138, 150, 128, 134, 143, 148, | ||
313 | 152, 159, 166, 175, 178, 179, 129, 186, | ||
314 | 128, 142, 144, 153, 132, 138, 141, 165, | ||
315 | 167, 129, 130, 135, 136, 148, 151, 153, | ||
316 | 159, 161, 163, 170, 171, 173, 185, 187, | ||
317 | 189, 134, 128, 132, 136, 141, 144, 153, | ||
318 | 156, 159, 128, 181, 183, 185, 152, 153, | ||
319 | 160, 169, 190, 191, 128, 135, 137, 172, | ||
320 | 177, 191, 128, 132, 134, 151, 153, 188, | ||
321 | 134, 128, 129, 130, 131, 137, 138, 139, | ||
322 | 140, 141, 142, 143, 144, 153, 154, 155, | ||
323 | 156, 157, 158, 159, 160, 161, 162, 163, | ||
324 | 164, 165, 166, 167, 168, 169, 170, 173, | ||
325 | 175, 176, 177, 178, 179, 181, 182, 183, | ||
326 | 188, 189, 190, 191, 132, 152, 172, 184, | ||
327 | 185, 187, 128, 191, 128, 137, 144, 255, | ||
328 | 158, 159, 134, 187, 136, 140, 142, 143, | ||
329 | 137, 151, 153, 142, 143, 158, 159, 137, | ||
330 | 177, 142, 143, 182, 183, 191, 255, 128, | ||
331 | 130, 133, 136, 150, 152, 255, 145, 150, | ||
332 | 151, 155, 156, 160, 168, 178, 255, 128, | ||
333 | 143, 160, 255, 182, 183, 190, 255, 129, | ||
334 | 255, 173, 174, 192, 255, 129, 154, 160, | ||
335 | 255, 171, 173, 185, 255, 128, 140, 142, | ||
336 | 148, 160, 180, 128, 147, 160, 172, 174, | ||
337 | 176, 178, 179, 148, 150, 152, 155, 158, | ||
338 | 159, 170, 255, 139, 141, 144, 153, 160, | ||
339 | 255, 184, 255, 128, 170, 176, 255, 182, | ||
340 | 255, 128, 158, 160, 171, 176, 187, 134, | ||
341 | 173, 176, 180, 128, 171, 176, 255, 138, | ||
342 | 143, 155, 255, 128, 155, 160, 255, 159, | ||
343 | 189, 190, 192, 255, 167, 128, 137, 144, | ||
344 | 153, 176, 189, 140, 143, 154, 170, 180, | ||
345 | 255, 180, 255, 128, 183, 128, 137, 141, | ||
346 | 189, 128, 136, 144, 146, 148, 182, 184, | ||
347 | 185, 128, 181, 187, 191, 150, 151, 158, | ||
348 | 159, 152, 154, 156, 158, 134, 135, 142, | ||
349 | 143, 190, 255, 190, 128, 180, 182, 188, | ||
350 | 130, 132, 134, 140, 144, 147, 150, 155, | ||
351 | 160, 172, 178, 180, 182, 188, 128, 129, | ||
352 | 130, 131, 132, 133, 134, 176, 177, 178, | ||
353 | 179, 180, 181, 182, 183, 191, 255, 129, | ||
354 | 147, 149, 176, 178, 190, 192, 255, 144, | ||
355 | 156, 161, 144, 156, 165, 176, 130, 135, | ||
356 | 149, 164, 166, 168, 138, 147, 152, 157, | ||
357 | 170, 185, 188, 191, 142, 133, 137, 160, | ||
358 | 255, 137, 255, 128, 174, 176, 255, 159, | ||
359 | 165, 170, 180, 255, 167, 173, 128, 165, | ||
360 | 176, 255, 168, 174, 176, 190, 192, 255, | ||
361 | 128, 150, 160, 166, 168, 174, 176, 182, | ||
362 | 184, 190, 128, 134, 136, 142, 144, 150, | ||
363 | 152, 158, 160, 191, 128, 129, 130, 131, | ||
364 | 132, 133, 134, 135, 144, 145, 255, 133, | ||
365 | 135, 161, 175, 177, 181, 184, 188, 160, | ||
366 | 151, 152, 187, 192, 255, 133, 173, 177, | ||
367 | 255, 143, 159, 187, 255, 176, 191, 182, | ||
368 | 183, 184, 191, 192, 255, 150, 255, 128, | ||
369 | 146, 147, 148, 152, 153, 154, 155, 156, | ||
370 | 158, 159, 160, 161, 162, 163, 164, 165, | ||
371 | 166, 167, 168, 169, 170, 171, 172, 173, | ||
372 | 174, 175, 176, 129, 255, 141, 255, 144, | ||
373 | 189, 141, 143, 172, 255, 191, 128, 175, | ||
374 | 180, 189, 151, 159, 162, 255, 175, 137, | ||
375 | 138, 184, 255, 183, 255, 168, 255, 128, | ||
376 | 179, 188, 134, 143, 154, 159, 184, 186, | ||
377 | 190, 255, 128, 173, 176, 255, 148, 159, | ||
378 | 189, 255, 129, 142, 154, 159, 191, 255, | ||
379 | 128, 182, 128, 141, 144, 153, 160, 182, | ||
380 | 186, 255, 128, 130, 155, 157, 160, 175, | ||
381 | 178, 182, 129, 134, 137, 142, 145, 150, | ||
382 | 160, 166, 168, 174, 176, 255, 155, 166, | ||
383 | 175, 128, 170, 172, 173, 176, 185, 158, | ||
384 | 159, 160, 255, 164, 175, 135, 138, 188, | ||
385 | 255, 164, 169, 171, 172, 173, 174, 175, | ||
386 | 180, 181, 182, 183, 184, 185, 187, 188, | ||
387 | 189, 190, 191, 165, 186, 174, 175, 154, | ||
388 | 255, 190, 128, 134, 147, 151, 157, 168, | ||
389 | 170, 182, 184, 188, 128, 129, 131, 132, | ||
390 | 134, 255, 147, 255, 190, 255, 144, 145, | ||
391 | 136, 175, 188, 255, 128, 143, 160, 175, | ||
392 | 179, 180, 141, 143, 176, 180, 182, 255, | ||
393 | 189, 255, 191, 144, 153, 161, 186, 129, | ||
394 | 154, 166, 255, 191, 255, 130, 135, 138, | ||
395 | 143, 146, 151, 154, 156, 144, 145, 146, | ||
396 | 147, 148, 150, 151, 152, 155, 157, 158, | ||
397 | 160, 170, 171, 172, 175, 161, 169, 128, | ||
398 | 129, 130, 131, 133, 135, 138, 139, 140, | ||
399 | 141, 142, 143, 144, 145, 146, 147, 148, | ||
400 | 149, 152, 156, 157, 160, 161, 162, 163, | ||
401 | 164, 166, 168, 169, 170, 171, 172, 173, | ||
402 | 174, 176, 177, 153, 155, 178, 179, 128, | ||
403 | 139, 141, 166, 168, 186, 188, 189, 191, | ||
404 | 255, 142, 143, 158, 255, 187, 255, 128, | ||
405 | 180, 189, 128, 156, 160, 255, 145, 159, | ||
406 | 161, 255, 128, 159, 176, 255, 139, 143, | ||
407 | 187, 255, 128, 157, 160, 255, 144, 132, | ||
408 | 135, 150, 255, 158, 159, 170, 175, 148, | ||
409 | 151, 188, 255, 128, 167, 176, 255, 164, | ||
410 | 255, 183, 255, 128, 149, 160, 167, 136, | ||
411 | 188, 128, 133, 138, 181, 183, 184, 191, | ||
412 | 255, 150, 159, 183, 255, 128, 158, 160, | ||
413 | 178, 180, 181, 128, 149, 160, 185, 128, | ||
414 | 183, 190, 191, 191, 128, 131, 133, 134, | ||
415 | 140, 147, 149, 151, 153, 179, 184, 186, | ||
416 | 160, 188, 128, 156, 128, 135, 137, 166, | ||
417 | 128, 181, 128, 149, 160, 178, 128, 145, | ||
418 | 128, 178, 129, 130, 131, 132, 133, 135, | ||
419 | 136, 138, 139, 140, 141, 144, 145, 146, | ||
420 | 147, 150, 151, 152, 153, 154, 155, 156, | ||
421 | 162, 163, 171, 176, 177, 178, 128, 134, | ||
422 | 135, 165, 176, 190, 144, 168, 176, 185, | ||
423 | 128, 180, 182, 191, 182, 144, 179, 155, | ||
424 | 133, 137, 141, 143, 157, 255, 190, 128, | ||
425 | 145, 147, 183, 136, 128, 134, 138, 141, | ||
426 | 143, 157, 159, 168, 176, 255, 171, 175, | ||
427 | 186, 255, 128, 131, 133, 140, 143, 144, | ||
428 | 147, 168, 170, 176, 178, 179, 181, 185, | ||
429 | 188, 191, 144, 151, 128, 132, 135, 136, | ||
430 | 139, 141, 157, 163, 166, 172, 176, 180, | ||
431 | 128, 138, 144, 153, 134, 136, 143, 154, | ||
432 | 255, 128, 181, 184, 255, 129, 151, 158, | ||
433 | 255, 129, 131, 133, 143, 154, 255, 128, | ||
434 | 137, 128, 153, 157, 171, 176, 185, 160, | ||
435 | 255, 170, 190, 192, 255, 128, 184, 128, | ||
436 | 136, 138, 182, 184, 191, 128, 144, 153, | ||
437 | 178, 255, 168, 144, 145, 183, 255, 128, | ||
438 | 142, 145, 149, 129, 141, 144, 146, 147, | ||
439 | 148, 175, 255, 132, 255, 128, 144, 129, | ||
440 | 143, 144, 153, 145, 152, 135, 255, 160, | ||
441 | 168, 169, 171, 172, 173, 174, 188, 189, | ||
442 | 190, 191, 161, 167, 185, 255, 128, 158, | ||
443 | 160, 169, 144, 173, 176, 180, 128, 131, | ||
444 | 144, 153, 163, 183, 189, 255, 144, 255, | ||
445 | 133, 143, 191, 255, 143, 159, 160, 128, | ||
446 | 129, 255, 159, 160, 171, 172, 255, 173, | ||
447 | 255, 179, 255, 128, 176, 177, 178, 128, | ||
448 | 129, 171, 175, 189, 255, 128, 136, 144, | ||
449 | 153, 157, 158, 133, 134, 137, 144, 145, | ||
450 | 146, 147, 148, 149, 154, 155, 156, 157, | ||
451 | 158, 159, 168, 169, 170, 150, 153, 165, | ||
452 | 169, 173, 178, 187, 255, 131, 132, 140, | ||
453 | 169, 174, 255, 130, 132, 149, 157, 173, | ||
454 | 186, 188, 160, 161, 163, 164, 167, 168, | ||
455 | 132, 134, 149, 157, 186, 139, 140, 191, | ||
456 | 255, 134, 128, 132, 138, 144, 146, 255, | ||
457 | 166, 167, 129, 155, 187, 149, 181, 143, | ||
458 | 175, 137, 169, 131, 140, 141, 192, 255, | ||
459 | 128, 182, 187, 255, 173, 180, 182, 255, | ||
460 | 132, 155, 159, 161, 175, 128, 160, 163, | ||
461 | 164, 165, 184, 185, 186, 161, 162, 128, | ||
462 | 134, 136, 152, 155, 161, 163, 164, 166, | ||
463 | 170, 133, 143, 151, 255, 139, 143, 154, | ||
464 | 255, 164, 167, 185, 187, 128, 131, 133, | ||
465 | 159, 161, 162, 169, 178, 180, 183, 130, | ||
466 | 135, 137, 139, 148, 151, 153, 155, 157, | ||
467 | 159, 164, 190, 141, 143, 145, 146, 161, | ||
468 | 162, 167, 170, 172, 178, 180, 183, 185, | ||
469 | 188, 128, 137, 139, 155, 161, 163, 165, | ||
470 | 169, 171, 187, 155, 156, 151, 255, 156, | ||
471 | 157, 160, 181, 255, 186, 187, 255, 162, | ||
472 | 255, 160, 168, 161, 167, 158, 255, 160, | ||
473 | 132, 135, 133, 134, 176, 255, 170, 181, | ||
474 | 186, 191, 176, 180, 182, 183, 186, 189, | ||
475 | 134, 140, 136, 138, 142, 161, 163, 255, | ||
476 | 130, 137, 136, 255, 144, 170, 176, 178, | ||
477 | 160, 191, 128, 138, 174, 175, 177, 255, | ||
478 | 148, 150, 164, 167, 173, 176, 185, 189, | ||
479 | 190, 192, 255, 144, 146, 175, 141, 255, | ||
480 | 166, 176, 178, 255, 186, 138, 170, 180, | ||
481 | 181, 160, 161, 162, 164, 165, 166, 167, | ||
482 | 168, 169, 170, 171, 172, 173, 174, 175, | ||
483 | 176, 177, 178, 179, 180, 181, 182, 184, | ||
484 | 186, 187, 188, 189, 190, 183, 185, 154, | ||
485 | 164, 168, 128, 149, 128, 152, 189, 132, | ||
486 | 185, 144, 152, 161, 177, 255, 169, 177, | ||
487 | 129, 132, 141, 142, 145, 146, 179, 181, | ||
488 | 186, 188, 190, 255, 142, 156, 157, 159, | ||
489 | 161, 176, 177, 133, 138, 143, 144, 147, | ||
490 | 168, 170, 176, 178, 179, 181, 182, 184, | ||
491 | 185, 158, 153, 156, 178, 180, 189, 133, | ||
492 | 141, 143, 145, 147, 168, 170, 176, 178, | ||
493 | 179, 181, 185, 144, 185, 160, 161, 189, | ||
494 | 133, 140, 143, 144, 147, 168, 170, 176, | ||
495 | 178, 179, 181, 185, 177, 156, 157, 159, | ||
496 | 161, 131, 156, 133, 138, 142, 144, 146, | ||
497 | 149, 153, 154, 158, 159, 163, 164, 168, | ||
498 | 170, 174, 185, 144, 189, 133, 140, 142, | ||
499 | 144, 146, 168, 170, 185, 152, 154, 160, | ||
500 | 161, 128, 189, 133, 140, 142, 144, 146, | ||
501 | 168, 170, 179, 181, 185, 158, 160, 161, | ||
502 | 177, 178, 189, 133, 140, 142, 144, 146, | ||
503 | 186, 142, 148, 150, 159, 161, 186, 191, | ||
504 | 189, 133, 150, 154, 177, 179, 187, 128, | ||
505 | 134, 129, 176, 178, 179, 132, 138, 141, | ||
506 | 165, 167, 189, 129, 130, 135, 136, 148, | ||
507 | 151, 153, 159, 161, 163, 170, 171, 173, | ||
508 | 176, 178, 179, 134, 128, 132, 156, 159, | ||
509 | 128, 128, 135, 137, 172, 136, 140, 128, | ||
510 | 129, 130, 131, 137, 138, 139, 140, 141, | ||
511 | 142, 143, 144, 153, 154, 155, 156, 157, | ||
512 | 158, 159, 160, 161, 162, 163, 164, 165, | ||
513 | 166, 167, 168, 169, 170, 172, 173, 174, | ||
514 | 175, 176, 177, 178, 179, 180, 181, 182, | ||
515 | 184, 188, 189, 190, 191, 132, 152, 185, | ||
516 | 187, 191, 128, 170, 161, 144, 149, 154, | ||
517 | 157, 165, 166, 174, 176, 181, 255, 130, | ||
518 | 141, 143, 159, 155, 255, 128, 140, 142, | ||
519 | 145, 160, 177, 128, 145, 160, 172, 174, | ||
520 | 176, 151, 156, 170, 128, 168, 176, 255, | ||
521 | 138, 255, 128, 150, 160, 255, 149, 255, | ||
522 | 167, 133, 179, 133, 139, 131, 160, 174, | ||
523 | 175, 186, 255, 166, 255, 128, 163, 141, | ||
524 | 143, 154, 189, 169, 172, 174, 177, 181, | ||
525 | 182, 129, 130, 132, 133, 134, 176, 177, | ||
526 | 178, 179, 180, 181, 182, 183, 177, 191, | ||
527 | 165, 170, 175, 177, 180, 255, 168, 174, | ||
528 | 176, 255, 128, 134, 136, 142, 144, 150, | ||
529 | 152, 158, 128, 129, 130, 131, 132, 133, | ||
530 | 134, 135, 144, 145, 255, 133, 135, 161, | ||
531 | 169, 177, 181, 184, 188, 160, 151, 154, | ||
532 | 128, 146, 147, 148, 152, 153, 154, 155, | ||
533 | 156, 158, 159, 160, 161, 162, 163, 164, | ||
534 | 165, 166, 167, 168, 169, 170, 171, 172, | ||
535 | 173, 174, 175, 176, 129, 255, 141, 143, | ||
536 | 160, 169, 172, 255, 191, 128, 174, 130, | ||
537 | 134, 139, 163, 255, 130, 179, 187, 189, | ||
538 | 178, 183, 138, 165, 176, 255, 135, 159, | ||
539 | 189, 255, 132, 178, 143, 160, 164, 166, | ||
540 | 175, 186, 190, 128, 168, 186, 128, 130, | ||
541 | 132, 139, 160, 182, 190, 255, 176, 178, | ||
542 | 180, 183, 184, 190, 255, 128, 130, 155, | ||
543 | 157, 160, 170, 178, 180, 128, 162, 164, | ||
544 | 169, 171, 172, 173, 174, 175, 180, 181, | ||
545 | 182, 183, 185, 186, 187, 188, 189, 190, | ||
546 | 191, 165, 179, 157, 190, 128, 134, 147, | ||
547 | 151, 159, 168, 170, 182, 184, 188, 176, | ||
548 | 180, 182, 255, 161, 186, 144, 145, 146, | ||
549 | 147, 148, 150, 151, 152, 155, 157, 158, | ||
550 | 160, 170, 171, 172, 175, 161, 169, 128, | ||
551 | 129, 130, 131, 133, 138, 139, 140, 141, | ||
552 | 142, 143, 144, 145, 146, 147, 148, 149, | ||
553 | 152, 156, 157, 160, 161, 162, 163, 164, | ||
554 | 166, 168, 169, 170, 171, 172, 173, 174, | ||
555 | 176, 177, 153, 155, 178, 179, 145, 255, | ||
556 | 139, 143, 182, 255, 158, 175, 128, 144, | ||
557 | 147, 149, 151, 153, 179, 128, 135, 137, | ||
558 | 164, 128, 130, 131, 132, 133, 134, 135, | ||
559 | 136, 138, 139, 140, 141, 144, 145, 146, | ||
560 | 147, 150, 151, 152, 153, 154, 156, 162, | ||
561 | 163, 171, 176, 177, 178, 131, 183, 131, | ||
562 | 175, 144, 168, 131, 166, 182, 144, 178, | ||
563 | 131, 178, 154, 156, 129, 132, 128, 145, | ||
564 | 147, 171, 159, 255, 144, 157, 161, 135, | ||
565 | 138, 128, 175, 135, 132, 133, 128, 174, | ||
566 | 152, 155, 132, 128, 170, 128, 153, 160, | ||
567 | 190, 192, 255, 128, 136, 138, 174, 128, | ||
568 | 178, 255, 160, 168, 169, 171, 172, 173, | ||
569 | 174, 188, 189, 190, 191, 161, 167, 144, | ||
570 | 173, 128, 131, 163, 183, 189, 255, 133, | ||
571 | 143, 145, 255, 147, 159, 128, 176, 177, | ||
572 | 178, 128, 136, 144, 153, 144, 145, 146, | ||
573 | 147, 148, 149, 154, 155, 156, 157, 158, | ||
574 | 159, 150, 153, 131, 140, 255, 160, 163, | ||
575 | 164, 165, 184, 185, 186, 161, 162, 133, | ||
576 | 255, 170, 181, 183, 186, 128, 150, 152, | ||
577 | 182, 184, 255, 192, 255, 128, 255, 173, | 263 | 182, 184, 255, 192, 255, 128, 255, 173, |
578 | 130, 133, 146, 159, 165, 171, 175, 255, | 264 | 130, 133, 146, 159, 165, 171, 175, 255, |
579 | 181, 190, 184, 185, 192, 255, 140, 134, | 265 | 181, 190, 184, 185, 192, 255, 140, 134, |
@@ -779,649 +465,959 @@ var _hcltok_trans_keys []byte = []byte{ | |||
779 | 171, 187, 155, 156, 151, 255, 156, 157, | 465 | 171, 187, 155, 156, 151, 255, 156, 157, |
780 | 160, 181, 255, 186, 187, 255, 162, 255, | 466 | 160, 181, 255, 186, 187, 255, 162, 255, |
781 | 160, 168, 161, 167, 158, 255, 160, 132, | 467 | 160, 168, 161, 167, 158, 255, 160, 132, |
782 | 135, 133, 134, 176, 255, 128, 191, 154, | 468 | 135, 133, 134, 176, 255, 170, 181, 186, |
783 | 164, 168, 128, 149, 150, 191, 128, 152, | 469 | 191, 176, 180, 182, 183, 186, 189, 134, |
784 | 153, 191, 181, 128, 159, 160, 189, 190, | 470 | 140, 136, 138, 142, 161, 163, 255, 130, |
785 | 191, 189, 128, 131, 132, 185, 186, 191, | 471 | 137, 136, 255, 144, 170, 176, 178, 160, |
786 | 144, 128, 151, 152, 161, 162, 176, 177, | 472 | 191, 128, 138, 174, 175, 177, 255, 148, |
787 | 255, 169, 177, 129, 132, 141, 142, 145, | 473 | 150, 164, 167, 173, 176, 185, 189, 190, |
788 | 146, 179, 181, 186, 188, 190, 191, 192, | 474 | 192, 255, 144, 146, 175, 141, 255, 166, |
789 | 255, 142, 158, 128, 155, 156, 161, 162, | 475 | 176, 178, 255, 186, 138, 170, 180, 181, |
790 | 175, 176, 177, 178, 191, 169, 177, 180, | 476 | 160, 161, 162, 164, 165, 166, 167, 168, |
791 | 183, 128, 132, 133, 138, 139, 142, 143, | 477 | 169, 170, 171, 172, 173, 174, 175, 176, |
792 | 144, 145, 146, 147, 185, 186, 191, 157, | 478 | 177, 178, 179, 180, 181, 182, 184, 186, |
793 | 128, 152, 153, 158, 159, 177, 178, 180, | 479 | 187, 188, 189, 190, 183, 185, 154, 164, |
794 | 181, 191, 142, 146, 169, 177, 180, 189, | 480 | 168, 128, 149, 128, 152, 189, 132, 185, |
795 | 128, 132, 133, 185, 186, 191, 144, 185, | 481 | 144, 152, 161, 177, 255, 169, 177, 129, |
796 | 128, 159, 160, 161, 162, 191, 169, 177, | 482 | 132, 141, 142, 145, 146, 179, 181, 186, |
797 | 180, 189, 128, 132, 133, 140, 141, 142, | 483 | 188, 190, 255, 142, 156, 157, 159, 161, |
798 | 143, 144, 145, 146, 147, 185, 186, 191, | 484 | 176, 177, 133, 138, 143, 144, 147, 168, |
799 | 158, 177, 128, 155, 156, 161, 162, 191, | 485 | 170, 176, 178, 179, 181, 182, 184, 185, |
800 | 131, 145, 155, 157, 128, 132, 133, 138, | 486 | 158, 153, 156, 178, 180, 189, 133, 141, |
801 | 139, 141, 142, 149, 150, 152, 153, 159, | 487 | 143, 145, 147, 168, 170, 176, 178, 179, |
802 | 160, 162, 163, 164, 165, 167, 168, 170, | 488 | 181, 185, 144, 185, 160, 161, 189, 133, |
803 | 171, 173, 174, 185, 186, 191, 144, 128, | 489 | 140, 143, 144, 147, 168, 170, 176, 178, |
804 | 191, 141, 145, 169, 189, 128, 132, 133, | 490 | 179, 181, 185, 177, 156, 157, 159, 161, |
805 | 185, 186, 191, 128, 151, 152, 154, 155, | 491 | 131, 156, 133, 138, 142, 144, 146, 149, |
806 | 159, 160, 161, 162, 191, 128, 141, 145, | 492 | 153, 154, 158, 159, 163, 164, 168, 170, |
807 | 169, 180, 189, 129, 132, 133, 185, 186, | 493 | 174, 185, 144, 189, 133, 140, 142, 144, |
808 | 191, 158, 128, 159, 160, 161, 162, 176, | 494 | 146, 168, 170, 185, 152, 154, 160, 161, |
809 | 177, 178, 179, 191, 141, 145, 189, 128, | 495 | 128, 189, 133, 140, 142, 144, 146, 168, |
810 | 132, 133, 186, 187, 191, 142, 128, 147, | 496 | 170, 179, 181, 185, 158, 160, 161, 177, |
811 | 148, 150, 151, 158, 159, 161, 162, 185, | 497 | 178, 189, 133, 140, 142, 144, 146, 186, |
812 | 186, 191, 178, 188, 128, 132, 133, 150, | 498 | 142, 148, 150, 159, 161, 186, 191, 189, |
813 | 151, 153, 154, 189, 190, 191, 128, 134, | 499 | 133, 150, 154, 177, 179, 187, 128, 134, |
814 | 135, 191, 128, 177, 129, 179, 180, 191, | 500 | 129, 176, 178, 179, 132, 138, 141, 165, |
815 | 128, 131, 137, 141, 152, 160, 164, 166, | 501 | 167, 189, 129, 130, 135, 136, 148, 151, |
816 | 172, 177, 189, 129, 132, 133, 134, 135, | 502 | 153, 159, 161, 163, 170, 171, 173, 176, |
817 | 138, 139, 147, 148, 167, 168, 169, 170, | 503 | 178, 179, 134, 128, 132, 156, 159, 128, |
818 | 179, 180, 191, 133, 128, 134, 135, 155, | 504 | 128, 135, 137, 172, 136, 140, 128, 129, |
819 | 156, 159, 160, 191, 128, 129, 191, 136, | 505 | 130, 131, 137, 138, 139, 140, 141, 142, |
820 | 128, 172, 173, 191, 128, 135, 136, 140, | 506 | 143, 144, 153, 154, 155, 156, 157, 158, |
821 | 141, 191, 191, 128, 170, 171, 190, 161, | 507 | 159, 160, 161, 162, 163, 164, 165, 166, |
822 | 128, 143, 144, 149, 150, 153, 154, 157, | 508 | 167, 168, 169, 170, 172, 173, 174, 175, |
823 | 158, 164, 165, 166, 167, 173, 174, 176, | 509 | 176, 177, 178, 179, 180, 181, 182, 184, |
824 | 177, 180, 181, 255, 130, 141, 143, 159, | 510 | 188, 189, 190, 191, 132, 152, 185, 187, |
825 | 134, 187, 136, 140, 142, 143, 137, 151, | 511 | 191, 128, 170, 161, 144, 149, 154, 157, |
826 | 153, 142, 143, 158, 159, 137, 177, 191, | 512 | 165, 166, 174, 176, 181, 255, 130, 141, |
827 | 142, 143, 182, 183, 192, 255, 129, 151, | 513 | 143, 159, 155, 255, 128, 140, 142, 145, |
828 | 128, 133, 134, 135, 136, 255, 145, 150, | 514 | 160, 177, 128, 145, 160, 172, 174, 176, |
829 | 151, 155, 191, 192, 255, 128, 143, 144, | 515 | 151, 156, 170, 128, 168, 176, 255, 138, |
830 | 159, 160, 255, 182, 183, 190, 191, 192, | 516 | 255, 128, 150, 160, 255, 149, 255, 167, |
831 | 255, 128, 129, 255, 173, 174, 192, 255, | 517 | 133, 179, 133, 139, 131, 160, 174, 175, |
832 | 128, 129, 154, 155, 159, 160, 255, 171, | 518 | 186, 255, 166, 255, 128, 163, 141, 143, |
833 | 173, 185, 191, 192, 255, 141, 128, 145, | 519 | 154, 189, 169, 172, 174, 177, 181, 182, |
834 | 146, 159, 160, 177, 178, 191, 173, 128, | 520 | 129, 130, 132, 133, 134, 176, 177, 178, |
835 | 145, 146, 159, 160, 176, 177, 191, 128, | 521 | 179, 180, 181, 182, 183, 177, 191, 165, |
836 | 179, 180, 191, 151, 156, 128, 191, 128, | 522 | 170, 175, 177, 180, 255, 168, 174, 176, |
837 | 159, 160, 255, 184, 191, 192, 255, 169, | 523 | 255, 128, 134, 136, 142, 144, 150, 152, |
838 | 128, 170, 171, 175, 176, 255, 182, 191, | 524 | 158, 128, 129, 130, 131, 132, 133, 134, |
839 | 192, 255, 128, 158, 159, 191, 128, 143, | 525 | 135, 144, 145, 255, 133, 135, 161, 169, |
840 | 144, 173, 174, 175, 176, 180, 181, 191, | 526 | 177, 181, 184, 188, 160, 151, 154, 128, |
841 | 128, 171, 172, 175, 176, 255, 138, 191, | ||
842 | 192, 255, 128, 150, 151, 159, 160, 255, | ||
843 | 149, 191, 192, 255, 167, 128, 191, 128, | ||
844 | 132, 133, 179, 180, 191, 128, 132, 133, | ||
845 | 139, 140, 191, 128, 130, 131, 160, 161, | ||
846 | 173, 174, 175, 176, 185, 186, 255, 166, | ||
847 | 191, 192, 255, 128, 163, 164, 191, 128, | ||
848 | 140, 141, 143, 144, 153, 154, 189, 190, | ||
849 | 191, 128, 136, 137, 191, 173, 128, 168, | ||
850 | 169, 177, 178, 180, 181, 182, 183, 191, | ||
851 | 0, 127, 192, 255, 150, 151, 158, 159, | ||
852 | 152, 154, 156, 158, 134, 135, 142, 143, | ||
853 | 190, 191, 192, 255, 181, 189, 191, 128, | ||
854 | 190, 133, 181, 128, 129, 130, 140, 141, | ||
855 | 143, 144, 147, 148, 149, 150, 155, 156, | ||
856 | 159, 160, 172, 173, 177, 178, 188, 189, | ||
857 | 191, 177, 191, 128, 190, 128, 143, 144, | ||
858 | 156, 157, 191, 130, 135, 148, 164, 166, | ||
859 | 168, 128, 137, 138, 149, 150, 151, 152, | ||
860 | 157, 158, 169, 170, 185, 186, 187, 188, | ||
861 | 191, 142, 128, 132, 133, 137, 138, 159, | ||
862 | 160, 255, 137, 191, 192, 255, 175, 128, | ||
863 | 255, 159, 165, 170, 175, 177, 180, 191, | ||
864 | 192, 255, 166, 173, 128, 167, 168, 175, | ||
865 | 176, 255, 168, 174, 176, 191, 192, 255, | ||
866 | 167, 175, 183, 191, 128, 150, 151, 159, | ||
867 | 160, 190, 135, 143, 151, 128, 158, 159, | ||
868 | 191, 128, 132, 133, 135, 136, 160, 161, | ||
869 | 169, 170, 176, 177, 181, 182, 183, 184, | ||
870 | 188, 189, 191, 160, 151, 154, 187, 192, | ||
871 | 255, 128, 132, 133, 173, 174, 176, 177, | ||
872 | 255, 143, 159, 187, 191, 192, 255, 128, | ||
873 | 175, 176, 191, 150, 191, 192, 255, 141, | ||
874 | 191, 192, 255, 128, 143, 144, 189, 190, | ||
875 | 191, 141, 143, 160, 169, 172, 191, 192, | ||
876 | 255, 191, 128, 174, 175, 190, 128, 157, | ||
877 | 158, 159, 160, 255, 176, 191, 192, 255, | ||
878 | 128, 150, 151, 159, 160, 161, 162, 255, | ||
879 | 175, 137, 138, 184, 191, 192, 255, 128, | ||
880 | 182, 183, 255, 130, 134, 139, 163, 191, | ||
881 | 192, 255, 128, 129, 130, 179, 180, 191, | ||
882 | 187, 189, 128, 177, 178, 183, 184, 191, | ||
883 | 128, 137, 138, 165, 166, 175, 176, 255, | ||
884 | 135, 159, 189, 191, 192, 255, 128, 131, | ||
885 | 132, 178, 179, 191, 143, 165, 191, 128, | ||
886 | 159, 160, 175, 176, 185, 186, 190, 128, | ||
887 | 168, 169, 191, 131, 186, 128, 139, 140, | ||
888 | 159, 160, 182, 183, 189, 190, 255, 176, | ||
889 | 178, 180, 183, 184, 190, 191, 192, 255, | ||
890 | 129, 128, 130, 131, 154, 155, 157, 158, | ||
891 | 159, 160, 170, 171, 177, 178, 180, 181, | ||
892 | 191, 128, 167, 175, 129, 134, 135, 136, | ||
893 | 137, 142, 143, 144, 145, 150, 151, 159, | ||
894 | 160, 255, 155, 166, 175, 128, 162, 163, | ||
895 | 191, 164, 175, 135, 138, 188, 191, 192, | ||
896 | 255, 174, 175, 154, 191, 192, 255, 157, | ||
897 | 169, 183, 189, 191, 128, 134, 135, 146, | ||
898 | 147, 151, 152, 158, 159, 190, 130, 133, | ||
899 | 128, 255, 178, 191, 192, 255, 128, 146, | ||
900 | 147, 255, 190, 191, 192, 255, 128, 143, | ||
901 | 144, 255, 144, 145, 136, 175, 188, 191, | ||
902 | 192, 255, 181, 128, 175, 176, 255, 189, | ||
903 | 191, 192, 255, 128, 160, 161, 186, 187, | ||
904 | 191, 128, 129, 154, 155, 165, 166, 255, | ||
905 | 191, 192, 255, 128, 129, 130, 135, 136, | ||
906 | 137, 138, 143, 144, 145, 146, 151, 152, | ||
907 | 153, 154, 156, 157, 191, 128, 191, 128, | ||
908 | 129, 130, 131, 133, 138, 139, 140, 141, | ||
909 | 142, 143, 144, 145, 146, 147, 148, 149, | ||
910 | 152, 156, 157, 160, 161, 162, 163, 164, | ||
911 | 166, 168, 169, 170, 171, 172, 173, 174, | ||
912 | 176, 177, 132, 151, 153, 155, 158, 175, | ||
913 | 178, 179, 180, 191, 140, 167, 187, 190, | ||
914 | 128, 255, 142, 143, 158, 191, 192, 255, | ||
915 | 187, 191, 192, 255, 128, 180, 181, 191, | ||
916 | 128, 156, 157, 159, 160, 255, 145, 191, | ||
917 | 192, 255, 128, 159, 160, 175, 176, 255, | ||
918 | 139, 143, 182, 191, 192, 255, 144, 132, | ||
919 | 135, 150, 191, 192, 255, 158, 175, 148, | ||
920 | 151, 188, 191, 192, 255, 128, 167, 168, | ||
921 | 175, 176, 255, 164, 191, 192, 255, 183, | ||
922 | 191, 192, 255, 128, 149, 150, 159, 160, | ||
923 | 167, 168, 191, 136, 182, 188, 128, 133, | ||
924 | 134, 137, 138, 184, 185, 190, 191, 255, | ||
925 | 150, 159, 183, 191, 192, 255, 179, 128, | ||
926 | 159, 160, 181, 182, 191, 128, 149, 150, | ||
927 | 159, 160, 185, 186, 191, 128, 183, 184, | ||
928 | 189, 190, 191, 128, 148, 152, 129, 143, | ||
929 | 144, 179, 180, 191, 128, 159, 160, 188, | ||
930 | 189, 191, 128, 156, 157, 191, 136, 128, | ||
931 | 164, 165, 191, 128, 181, 182, 191, 128, | ||
932 | 149, 150, 159, 160, 178, 179, 191, 128, | ||
933 | 145, 146, 191, 128, 178, 179, 191, 128, | ||
934 | 130, 131, 132, 133, 134, 135, 136, 138, | ||
935 | 139, 140, 141, 144, 145, 146, 147, 150, | ||
936 | 151, 152, 153, 154, 156, 162, 163, 171, | ||
937 | 176, 177, 178, 129, 191, 128, 130, 131, | ||
938 | 183, 184, 191, 128, 130, 131, 175, 176, | ||
939 | 191, 128, 143, 144, 168, 169, 191, 128, | ||
940 | 130, 131, 166, 167, 191, 182, 128, 143, | ||
941 | 144, 178, 179, 191, 128, 130, 131, 178, | ||
942 | 179, 191, 128, 154, 156, 129, 132, 133, | ||
943 | 191, 146, 128, 171, 172, 191, 135, 137, | ||
944 | 142, 158, 128, 168, 169, 175, 176, 255, | ||
945 | 159, 191, 192, 255, 144, 128, 156, 157, | ||
946 | 161, 162, 191, 128, 134, 135, 138, 139, | ||
947 | 191, 128, 175, 176, 191, 134, 128, 131, | ||
948 | 132, 135, 136, 191, 128, 174, 175, 191, | ||
949 | 128, 151, 152, 155, 156, 191, 132, 128, | ||
950 | 191, 128, 170, 171, 191, 128, 153, 154, | ||
951 | 191, 160, 190, 192, 255, 128, 184, 185, | ||
952 | 191, 137, 128, 174, 175, 191, 128, 129, | ||
953 | 177, 178, 255, 144, 191, 192, 255, 128, | ||
954 | 142, 143, 144, 145, 146, 149, 129, 148, | ||
955 | 150, 191, 175, 191, 192, 255, 132, 191, | ||
956 | 192, 255, 128, 144, 129, 143, 145, 191, | ||
957 | 144, 153, 128, 143, 145, 152, 154, 191, | ||
958 | 135, 191, 192, 255, 160, 168, 169, 171, | ||
959 | 172, 173, 174, 188, 189, 190, 191, 128, | ||
960 | 159, 161, 167, 170, 187, 185, 191, 192, | ||
961 | 255, 128, 143, 144, 173, 174, 191, 128, | ||
962 | 131, 132, 162, 163, 183, 184, 188, 189, | ||
963 | 255, 133, 143, 145, 191, 192, 255, 128, | ||
964 | 146, 147, 159, 160, 191, 160, 128, 191, | ||
965 | 128, 129, 191, 192, 255, 159, 160, 171, | ||
966 | 128, 170, 172, 191, 192, 255, 173, 191, | ||
967 | 192, 255, 179, 191, 192, 255, 128, 176, | ||
968 | 177, 178, 129, 191, 128, 129, 130, 191, | ||
969 | 171, 175, 189, 191, 192, 255, 128, 136, | ||
970 | 137, 143, 144, 153, 154, 191, 144, 145, | ||
971 | 146, 147, 148, 149, 154, 155, 156, 157, | ||
972 | 158, 159, 128, 143, 150, 153, 160, 191, | ||
973 | 149, 157, 173, 186, 188, 160, 161, 163, | ||
974 | 164, 167, 168, 132, 134, 149, 157, 186, | ||
975 | 191, 139, 140, 192, 255, 133, 145, 128, | ||
976 | 134, 135, 137, 138, 255, 166, 167, 129, | ||
977 | 155, 187, 149, 181, 143, 175, 137, 169, | ||
978 | 131, 140, 191, 192, 255, 160, 163, 164, | ||
979 | 165, 184, 185, 186, 128, 159, 161, 162, | ||
980 | 166, 191, 133, 191, 192, 255, 132, 160, | ||
981 | 163, 167, 179, 184, 186, 128, 164, 165, | ||
982 | 168, 169, 187, 188, 191, 130, 135, 137, | ||
983 | 139, 144, 147, 151, 153, 155, 157, 159, | ||
984 | 163, 171, 179, 184, 189, 191, 128, 140, | ||
985 | 141, 148, 149, 160, 161, 164, 165, 166, | ||
986 | 167, 190, 138, 164, 170, 128, 155, 156, | ||
987 | 160, 161, 187, 188, 191, 128, 191, 155, | ||
988 | 156, 128, 191, 151, 191, 192, 255, 156, | ||
989 | 157, 160, 128, 191, 181, 191, 192, 255, | ||
990 | 158, 159, 186, 128, 185, 187, 191, 192, | ||
991 | 255, 162, 191, 192, 255, 160, 168, 128, | ||
992 | 159, 161, 167, 169, 191, 158, 191, 192, | ||
993 | 255, 123, 123, 128, 191, 128, 191, 128, | ||
994 | 191, 128, 191, 128, 191, 10, 123, 123, | ||
995 | 128, 191, 128, 191, 128, 191, 123, 123, | ||
996 | 10, 123, 128, 191, 128, 191, 128, 191, | ||
997 | 123, 123, 170, 181, 183, 186, 128, 150, | ||
998 | 152, 182, 184, 255, 192, 255, 128, 255, | ||
999 | 173, 130, 133, 146, 159, 165, 171, 175, | ||
1000 | 255, 181, 190, 184, 185, 192, 255, 140, | ||
1001 | 134, 138, 142, 161, 163, 255, 182, 130, | ||
1002 | 136, 137, 176, 151, 152, 154, 160, 190, | ||
1003 | 136, 144, 192, 255, 135, 129, 130, 132, | ||
1004 | 133, 144, 170, 176, 178, 144, 154, 160, | ||
1005 | 191, 128, 169, 174, 255, 148, 169, 157, | ||
1006 | 158, 189, 190, 192, 255, 144, 255, 139, | ||
1007 | 140, 178, 255, 186, 128, 181, 160, 161, | ||
1008 | 162, 163, 164, 165, 166, 167, 168, 169, | ||
1009 | 170, 171, 172, 173, 174, 175, 176, 177, | ||
1010 | 178, 179, 180, 181, 182, 183, 184, 185, | ||
1011 | 186, 187, 188, 189, 190, 191, 128, 173, | ||
1012 | 128, 155, 160, 180, 182, 189, 148, 161, | ||
1013 | 163, 255, 176, 164, 165, 132, 169, 177, | ||
1014 | 141, 142, 145, 146, 179, 181, 186, 187, | ||
1015 | 158, 133, 134, 137, 138, 143, 150, 152, | ||
1016 | 155, 164, 165, 178, 255, 188, 129, 131, | ||
1017 | 133, 138, 143, 144, 147, 168, 170, 176, | ||
1018 | 178, 179, 181, 182, 184, 185, 190, 255, | ||
1019 | 157, 131, 134, 137, 138, 142, 144, 146, | ||
1020 | 152, 159, 165, 182, 255, 129, 131, 133, | ||
1021 | 141, 143, 145, 147, 168, 170, 176, 178, | ||
1022 | 179, 181, 185, 188, 255, 134, 138, 142, | ||
1023 | 143, 145, 159, 164, 165, 176, 184, 186, | ||
1024 | 255, 129, 131, 133, 140, 143, 144, 147, | ||
1025 | 168, 170, 176, 178, 179, 181, 185, 188, | ||
1026 | 191, 177, 128, 132, 135, 136, 139, 141, | ||
1027 | 150, 151, 156, 157, 159, 163, 166, 175, | ||
1028 | 156, 130, 131, 133, 138, 142, 144, 146, | ||
1029 | 149, 153, 154, 158, 159, 163, 164, 168, | ||
1030 | 170, 174, 185, 190, 191, 144, 151, 128, | ||
1031 | 130, 134, 136, 138, 141, 166, 175, 128, | ||
1032 | 131, 133, 140, 142, 144, 146, 168, 170, | ||
1033 | 185, 189, 255, 133, 137, 151, 142, 148, | ||
1034 | 155, 159, 164, 165, 176, 255, 128, 131, | ||
1035 | 133, 140, 142, 144, 146, 168, 170, 179, | ||
1036 | 181, 185, 188, 191, 158, 128, 132, 134, | ||
1037 | 136, 138, 141, 149, 150, 160, 163, 166, | ||
1038 | 175, 177, 178, 129, 131, 133, 140, 142, | ||
1039 | 144, 146, 186, 189, 255, 133, 137, 143, | ||
1040 | 147, 152, 158, 164, 165, 176, 185, 192, | ||
1041 | 255, 189, 130, 131, 133, 150, 154, 177, | ||
1042 | 179, 187, 138, 150, 128, 134, 143, 148, | ||
1043 | 152, 159, 166, 175, 178, 179, 129, 186, | ||
1044 | 128, 142, 144, 153, 132, 138, 141, 165, | ||
1045 | 167, 129, 130, 135, 136, 148, 151, 153, | ||
1046 | 159, 161, 163, 170, 171, 173, 185, 187, | ||
1047 | 189, 134, 128, 132, 136, 141, 144, 153, | ||
1048 | 156, 159, 128, 181, 183, 185, 152, 153, | ||
1049 | 160, 169, 190, 191, 128, 135, 137, 172, | ||
1050 | 177, 191, 128, 132, 134, 151, 153, 188, | ||
1051 | 134, 128, 129, 130, 131, 137, 138, 139, | ||
1052 | 140, 141, 142, 143, 144, 153, 154, 155, | ||
1053 | 156, 157, 158, 159, 160, 161, 162, 163, | ||
1054 | 164, 165, 166, 167, 168, 169, 170, 173, | ||
1055 | 175, 176, 177, 178, 179, 181, 182, 183, | ||
1056 | 188, 189, 190, 191, 132, 152, 172, 184, | ||
1057 | 185, 187, 128, 191, 128, 137, 144, 255, | ||
1058 | 158, 159, 134, 187, 136, 140, 142, 143, | ||
1059 | 137, 151, 153, 142, 143, 158, 159, 137, | ||
1060 | 177, 142, 143, 182, 183, 191, 255, 128, | ||
1061 | 130, 133, 136, 150, 152, 255, 145, 150, | ||
1062 | 151, 155, 156, 160, 168, 178, 255, 128, | ||
1063 | 143, 160, 255, 182, 183, 190, 255, 129, | ||
1064 | 255, 173, 174, 192, 255, 129, 154, 160, | ||
1065 | 255, 171, 173, 185, 255, 128, 140, 142, | ||
1066 | 148, 160, 180, 128, 147, 160, 172, 174, | ||
1067 | 176, 178, 179, 148, 150, 152, 155, 158, | ||
1068 | 159, 170, 255, 139, 141, 144, 153, 160, | ||
1069 | 255, 184, 255, 128, 170, 176, 255, 182, | ||
1070 | 255, 128, 158, 160, 171, 176, 187, 134, | ||
1071 | 173, 176, 180, 128, 171, 176, 255, 138, | ||
1072 | 143, 155, 255, 128, 155, 160, 255, 159, | ||
1073 | 189, 190, 192, 255, 167, 128, 137, 144, | ||
1074 | 153, 176, 189, 140, 143, 154, 170, 180, | ||
1075 | 255, 180, 255, 128, 183, 128, 137, 141, | ||
1076 | 189, 128, 136, 144, 146, 148, 182, 184, | ||
1077 | 185, 128, 181, 187, 191, 150, 151, 158, | ||
1078 | 159, 152, 154, 156, 158, 134, 135, 142, | ||
1079 | 143, 190, 255, 190, 128, 180, 182, 188, | ||
1080 | 130, 132, 134, 140, 144, 147, 150, 155, | ||
1081 | 160, 172, 178, 180, 182, 188, 128, 129, | ||
1082 | 130, 131, 132, 133, 134, 176, 177, 178, | ||
1083 | 179, 180, 181, 182, 183, 191, 255, 129, | ||
1084 | 147, 149, 176, 178, 190, 192, 255, 144, | ||
1085 | 156, 161, 144, 156, 165, 176, 130, 135, | ||
1086 | 149, 164, 166, 168, 138, 147, 152, 157, | ||
1087 | 170, 185, 188, 191, 142, 133, 137, 160, | ||
1088 | 255, 137, 255, 128, 174, 176, 255, 159, | ||
1089 | 165, 170, 180, 255, 167, 173, 128, 165, | ||
1090 | 176, 255, 168, 174, 176, 190, 192, 255, | ||
1091 | 128, 150, 160, 166, 168, 174, 176, 182, | ||
1092 | 184, 190, 128, 134, 136, 142, 144, 150, | ||
1093 | 152, 158, 160, 191, 128, 129, 130, 131, | ||
1094 | 132, 133, 134, 135, 144, 145, 255, 133, | ||
1095 | 135, 161, 175, 177, 181, 184, 188, 160, | ||
1096 | 151, 152, 187, 192, 255, 133, 173, 177, | ||
1097 | 255, 143, 159, 187, 255, 176, 191, 182, | ||
1098 | 183, 184, 191, 192, 255, 150, 255, 128, | ||
1099 | 146, 147, 148, 152, 153, 154, 155, 156, | 527 | 146, 147, 148, 152, 153, 154, 155, 156, |
1100 | 158, 159, 160, 161, 162, 163, 164, 165, | 528 | 158, 159, 160, 161, 162, 163, 164, 165, |
1101 | 166, 167, 168, 169, 170, 171, 172, 173, | 529 | 166, 167, 168, 169, 170, 171, 172, 173, |
1102 | 174, 175, 176, 129, 255, 141, 255, 144, | 530 | 174, 175, 176, 129, 255, 141, 143, 160, |
1103 | 189, 141, 143, 172, 255, 191, 128, 175, | 531 | 169, 172, 255, 191, 128, 174, 130, 134, |
1104 | 180, 189, 151, 159, 162, 255, 175, 137, | 532 | 139, 163, 255, 130, 179, 187, 189, 178, |
1105 | 138, 184, 255, 183, 255, 168, 255, 128, | 533 | 183, 138, 165, 176, 255, 135, 159, 189, |
1106 | 179, 188, 134, 143, 154, 159, 184, 186, | 534 | 255, 132, 178, 143, 160, 164, 166, 175, |
1107 | 190, 255, 128, 173, 176, 255, 148, 159, | 535 | 186, 190, 128, 168, 186, 128, 130, 132, |
1108 | 189, 255, 129, 142, 154, 159, 191, 255, | 536 | 139, 160, 182, 190, 255, 176, 178, 180, |
1109 | 128, 182, 128, 141, 144, 153, 160, 182, | 537 | 183, 184, 190, 255, 128, 130, 155, 157, |
1110 | 186, 255, 128, 130, 155, 157, 160, 175, | 538 | 160, 170, 178, 180, 128, 162, 164, 169, |
1111 | 178, 182, 129, 134, 137, 142, 145, 150, | 539 | 171, 172, 173, 174, 175, 180, 181, 182, |
1112 | 160, 166, 168, 174, 176, 255, 155, 166, | 540 | 183, 185, 186, 187, 188, 189, 190, 191, |
1113 | 175, 128, 170, 172, 173, 176, 185, 158, | 541 | 165, 179, 157, 190, 128, 134, 147, 151, |
1114 | 159, 160, 255, 164, 175, 135, 138, 188, | 542 | 159, 168, 170, 182, 184, 188, 176, 180, |
1115 | 255, 164, 169, 171, 172, 173, 174, 175, | 543 | 182, 255, 161, 186, 144, 145, 146, 147, |
1116 | 180, 181, 182, 183, 184, 185, 187, 188, | 544 | 148, 150, 151, 152, 155, 157, 158, 160, |
1117 | 189, 190, 191, 165, 186, 174, 175, 154, | 545 | 170, 171, 172, 175, 161, 169, 128, 129, |
1118 | 255, 190, 128, 134, 147, 151, 157, 168, | 546 | 130, 131, 133, 138, 139, 140, 141, 142, |
1119 | 170, 182, 184, 188, 128, 129, 131, 132, | 547 | 143, 144, 145, 146, 147, 148, 149, 152, |
1120 | 134, 255, 147, 255, 190, 255, 144, 145, | 548 | 156, 157, 160, 161, 162, 163, 164, 166, |
1121 | 136, 175, 188, 255, 128, 143, 160, 175, | 549 | 168, 169, 170, 171, 172, 173, 174, 176, |
1122 | 179, 180, 141, 143, 176, 180, 182, 255, | 550 | 177, 153, 155, 178, 179, 145, 255, 139, |
1123 | 189, 255, 191, 144, 153, 161, 186, 129, | 551 | 143, 182, 255, 158, 175, 128, 144, 147, |
1124 | 154, 166, 255, 191, 255, 130, 135, 138, | 552 | 149, 151, 153, 179, 128, 135, 137, 164, |
1125 | 143, 146, 151, 154, 156, 144, 145, 146, | ||
1126 | 147, 148, 150, 151, 152, 155, 157, 158, | ||
1127 | 160, 170, 171, 172, 175, 161, 169, 128, | ||
1128 | 129, 130, 131, 133, 135, 138, 139, 140, | ||
1129 | 141, 142, 143, 144, 145, 146, 147, 148, | ||
1130 | 149, 152, 156, 157, 160, 161, 162, 163, | ||
1131 | 164, 166, 168, 169, 170, 171, 172, 173, | ||
1132 | 174, 176, 177, 153, 155, 178, 179, 128, | ||
1133 | 139, 141, 166, 168, 186, 188, 189, 191, | ||
1134 | 255, 142, 143, 158, 255, 187, 255, 128, | ||
1135 | 180, 189, 128, 156, 160, 255, 145, 159, | ||
1136 | 161, 255, 128, 159, 176, 255, 139, 143, | ||
1137 | 187, 255, 128, 157, 160, 255, 144, 132, | ||
1138 | 135, 150, 255, 158, 159, 170, 175, 148, | ||
1139 | 151, 188, 255, 128, 167, 176, 255, 164, | ||
1140 | 255, 183, 255, 128, 149, 160, 167, 136, | ||
1141 | 188, 128, 133, 138, 181, 183, 184, 191, | ||
1142 | 255, 150, 159, 183, 255, 128, 158, 160, | ||
1143 | 178, 180, 181, 128, 149, 160, 185, 128, | ||
1144 | 183, 190, 191, 191, 128, 131, 133, 134, | ||
1145 | 140, 147, 149, 151, 153, 179, 184, 186, | ||
1146 | 160, 188, 128, 156, 128, 135, 137, 166, | ||
1147 | 128, 181, 128, 149, 160, 178, 128, 145, | ||
1148 | 128, 178, 129, 130, 131, 132, 133, 135, | ||
1149 | 136, 138, 139, 140, 141, 144, 145, 146, | ||
1150 | 147, 150, 151, 152, 153, 154, 155, 156, | ||
1151 | 162, 163, 171, 176, 177, 178, 128, 134, | ||
1152 | 135, 165, 176, 190, 144, 168, 176, 185, | ||
1153 | 128, 180, 182, 191, 182, 144, 179, 155, | ||
1154 | 133, 137, 141, 143, 157, 255, 190, 128, | ||
1155 | 145, 147, 183, 136, 128, 134, 138, 141, | ||
1156 | 143, 157, 159, 168, 176, 255, 171, 175, | ||
1157 | 186, 255, 128, 131, 133, 140, 143, 144, | ||
1158 | 147, 168, 170, 176, 178, 179, 181, 185, | ||
1159 | 188, 191, 144, 151, 128, 132, 135, 136, | ||
1160 | 139, 141, 157, 163, 166, 172, 176, 180, | ||
1161 | 128, 138, 144, 153, 134, 136, 143, 154, | ||
1162 | 255, 128, 181, 184, 255, 129, 151, 158, | ||
1163 | 255, 129, 131, 133, 143, 154, 255, 128, | ||
1164 | 137, 128, 153, 157, 171, 176, 185, 160, | ||
1165 | 255, 170, 190, 192, 255, 128, 184, 128, | ||
1166 | 136, 138, 182, 184, 191, 128, 144, 153, | ||
1167 | 178, 255, 168, 144, 145, 183, 255, 128, | ||
1168 | 142, 145, 149, 129, 141, 144, 146, 147, | ||
1169 | 148, 175, 255, 132, 255, 128, 144, 129, | ||
1170 | 143, 144, 153, 145, 152, 135, 255, 160, | ||
1171 | 168, 169, 171, 172, 173, 174, 188, 189, | ||
1172 | 190, 191, 161, 167, 185, 255, 128, 158, | ||
1173 | 160, 169, 144, 173, 176, 180, 128, 131, | ||
1174 | 144, 153, 163, 183, 189, 255, 144, 255, | ||
1175 | 133, 143, 191, 255, 143, 159, 160, 128, | ||
1176 | 129, 255, 159, 160, 171, 172, 255, 173, | ||
1177 | 255, 179, 255, 128, 176, 177, 178, 128, | ||
1178 | 129, 171, 175, 189, 255, 128, 136, 144, | ||
1179 | 153, 157, 158, 133, 134, 137, 144, 145, | ||
1180 | 146, 147, 148, 149, 154, 155, 156, 157, | ||
1181 | 158, 159, 168, 169, 170, 150, 153, 165, | ||
1182 | 169, 173, 178, 187, 255, 131, 132, 140, | ||
1183 | 169, 174, 255, 130, 132, 149, 157, 173, | ||
1184 | 186, 188, 160, 161, 163, 164, 167, 168, | ||
1185 | 132, 134, 149, 157, 186, 139, 140, 191, | ||
1186 | 255, 134, 128, 132, 138, 144, 146, 255, | ||
1187 | 166, 167, 129, 155, 187, 149, 181, 143, | ||
1188 | 175, 137, 169, 131, 140, 141, 192, 255, | ||
1189 | 128, 182, 187, 255, 173, 180, 182, 255, | ||
1190 | 132, 155, 159, 161, 175, 128, 160, 163, | ||
1191 | 164, 165, 184, 185, 186, 161, 162, 128, | ||
1192 | 134, 136, 152, 155, 161, 163, 164, 166, | ||
1193 | 170, 133, 143, 151, 255, 139, 143, 154, | ||
1194 | 255, 164, 167, 185, 187, 128, 131, 133, | ||
1195 | 159, 161, 162, 169, 178, 180, 183, 130, | ||
1196 | 135, 137, 139, 148, 151, 153, 155, 157, | ||
1197 | 159, 164, 190, 141, 143, 145, 146, 161, | ||
1198 | 162, 167, 170, 172, 178, 180, 183, 185, | ||
1199 | 188, 128, 137, 139, 155, 161, 163, 165, | ||
1200 | 169, 171, 187, 155, 156, 151, 255, 156, | ||
1201 | 157, 160, 181, 255, 186, 187, 255, 162, | ||
1202 | 255, 160, 168, 161, 167, 158, 255, 160, | ||
1203 | 132, 135, 133, 134, 176, 255, 128, 191, | ||
1204 | 154, 164, 168, 128, 149, 150, 191, 128, | ||
1205 | 152, 153, 191, 181, 128, 159, 160, 189, | ||
1206 | 190, 191, 189, 128, 131, 132, 185, 186, | ||
1207 | 191, 144, 128, 151, 152, 161, 162, 176, | ||
1208 | 177, 255, 169, 177, 129, 132, 141, 142, | ||
1209 | 145, 146, 179, 181, 186, 188, 190, 191, | ||
1210 | 192, 255, 142, 158, 128, 155, 156, 161, | ||
1211 | 162, 175, 176, 177, 178, 191, 169, 177, | ||
1212 | 180, 183, 128, 132, 133, 138, 139, 142, | ||
1213 | 143, 144, 145, 146, 147, 185, 186, 191, | ||
1214 | 157, 128, 152, 153, 158, 159, 177, 178, | ||
1215 | 180, 181, 191, 142, 146, 169, 177, 180, | ||
1216 | 189, 128, 132, 133, 185, 186, 191, 144, | ||
1217 | 185, 128, 159, 160, 161, 162, 191, 169, | ||
1218 | 177, 180, 189, 128, 132, 133, 140, 141, | ||
1219 | 142, 143, 144, 145, 146, 147, 185, 186, | ||
1220 | 191, 158, 177, 128, 155, 156, 161, 162, | ||
1221 | 191, 131, 145, 155, 157, 128, 132, 133, | ||
1222 | 138, 139, 141, 142, 149, 150, 152, 153, | ||
1223 | 159, 160, 162, 163, 164, 165, 167, 168, | ||
1224 | 170, 171, 173, 174, 185, 186, 191, 144, | ||
1225 | 128, 191, 141, 145, 169, 189, 128, 132, | ||
1226 | 133, 185, 186, 191, 128, 151, 152, 154, | ||
1227 | 155, 159, 160, 161, 162, 191, 128, 141, | ||
1228 | 145, 169, 180, 189, 129, 132, 133, 185, | ||
1229 | 186, 191, 158, 128, 159, 160, 161, 162, | ||
1230 | 176, 177, 178, 179, 191, 141, 145, 189, | ||
1231 | 128, 132, 133, 186, 187, 191, 142, 128, | ||
1232 | 147, 148, 150, 151, 158, 159, 161, 162, | ||
1233 | 185, 186, 191, 178, 188, 128, 132, 133, | ||
1234 | 150, 151, 153, 154, 189, 190, 191, 128, | ||
1235 | 134, 135, 191, 128, 177, 129, 179, 180, | ||
1236 | 191, 128, 131, 137, 141, 152, 160, 164, | ||
1237 | 166, 172, 177, 189, 129, 132, 133, 134, | ||
1238 | 135, 138, 139, 147, 148, 167, 168, 169, | ||
1239 | 170, 179, 180, 191, 133, 128, 134, 135, | ||
1240 | 155, 156, 159, 160, 191, 128, 129, 191, | ||
1241 | 136, 128, 172, 173, 191, 128, 135, 136, | ||
1242 | 140, 141, 191, 191, 128, 170, 171, 190, | ||
1243 | 161, 128, 143, 144, 149, 150, 153, 154, | ||
1244 | 157, 158, 164, 165, 166, 167, 173, 174, | ||
1245 | 176, 177, 180, 181, 255, 130, 141, 143, | ||
1246 | 159, 134, 187, 136, 140, 142, 143, 137, | ||
1247 | 151, 153, 142, 143, 158, 159, 137, 177, | ||
1248 | 191, 142, 143, 182, 183, 192, 255, 129, | ||
1249 | 151, 128, 133, 134, 135, 136, 255, 145, | ||
1250 | 150, 151, 155, 191, 192, 255, 128, 143, | ||
1251 | 144, 159, 160, 255, 182, 183, 190, 191, | ||
1252 | 192, 255, 128, 129, 255, 173, 174, 192, | ||
1253 | 255, 128, 129, 154, 155, 159, 160, 255, | ||
1254 | 171, 173, 185, 191, 192, 255, 141, 128, | ||
1255 | 145, 146, 159, 160, 177, 178, 191, 173, | ||
1256 | 128, 145, 146, 159, 160, 176, 177, 191, | ||
1257 | 128, 179, 180, 191, 151, 156, 128, 191, | ||
1258 | 128, 159, 160, 255, 184, 191, 192, 255, | ||
1259 | 169, 128, 170, 171, 175, 176, 255, 182, | ||
1260 | 191, 192, 255, 128, 158, 159, 191, 128, | ||
1261 | 143, 144, 173, 174, 175, 176, 180, 181, | ||
1262 | 191, 128, 171, 172, 175, 176, 255, 138, | ||
1263 | 191, 192, 255, 128, 150, 151, 159, 160, | ||
1264 | 255, 149, 191, 192, 255, 167, 128, 191, | ||
1265 | 128, 132, 133, 179, 180, 191, 128, 132, | ||
1266 | 133, 139, 140, 191, 128, 130, 131, 160, | ||
1267 | 161, 173, 174, 175, 176, 185, 186, 255, | ||
1268 | 166, 191, 192, 255, 128, 163, 164, 191, | ||
1269 | 128, 140, 141, 143, 144, 153, 154, 189, | ||
1270 | 190, 191, 128, 136, 137, 191, 173, 128, | ||
1271 | 168, 169, 177, 178, 180, 181, 182, 183, | ||
1272 | 191, 0, 127, 192, 255, 150, 151, 158, | ||
1273 | 159, 152, 154, 156, 158, 134, 135, 142, | ||
1274 | 143, 190, 191, 192, 255, 181, 189, 191, | ||
1275 | 128, 190, 133, 181, 128, 129, 130, 140, | ||
1276 | 141, 143, 144, 147, 148, 149, 150, 155, | ||
1277 | 156, 159, 160, 172, 173, 177, 178, 188, | ||
1278 | 189, 191, 177, 191, 128, 190, 128, 143, | ||
1279 | 144, 156, 157, 191, 130, 135, 148, 164, | ||
1280 | 166, 168, 128, 137, 138, 149, 150, 151, | ||
1281 | 152, 157, 158, 169, 170, 185, 186, 187, | ||
1282 | 188, 191, 142, 128, 132, 133, 137, 138, | ||
1283 | 159, 160, 255, 137, 191, 192, 255, 175, | ||
1284 | 128, 255, 159, 165, 170, 175, 177, 180, | ||
1285 | 191, 192, 255, 166, 173, 128, 167, 168, | ||
1286 | 175, 176, 255, 168, 174, 176, 191, 192, | ||
1287 | 255, 167, 175, 183, 191, 128, 150, 151, | ||
1288 | 159, 160, 190, 135, 143, 151, 128, 158, | ||
1289 | 159, 191, 128, 132, 133, 135, 136, 160, | ||
1290 | 161, 169, 170, 176, 177, 181, 182, 183, | ||
1291 | 184, 188, 189, 191, 160, 151, 154, 187, | ||
1292 | 192, 255, 128, 132, 133, 173, 174, 176, | ||
1293 | 177, 255, 143, 159, 187, 191, 192, 255, | ||
1294 | 128, 175, 176, 191, 150, 191, 192, 255, | ||
1295 | 141, 191, 192, 255, 128, 143, 144, 189, | ||
1296 | 190, 191, 141, 143, 160, 169, 172, 191, | ||
1297 | 192, 255, 191, 128, 174, 175, 190, 128, | ||
1298 | 157, 158, 159, 160, 255, 176, 191, 192, | ||
1299 | 255, 128, 150, 151, 159, 160, 161, 162, | ||
1300 | 255, 175, 137, 138, 184, 191, 192, 255, | ||
1301 | 128, 182, 183, 255, 130, 134, 139, 163, | ||
1302 | 191, 192, 255, 128, 129, 130, 179, 180, | ||
1303 | 191, 187, 189, 128, 177, 178, 183, 184, | ||
1304 | 191, 128, 137, 138, 165, 166, 175, 176, | ||
1305 | 255, 135, 159, 189, 191, 192, 255, 128, | ||
1306 | 131, 132, 178, 179, 191, 143, 165, 191, | ||
1307 | 128, 159, 160, 175, 176, 185, 186, 190, | ||
1308 | 128, 168, 169, 191, 131, 186, 128, 139, | ||
1309 | 140, 159, 160, 182, 183, 189, 190, 255, | ||
1310 | 176, 178, 180, 183, 184, 190, 191, 192, | ||
1311 | 255, 129, 128, 130, 131, 154, 155, 157, | ||
1312 | 158, 159, 160, 170, 171, 177, 178, 180, | ||
1313 | 181, 191, 128, 167, 175, 129, 134, 135, | ||
1314 | 136, 137, 142, 143, 144, 145, 150, 151, | ||
1315 | 159, 160, 255, 155, 166, 175, 128, 162, | ||
1316 | 163, 191, 164, 175, 135, 138, 188, 191, | ||
1317 | 192, 255, 174, 175, 154, 191, 192, 255, | ||
1318 | 157, 169, 183, 189, 191, 128, 134, 135, | ||
1319 | 146, 147, 151, 152, 158, 159, 190, 130, | ||
1320 | 133, 128, 255, 178, 191, 192, 255, 128, | ||
1321 | 146, 147, 255, 190, 191, 192, 255, 128, | ||
1322 | 143, 144, 255, 144, 145, 136, 175, 188, | ||
1323 | 191, 192, 255, 181, 128, 175, 176, 255, | ||
1324 | 189, 191, 192, 255, 128, 160, 161, 186, | ||
1325 | 187, 191, 128, 129, 154, 155, 165, 166, | ||
1326 | 255, 191, 192, 255, 128, 129, 130, 135, | ||
1327 | 136, 137, 138, 143, 144, 145, 146, 151, | ||
1328 | 152, 153, 154, 156, 157, 191, 128, 191, | ||
1329 | 128, 129, 130, 131, 133, 138, 139, 140, | ||
1330 | 141, 142, 143, 144, 145, 146, 147, 148, | ||
1331 | 149, 152, 156, 157, 160, 161, 162, 163, | ||
1332 | 164, 166, 168, 169, 170, 171, 172, 173, | ||
1333 | 174, 176, 177, 132, 151, 153, 155, 158, | ||
1334 | 175, 178, 179, 180, 191, 140, 167, 187, | ||
1335 | 190, 128, 255, 142, 143, 158, 191, 192, | ||
1336 | 255, 187, 191, 192, 255, 128, 180, 181, | ||
1337 | 191, 128, 156, 157, 159, 160, 255, 145, | ||
1338 | 191, 192, 255, 128, 159, 160, 175, 176, | ||
1339 | 255, 139, 143, 182, 191, 192, 255, 144, | ||
1340 | 132, 135, 150, 191, 192, 255, 158, 175, | ||
1341 | 148, 151, 188, 191, 192, 255, 128, 167, | ||
1342 | 168, 175, 176, 255, 164, 191, 192, 255, | ||
1343 | 183, 191, 192, 255, 128, 149, 150, 159, | ||
1344 | 160, 167, 168, 191, 136, 182, 188, 128, | ||
1345 | 133, 134, 137, 138, 184, 185, 190, 191, | ||
1346 | 255, 150, 159, 183, 191, 192, 255, 179, | ||
1347 | 128, 159, 160, 181, 182, 191, 128, 149, | ||
1348 | 150, 159, 160, 185, 186, 191, 128, 183, | ||
1349 | 184, 189, 190, 191, 128, 148, 152, 129, | ||
1350 | 143, 144, 179, 180, 191, 128, 159, 160, | ||
1351 | 188, 189, 191, 128, 156, 157, 191, 136, | ||
1352 | 128, 164, 165, 191, 128, 181, 182, 191, | ||
1353 | 128, 149, 150, 159, 160, 178, 179, 191, | ||
1354 | 128, 145, 146, 191, 128, 178, 179, 191, | ||
1355 | 128, 130, 131, 132, 133, 134, 135, 136, | 553 | 128, 130, 131, 132, 133, 134, 135, 136, |
1356 | 138, 139, 140, 141, 144, 145, 146, 147, | 554 | 138, 139, 140, 141, 144, 145, 146, 147, |
1357 | 150, 151, 152, 153, 154, 156, 162, 163, | 555 | 150, 151, 152, 153, 154, 156, 162, 163, |
1358 | 171, 176, 177, 178, 129, 191, 128, 130, | 556 | 171, 176, 177, 178, 131, 183, 131, 175, |
1359 | 131, 183, 184, 191, 128, 130, 131, 175, | 557 | 144, 168, 131, 166, 182, 144, 178, 131, |
1360 | 176, 191, 128, 143, 144, 168, 169, 191, | 558 | 178, 154, 156, 129, 132, 128, 145, 147, |
1361 | 128, 130, 131, 166, 167, 191, 182, 128, | 559 | 171, 159, 255, 144, 157, 161, 135, 138, |
1362 | 143, 144, 178, 179, 191, 128, 130, 131, | 560 | 128, 175, 135, 132, 133, 128, 174, 152, |
1363 | 178, 179, 191, 128, 154, 156, 129, 132, | 561 | 155, 132, 128, 170, 128, 153, 160, 190, |
1364 | 133, 191, 146, 128, 171, 172, 191, 135, | 562 | 192, 255, 128, 136, 138, 174, 128, 178, |
1365 | 137, 142, 158, 128, 168, 169, 175, 176, | 563 | 255, 160, 168, 169, 171, 172, 173, 174, |
1366 | 255, 159, 191, 192, 255, 144, 128, 156, | 564 | 188, 189, 190, 191, 161, 167, 144, 173, |
1367 | 157, 161, 162, 191, 128, 134, 135, 138, | 565 | 128, 131, 163, 183, 189, 255, 133, 143, |
1368 | 139, 191, 128, 175, 176, 191, 134, 128, | 566 | 145, 255, 147, 159, 128, 176, 177, 178, |
1369 | 131, 132, 135, 136, 191, 128, 174, 175, | 567 | 128, 136, 144, 153, 144, 145, 146, 147, |
1370 | 191, 128, 151, 152, 155, 156, 191, 132, | 568 | 148, 149, 154, 155, 156, 157, 158, 159, |
1371 | 128, 191, 128, 170, 171, 191, 128, 153, | 569 | 150, 153, 131, 140, 255, 160, 163, 164, |
1372 | 154, 191, 160, 190, 192, 255, 128, 184, | 570 | 165, 184, 185, 186, 161, 162, 133, 255, |
1373 | 185, 191, 137, 128, 174, 175, 191, 128, | 571 | 170, 181, 183, 186, 128, 150, 152, 182, |
1374 | 129, 177, 178, 255, 144, 191, 192, 255, | 572 | 184, 255, 192, 255, 128, 255, 173, 130, |
1375 | 128, 142, 143, 144, 145, 146, 149, 129, | 573 | 133, 146, 159, 165, 171, 175, 255, 181, |
1376 | 148, 150, 191, 175, 191, 192, 255, 132, | 574 | 190, 184, 185, 192, 255, 140, 134, 138, |
1377 | 191, 192, 255, 128, 144, 129, 143, 145, | 575 | 142, 161, 163, 255, 182, 130, 136, 137, |
1378 | 191, 144, 153, 128, 143, 145, 152, 154, | 576 | 176, 151, 152, 154, 160, 190, 136, 144, |
1379 | 191, 135, 191, 192, 255, 160, 168, 169, | 577 | 192, 255, 135, 129, 130, 132, 133, 144, |
578 | 170, 176, 178, 144, 154, 160, 191, 128, | ||
579 | 169, 174, 255, 148, 169, 157, 158, 189, | ||
580 | 190, 192, 255, 144, 255, 139, 140, 178, | ||
581 | 255, 186, 128, 181, 160, 161, 162, 163, | ||
582 | 164, 165, 166, 167, 168, 169, 170, 171, | ||
583 | 172, 173, 174, 175, 176, 177, 178, 179, | ||
584 | 180, 181, 182, 183, 184, 185, 186, 187, | ||
585 | 188, 189, 190, 191, 128, 173, 128, 155, | ||
586 | 160, 180, 182, 189, 148, 161, 163, 255, | ||
587 | 176, 164, 165, 132, 169, 177, 141, 142, | ||
588 | 145, 146, 179, 181, 186, 187, 158, 133, | ||
589 | 134, 137, 138, 143, 150, 152, 155, 164, | ||
590 | 165, 178, 255, 188, 129, 131, 133, 138, | ||
591 | 143, 144, 147, 168, 170, 176, 178, 179, | ||
592 | 181, 182, 184, 185, 190, 255, 157, 131, | ||
593 | 134, 137, 138, 142, 144, 146, 152, 159, | ||
594 | 165, 182, 255, 129, 131, 133, 141, 143, | ||
595 | 145, 147, 168, 170, 176, 178, 179, 181, | ||
596 | 185, 188, 255, 134, 138, 142, 143, 145, | ||
597 | 159, 164, 165, 176, 184, 186, 255, 129, | ||
598 | 131, 133, 140, 143, 144, 147, 168, 170, | ||
599 | 176, 178, 179, 181, 185, 188, 191, 177, | ||
600 | 128, 132, 135, 136, 139, 141, 150, 151, | ||
601 | 156, 157, 159, 163, 166, 175, 156, 130, | ||
602 | 131, 133, 138, 142, 144, 146, 149, 153, | ||
603 | 154, 158, 159, 163, 164, 168, 170, 174, | ||
604 | 185, 190, 191, 144, 151, 128, 130, 134, | ||
605 | 136, 138, 141, 166, 175, 128, 131, 133, | ||
606 | 140, 142, 144, 146, 168, 170, 185, 189, | ||
607 | 255, 133, 137, 151, 142, 148, 155, 159, | ||
608 | 164, 165, 176, 255, 128, 131, 133, 140, | ||
609 | 142, 144, 146, 168, 170, 179, 181, 185, | ||
610 | 188, 191, 158, 128, 132, 134, 136, 138, | ||
611 | 141, 149, 150, 160, 163, 166, 175, 177, | ||
612 | 178, 129, 131, 133, 140, 142, 144, 146, | ||
613 | 186, 189, 255, 133, 137, 143, 147, 152, | ||
614 | 158, 164, 165, 176, 185, 192, 255, 189, | ||
615 | 130, 131, 133, 150, 154, 177, 179, 187, | ||
616 | 138, 150, 128, 134, 143, 148, 152, 159, | ||
617 | 166, 175, 178, 179, 129, 186, 128, 142, | ||
618 | 144, 153, 132, 138, 141, 165, 167, 129, | ||
619 | 130, 135, 136, 148, 151, 153, 159, 161, | ||
620 | 163, 170, 171, 173, 185, 187, 189, 134, | ||
621 | 128, 132, 136, 141, 144, 153, 156, 159, | ||
622 | 128, 181, 183, 185, 152, 153, 160, 169, | ||
623 | 190, 191, 128, 135, 137, 172, 177, 191, | ||
624 | 128, 132, 134, 151, 153, 188, 134, 128, | ||
625 | 129, 130, 131, 137, 138, 139, 140, 141, | ||
626 | 142, 143, 144, 153, 154, 155, 156, 157, | ||
627 | 158, 159, 160, 161, 162, 163, 164, 165, | ||
628 | 166, 167, 168, 169, 170, 173, 175, 176, | ||
629 | 177, 178, 179, 181, 182, 183, 188, 189, | ||
630 | 190, 191, 132, 152, 172, 184, 185, 187, | ||
631 | 128, 191, 128, 137, 144, 255, 158, 159, | ||
632 | 134, 187, 136, 140, 142, 143, 137, 151, | ||
633 | 153, 142, 143, 158, 159, 137, 177, 142, | ||
634 | 143, 182, 183, 191, 255, 128, 130, 133, | ||
635 | 136, 150, 152, 255, 145, 150, 151, 155, | ||
636 | 156, 160, 168, 178, 255, 128, 143, 160, | ||
637 | 255, 182, 183, 190, 255, 129, 255, 173, | ||
638 | 174, 192, 255, 129, 154, 160, 255, 171, | ||
639 | 173, 185, 255, 128, 140, 142, 148, 160, | ||
640 | 180, 128, 147, 160, 172, 174, 176, 178, | ||
641 | 179, 148, 150, 152, 155, 158, 159, 170, | ||
642 | 255, 139, 141, 144, 153, 160, 255, 184, | ||
643 | 255, 128, 170, 176, 255, 182, 255, 128, | ||
644 | 158, 160, 171, 176, 187, 134, 173, 176, | ||
645 | 180, 128, 171, 176, 255, 138, 143, 155, | ||
646 | 255, 128, 155, 160, 255, 159, 189, 190, | ||
647 | 192, 255, 167, 128, 137, 144, 153, 176, | ||
648 | 189, 140, 143, 154, 170, 180, 255, 180, | ||
649 | 255, 128, 183, 128, 137, 141, 189, 128, | ||
650 | 136, 144, 146, 148, 182, 184, 185, 128, | ||
651 | 181, 187, 191, 150, 151, 158, 159, 152, | ||
652 | 154, 156, 158, 134, 135, 142, 143, 190, | ||
653 | 255, 190, 128, 180, 182, 188, 130, 132, | ||
654 | 134, 140, 144, 147, 150, 155, 160, 172, | ||
655 | 178, 180, 182, 188, 128, 129, 130, 131, | ||
656 | 132, 133, 134, 176, 177, 178, 179, 180, | ||
657 | 181, 182, 183, 191, 255, 129, 147, 149, | ||
658 | 176, 178, 190, 192, 255, 144, 156, 161, | ||
659 | 144, 156, 165, 176, 130, 135, 149, 164, | ||
660 | 166, 168, 138, 147, 152, 157, 170, 185, | ||
661 | 188, 191, 142, 133, 137, 160, 255, 137, | ||
662 | 255, 128, 174, 176, 255, 159, 165, 170, | ||
663 | 180, 255, 167, 173, 128, 165, 176, 255, | ||
664 | 168, 174, 176, 190, 192, 255, 128, 150, | ||
665 | 160, 166, 168, 174, 176, 182, 184, 190, | ||
666 | 128, 134, 136, 142, 144, 150, 152, 158, | ||
667 | 160, 191, 128, 129, 130, 131, 132, 133, | ||
668 | 134, 135, 144, 145, 255, 133, 135, 161, | ||
669 | 175, 177, 181, 184, 188, 160, 151, 152, | ||
670 | 187, 192, 255, 133, 173, 177, 255, 143, | ||
671 | 159, 187, 255, 176, 191, 182, 183, 184, | ||
672 | 191, 192, 255, 150, 255, 128, 146, 147, | ||
673 | 148, 152, 153, 154, 155, 156, 158, 159, | ||
674 | 160, 161, 162, 163, 164, 165, 166, 167, | ||
675 | 168, 169, 170, 171, 172, 173, 174, 175, | ||
676 | 176, 129, 255, 141, 255, 144, 189, 141, | ||
677 | 143, 172, 255, 191, 128, 175, 180, 189, | ||
678 | 151, 159, 162, 255, 175, 137, 138, 184, | ||
679 | 255, 183, 255, 168, 255, 128, 179, 188, | ||
680 | 134, 143, 154, 159, 184, 186, 190, 255, | ||
681 | 128, 173, 176, 255, 148, 159, 189, 255, | ||
682 | 129, 142, 154, 159, 191, 255, 128, 182, | ||
683 | 128, 141, 144, 153, 160, 182, 186, 255, | ||
684 | 128, 130, 155, 157, 160, 175, 178, 182, | ||
685 | 129, 134, 137, 142, 145, 150, 160, 166, | ||
686 | 168, 174, 176, 255, 155, 166, 175, 128, | ||
687 | 170, 172, 173, 176, 185, 158, 159, 160, | ||
688 | 255, 164, 175, 135, 138, 188, 255, 164, | ||
689 | 169, 171, 172, 173, 174, 175, 180, 181, | ||
690 | 182, 183, 184, 185, 187, 188, 189, 190, | ||
691 | 191, 165, 186, 174, 175, 154, 255, 190, | ||
692 | 128, 134, 147, 151, 157, 168, 170, 182, | ||
693 | 184, 188, 128, 129, 131, 132, 134, 255, | ||
694 | 147, 255, 190, 255, 144, 145, 136, 175, | ||
695 | 188, 255, 128, 143, 160, 175, 179, 180, | ||
696 | 141, 143, 176, 180, 182, 255, 189, 255, | ||
697 | 191, 144, 153, 161, 186, 129, 154, 166, | ||
698 | 255, 191, 255, 130, 135, 138, 143, 146, | ||
699 | 151, 154, 156, 144, 145, 146, 147, 148, | ||
700 | 150, 151, 152, 155, 157, 158, 160, 170, | ||
701 | 171, 172, 175, 161, 169, 128, 129, 130, | ||
702 | 131, 133, 135, 138, 139, 140, 141, 142, | ||
703 | 143, 144, 145, 146, 147, 148, 149, 152, | ||
704 | 156, 157, 160, 161, 162, 163, 164, 166, | ||
705 | 168, 169, 170, 171, 172, 173, 174, 176, | ||
706 | 177, 153, 155, 178, 179, 128, 139, 141, | ||
707 | 166, 168, 186, 188, 189, 191, 255, 142, | ||
708 | 143, 158, 255, 187, 255, 128, 180, 189, | ||
709 | 128, 156, 160, 255, 145, 159, 161, 255, | ||
710 | 128, 159, 176, 255, 139, 143, 187, 255, | ||
711 | 128, 157, 160, 255, 144, 132, 135, 150, | ||
712 | 255, 158, 159, 170, 175, 148, 151, 188, | ||
713 | 255, 128, 167, 176, 255, 164, 255, 183, | ||
714 | 255, 128, 149, 160, 167, 136, 188, 128, | ||
715 | 133, 138, 181, 183, 184, 191, 255, 150, | ||
716 | 159, 183, 255, 128, 158, 160, 178, 180, | ||
717 | 181, 128, 149, 160, 185, 128, 183, 190, | ||
718 | 191, 191, 128, 131, 133, 134, 140, 147, | ||
719 | 149, 151, 153, 179, 184, 186, 160, 188, | ||
720 | 128, 156, 128, 135, 137, 166, 128, 181, | ||
721 | 128, 149, 160, 178, 128, 145, 128, 178, | ||
722 | 129, 130, 131, 132, 133, 135, 136, 138, | ||
723 | 139, 140, 141, 144, 145, 146, 147, 150, | ||
724 | 151, 152, 153, 154, 155, 156, 162, 163, | ||
725 | 171, 176, 177, 178, 128, 134, 135, 165, | ||
726 | 176, 190, 144, 168, 176, 185, 128, 180, | ||
727 | 182, 191, 182, 144, 179, 155, 133, 137, | ||
728 | 141, 143, 157, 255, 190, 128, 145, 147, | ||
729 | 183, 136, 128, 134, 138, 141, 143, 157, | ||
730 | 159, 168, 176, 255, 171, 175, 186, 255, | ||
731 | 128, 131, 133, 140, 143, 144, 147, 168, | ||
732 | 170, 176, 178, 179, 181, 185, 188, 191, | ||
733 | 144, 151, 128, 132, 135, 136, 139, 141, | ||
734 | 157, 163, 166, 172, 176, 180, 128, 138, | ||
735 | 144, 153, 134, 136, 143, 154, 255, 128, | ||
736 | 181, 184, 255, 129, 151, 158, 255, 129, | ||
737 | 131, 133, 143, 154, 255, 128, 137, 128, | ||
738 | 153, 157, 171, 176, 185, 160, 255, 170, | ||
739 | 190, 192, 255, 128, 184, 128, 136, 138, | ||
740 | 182, 184, 191, 128, 144, 153, 178, 255, | ||
741 | 168, 144, 145, 183, 255, 128, 142, 145, | ||
742 | 149, 129, 141, 144, 146, 147, 148, 175, | ||
743 | 255, 132, 255, 128, 144, 129, 143, 144, | ||
744 | 153, 145, 152, 135, 255, 160, 168, 169, | ||
1380 | 171, 172, 173, 174, 188, 189, 190, 191, | 745 | 171, 172, 173, 174, 188, 189, 190, 191, |
1381 | 128, 159, 161, 167, 170, 187, 185, 191, | 746 | 161, 167, 185, 255, 128, 158, 160, 169, |
1382 | 192, 255, 128, 143, 144, 173, 174, 191, | 747 | 144, 173, 176, 180, 128, 131, 144, 153, |
1383 | 128, 131, 132, 162, 163, 183, 184, 188, | 748 | 163, 183, 189, 255, 144, 255, 133, 143, |
1384 | 189, 255, 133, 143, 145, 191, 192, 255, | 749 | 191, 255, 143, 159, 160, 128, 129, 255, |
1385 | 128, 146, 147, 159, 160, 191, 160, 128, | 750 | 159, 160, 171, 172, 255, 173, 255, 179, |
1386 | 191, 128, 129, 191, 192, 255, 159, 160, | 751 | 255, 128, 176, 177, 178, 128, 129, 171, |
1387 | 171, 128, 170, 172, 191, 192, 255, 173, | 752 | 175, 189, 255, 128, 136, 144, 153, 157, |
1388 | 191, 192, 255, 179, 191, 192, 255, 128, | 753 | 158, 133, 134, 137, 144, 145, 146, 147, |
1389 | 176, 177, 178, 129, 191, 128, 129, 130, | 754 | 148, 149, 154, 155, 156, 157, 158, 159, |
1390 | 191, 171, 175, 189, 191, 192, 255, 128, | 755 | 168, 169, 170, 150, 153, 165, 169, 173, |
1391 | 136, 137, 143, 144, 153, 154, 191, 144, | 756 | 178, 187, 255, 131, 132, 140, 169, 174, |
1392 | 145, 146, 147, 148, 149, 154, 155, 156, | 757 | 255, 130, 132, 149, 157, 173, 186, 188, |
1393 | 157, 158, 159, 128, 143, 150, 153, 160, | 758 | 160, 161, 163, 164, 167, 168, 132, 134, |
1394 | 191, 149, 157, 173, 186, 188, 160, 161, | 759 | 149, 157, 186, 139, 140, 191, 255, 134, |
1395 | 163, 164, 167, 168, 132, 134, 149, 157, | 760 | 128, 132, 138, 144, 146, 255, 166, 167, |
1396 | 186, 191, 139, 140, 192, 255, 133, 145, | ||
1397 | 128, 134, 135, 137, 138, 255, 166, 167, | ||
1398 | 129, 155, 187, 149, 181, 143, 175, 137, | 761 | 129, 155, 187, 149, 181, 143, 175, 137, |
1399 | 169, 131, 140, 191, 192, 255, 160, 163, | 762 | 169, 131, 140, 141, 192, 255, 128, 182, |
1400 | 164, 165, 184, 185, 186, 128, 159, 161, | 763 | 187, 255, 173, 180, 182, 255, 132, 155, |
1401 | 162, 166, 191, 133, 191, 192, 255, 132, | 764 | 159, 161, 175, 128, 160, 163, 164, 165, |
1402 | 160, 163, 167, 179, 184, 186, 128, 164, | 765 | 184, 185, 186, 161, 162, 128, 134, 136, |
1403 | 165, 168, 169, 187, 188, 191, 130, 135, | 766 | 152, 155, 161, 163, 164, 166, 170, 133, |
1404 | 137, 139, 144, 147, 151, 153, 155, 157, | 767 | 143, 151, 255, 139, 143, 154, 255, 164, |
1405 | 159, 163, 171, 179, 184, 189, 191, 128, | 768 | 167, 185, 187, 128, 131, 133, 159, 161, |
1406 | 140, 141, 148, 149, 160, 161, 164, 165, | 769 | 162, 169, 178, 180, 183, 130, 135, 137, |
1407 | 166, 167, 190, 138, 164, 170, 128, 155, | 770 | 139, 148, 151, 153, 155, 157, 159, 164, |
1408 | 156, 160, 161, 187, 188, 191, 128, 191, | 771 | 190, 141, 143, 145, 146, 161, 162, 167, |
1409 | 155, 156, 128, 191, 151, 191, 192, 255, | 772 | 170, 172, 178, 180, 183, 185, 188, 128, |
1410 | 156, 157, 160, 128, 191, 181, 191, 192, | 773 | 137, 139, 155, 161, 163, 165, 169, 171, |
1411 | 255, 158, 159, 186, 128, 185, 187, 191, | 774 | 187, 155, 156, 151, 255, 156, 157, 160, |
1412 | 192, 255, 162, 191, 192, 255, 160, 168, | 775 | 181, 255, 186, 187, 255, 162, 255, 160, |
1413 | 128, 159, 161, 167, 169, 191, 158, 191, | 776 | 168, 161, 167, 158, 255, 160, 132, 135, |
1414 | 192, 255, 9, 10, 13, 32, 33, 34, | 777 | 133, 134, 176, 255, 128, 191, 154, 164, |
1415 | 35, 37, 38, 46, 47, 60, 61, 62, | 778 | 168, 128, 149, 150, 191, 128, 152, 153, |
1416 | 64, 92, 95, 123, 124, 125, 126, 127, | 779 | 191, 181, 128, 159, 160, 189, 190, 191, |
1417 | 194, 195, 198, 199, 203, 204, 205, 206, | 780 | 189, 128, 131, 132, 185, 186, 191, 144, |
1418 | 207, 210, 212, 213, 214, 215, 216, 217, | 781 | 128, 151, 152, 161, 162, 176, 177, 255, |
1419 | 219, 220, 221, 222, 223, 224, 225, 226, | 782 | 169, 177, 129, 132, 141, 142, 145, 146, |
1420 | 227, 228, 233, 234, 237, 238, 239, 240, | 783 | 179, 181, 186, 188, 190, 191, 192, 255, |
1421 | 0, 39, 40, 45, 48, 57, 58, 63, | 784 | 142, 158, 128, 155, 156, 161, 162, 175, |
1422 | 65, 90, 91, 96, 97, 122, 192, 193, | 785 | 176, 177, 178, 191, 169, 177, 180, 183, |
1423 | 196, 218, 229, 236, 241, 247, 9, 32, | 786 | 128, 132, 133, 138, 139, 142, 143, 144, |
1424 | 10, 61, 10, 38, 46, 42, 47, 42, | 787 | 145, 146, 147, 185, 186, 191, 157, 128, |
788 | 152, 153, 158, 159, 177, 178, 180, 181, | ||
789 | 191, 142, 146, 169, 177, 180, 189, 128, | ||
790 | 132, 133, 185, 186, 191, 144, 185, 128, | ||
791 | 159, 160, 161, 162, 191, 169, 177, 180, | ||
792 | 189, 128, 132, 133, 140, 141, 142, 143, | ||
793 | 144, 145, 146, 147, 185, 186, 191, 158, | ||
794 | 177, 128, 155, 156, 161, 162, 191, 131, | ||
795 | 145, 155, 157, 128, 132, 133, 138, 139, | ||
796 | 141, 142, 149, 150, 152, 153, 159, 160, | ||
797 | 162, 163, 164, 165, 167, 168, 170, 171, | ||
798 | 173, 174, 185, 186, 191, 144, 128, 191, | ||
799 | 141, 145, 169, 189, 128, 132, 133, 185, | ||
800 | 186, 191, 128, 151, 152, 154, 155, 159, | ||
801 | 160, 161, 162, 191, 128, 141, 145, 169, | ||
802 | 180, 189, 129, 132, 133, 185, 186, 191, | ||
803 | 158, 128, 159, 160, 161, 162, 176, 177, | ||
804 | 178, 179, 191, 141, 145, 189, 128, 132, | ||
805 | 133, 186, 187, 191, 142, 128, 147, 148, | ||
806 | 150, 151, 158, 159, 161, 162, 185, 186, | ||
807 | 191, 178, 188, 128, 132, 133, 150, 151, | ||
808 | 153, 154, 189, 190, 191, 128, 134, 135, | ||
809 | 191, 128, 177, 129, 179, 180, 191, 128, | ||
810 | 131, 137, 141, 152, 160, 164, 166, 172, | ||
811 | 177, 189, 129, 132, 133, 134, 135, 138, | ||
812 | 139, 147, 148, 167, 168, 169, 170, 179, | ||
813 | 180, 191, 133, 128, 134, 135, 155, 156, | ||
814 | 159, 160, 191, 128, 129, 191, 136, 128, | ||
815 | 172, 173, 191, 128, 135, 136, 140, 141, | ||
816 | 191, 191, 128, 170, 171, 190, 161, 128, | ||
817 | 143, 144, 149, 150, 153, 154, 157, 158, | ||
818 | 164, 165, 166, 167, 173, 174, 176, 177, | ||
819 | 180, 181, 255, 130, 141, 143, 159, 134, | ||
820 | 187, 136, 140, 142, 143, 137, 151, 153, | ||
821 | 142, 143, 158, 159, 137, 177, 191, 142, | ||
822 | 143, 182, 183, 192, 255, 129, 151, 128, | ||
823 | 133, 134, 135, 136, 255, 145, 150, 151, | ||
824 | 155, 191, 192, 255, 128, 143, 144, 159, | ||
825 | 160, 255, 182, 183, 190, 191, 192, 255, | ||
826 | 128, 129, 255, 173, 174, 192, 255, 128, | ||
827 | 129, 154, 155, 159, 160, 255, 171, 173, | ||
828 | 185, 191, 192, 255, 141, 128, 145, 146, | ||
829 | 159, 160, 177, 178, 191, 173, 128, 145, | ||
830 | 146, 159, 160, 176, 177, 191, 128, 179, | ||
831 | 180, 191, 151, 156, 128, 191, 128, 159, | ||
832 | 160, 255, 184, 191, 192, 255, 169, 128, | ||
833 | 170, 171, 175, 176, 255, 182, 191, 192, | ||
834 | 255, 128, 158, 159, 191, 128, 143, 144, | ||
835 | 173, 174, 175, 176, 180, 181, 191, 128, | ||
836 | 171, 172, 175, 176, 255, 138, 191, 192, | ||
837 | 255, 128, 150, 151, 159, 160, 255, 149, | ||
838 | 191, 192, 255, 167, 128, 191, 128, 132, | ||
839 | 133, 179, 180, 191, 128, 132, 133, 139, | ||
840 | 140, 191, 128, 130, 131, 160, 161, 173, | ||
841 | 174, 175, 176, 185, 186, 255, 166, 191, | ||
842 | 192, 255, 128, 163, 164, 191, 128, 140, | ||
843 | 141, 143, 144, 153, 154, 189, 190, 191, | ||
844 | 128, 136, 137, 191, 173, 128, 168, 169, | ||
845 | 177, 178, 180, 181, 182, 183, 191, 0, | ||
846 | 127, 192, 255, 150, 151, 158, 159, 152, | ||
847 | 154, 156, 158, 134, 135, 142, 143, 190, | ||
848 | 191, 192, 255, 181, 189, 191, 128, 190, | ||
849 | 133, 181, 128, 129, 130, 140, 141, 143, | ||
850 | 144, 147, 148, 149, 150, 155, 156, 159, | ||
851 | 160, 172, 173, 177, 178, 188, 189, 191, | ||
852 | 177, 191, 128, 190, 128, 143, 144, 156, | ||
853 | 157, 191, 130, 135, 148, 164, 166, 168, | ||
854 | 128, 137, 138, 149, 150, 151, 152, 157, | ||
855 | 158, 169, 170, 185, 186, 187, 188, 191, | ||
856 | 142, 128, 132, 133, 137, 138, 159, 160, | ||
857 | 255, 137, 191, 192, 255, 175, 128, 255, | ||
858 | 159, 165, 170, 175, 177, 180, 191, 192, | ||
859 | 255, 166, 173, 128, 167, 168, 175, 176, | ||
860 | 255, 168, 174, 176, 191, 192, 255, 167, | ||
861 | 175, 183, 191, 128, 150, 151, 159, 160, | ||
862 | 190, 135, 143, 151, 128, 158, 159, 191, | ||
863 | 128, 132, 133, 135, 136, 160, 161, 169, | ||
864 | 170, 176, 177, 181, 182, 183, 184, 188, | ||
865 | 189, 191, 160, 151, 154, 187, 192, 255, | ||
866 | 128, 132, 133, 173, 174, 176, 177, 255, | ||
867 | 143, 159, 187, 191, 192, 255, 128, 175, | ||
868 | 176, 191, 150, 191, 192, 255, 141, 191, | ||
869 | 192, 255, 128, 143, 144, 189, 190, 191, | ||
870 | 141, 143, 160, 169, 172, 191, 192, 255, | ||
871 | 191, 128, 174, 175, 190, 128, 157, 158, | ||
872 | 159, 160, 255, 176, 191, 192, 255, 128, | ||
873 | 150, 151, 159, 160, 161, 162, 255, 175, | ||
874 | 137, 138, 184, 191, 192, 255, 128, 182, | ||
875 | 183, 255, 130, 134, 139, 163, 191, 192, | ||
876 | 255, 128, 129, 130, 179, 180, 191, 187, | ||
877 | 189, 128, 177, 178, 183, 184, 191, 128, | ||
878 | 137, 138, 165, 166, 175, 176, 255, 135, | ||
879 | 159, 189, 191, 192, 255, 128, 131, 132, | ||
880 | 178, 179, 191, 143, 165, 191, 128, 159, | ||
881 | 160, 175, 176, 185, 186, 190, 128, 168, | ||
882 | 169, 191, 131, 186, 128, 139, 140, 159, | ||
883 | 160, 182, 183, 189, 190, 255, 176, 178, | ||
884 | 180, 183, 184, 190, 191, 192, 255, 129, | ||
885 | 128, 130, 131, 154, 155, 157, 158, 159, | ||
886 | 160, 170, 171, 177, 178, 180, 181, 191, | ||
887 | 128, 167, 175, 129, 134, 135, 136, 137, | ||
888 | 142, 143, 144, 145, 150, 151, 159, 160, | ||
889 | 255, 155, 166, 175, 128, 162, 163, 191, | ||
890 | 164, 175, 135, 138, 188, 191, 192, 255, | ||
891 | 174, 175, 154, 191, 192, 255, 157, 169, | ||
892 | 183, 189, 191, 128, 134, 135, 146, 147, | ||
893 | 151, 152, 158, 159, 190, 130, 133, 128, | ||
894 | 255, 178, 191, 192, 255, 128, 146, 147, | ||
895 | 255, 190, 191, 192, 255, 128, 143, 144, | ||
896 | 255, 144, 145, 136, 175, 188, 191, 192, | ||
897 | 255, 181, 128, 175, 176, 255, 189, 191, | ||
898 | 192, 255, 128, 160, 161, 186, 187, 191, | ||
899 | 128, 129, 154, 155, 165, 166, 255, 191, | ||
900 | 192, 255, 128, 129, 130, 135, 136, 137, | ||
901 | 138, 143, 144, 145, 146, 151, 152, 153, | ||
902 | 154, 156, 157, 191, 128, 191, 128, 129, | ||
903 | 130, 131, 133, 138, 139, 140, 141, 142, | ||
904 | 143, 144, 145, 146, 147, 148, 149, 152, | ||
905 | 156, 157, 160, 161, 162, 163, 164, 166, | ||
906 | 168, 169, 170, 171, 172, 173, 174, 176, | ||
907 | 177, 132, 151, 153, 155, 158, 175, 178, | ||
908 | 179, 180, 191, 140, 167, 187, 190, 128, | ||
909 | 255, 142, 143, 158, 191, 192, 255, 187, | ||
910 | 191, 192, 255, 128, 180, 181, 191, 128, | ||
911 | 156, 157, 159, 160, 255, 145, 191, 192, | ||
912 | 255, 128, 159, 160, 175, 176, 255, 139, | ||
913 | 143, 182, 191, 192, 255, 144, 132, 135, | ||
914 | 150, 191, 192, 255, 158, 175, 148, 151, | ||
915 | 188, 191, 192, 255, 128, 167, 168, 175, | ||
916 | 176, 255, 164, 191, 192, 255, 183, 191, | ||
917 | 192, 255, 128, 149, 150, 159, 160, 167, | ||
918 | 168, 191, 136, 182, 188, 128, 133, 134, | ||
919 | 137, 138, 184, 185, 190, 191, 255, 150, | ||
920 | 159, 183, 191, 192, 255, 179, 128, 159, | ||
921 | 160, 181, 182, 191, 128, 149, 150, 159, | ||
922 | 160, 185, 186, 191, 128, 183, 184, 189, | ||
923 | 190, 191, 128, 148, 152, 129, 143, 144, | ||
924 | 179, 180, 191, 128, 159, 160, 188, 189, | ||
925 | 191, 128, 156, 157, 191, 136, 128, 164, | ||
926 | 165, 191, 128, 181, 182, 191, 128, 149, | ||
927 | 150, 159, 160, 178, 179, 191, 128, 145, | ||
928 | 146, 191, 128, 178, 179, 191, 128, 130, | ||
929 | 131, 132, 133, 134, 135, 136, 138, 139, | ||
930 | 140, 141, 144, 145, 146, 147, 150, 151, | ||
931 | 152, 153, 154, 156, 162, 163, 171, 176, | ||
932 | 177, 178, 129, 191, 128, 130, 131, 183, | ||
933 | 184, 191, 128, 130, 131, 175, 176, 191, | ||
934 | 128, 143, 144, 168, 169, 191, 128, 130, | ||
935 | 131, 166, 167, 191, 182, 128, 143, 144, | ||
936 | 178, 179, 191, 128, 130, 131, 178, 179, | ||
937 | 191, 128, 154, 156, 129, 132, 133, 191, | ||
938 | 146, 128, 171, 172, 191, 135, 137, 142, | ||
939 | 158, 128, 168, 169, 175, 176, 255, 159, | ||
940 | 191, 192, 255, 144, 128, 156, 157, 161, | ||
941 | 162, 191, 128, 134, 135, 138, 139, 191, | ||
942 | 128, 175, 176, 191, 134, 128, 131, 132, | ||
943 | 135, 136, 191, 128, 174, 175, 191, 128, | ||
944 | 151, 152, 155, 156, 191, 132, 128, 191, | ||
945 | 128, 170, 171, 191, 128, 153, 154, 191, | ||
946 | 160, 190, 192, 255, 128, 184, 185, 191, | ||
947 | 137, 128, 174, 175, 191, 128, 129, 177, | ||
948 | 178, 255, 144, 191, 192, 255, 128, 142, | ||
949 | 143, 144, 145, 146, 149, 129, 148, 150, | ||
950 | 191, 175, 191, 192, 255, 132, 191, 192, | ||
951 | 255, 128, 144, 129, 143, 145, 191, 144, | ||
952 | 153, 128, 143, 145, 152, 154, 191, 135, | ||
953 | 191, 192, 255, 160, 168, 169, 171, 172, | ||
954 | 173, 174, 188, 189, 190, 191, 128, 159, | ||
955 | 161, 167, 170, 187, 185, 191, 192, 255, | ||
956 | 128, 143, 144, 173, 174, 191, 128, 131, | ||
957 | 132, 162, 163, 183, 184, 188, 189, 255, | ||
958 | 133, 143, 145, 191, 192, 255, 128, 146, | ||
959 | 147, 159, 160, 191, 160, 128, 191, 128, | ||
960 | 129, 191, 192, 255, 159, 160, 171, 128, | ||
961 | 170, 172, 191, 192, 255, 173, 191, 192, | ||
962 | 255, 179, 191, 192, 255, 128, 176, 177, | ||
963 | 178, 129, 191, 128, 129, 130, 191, 171, | ||
964 | 175, 189, 191, 192, 255, 128, 136, 137, | ||
965 | 143, 144, 153, 154, 191, 144, 145, 146, | ||
966 | 147, 148, 149, 154, 155, 156, 157, 158, | ||
967 | 159, 128, 143, 150, 153, 160, 191, 149, | ||
968 | 157, 173, 186, 188, 160, 161, 163, 164, | ||
969 | 167, 168, 132, 134, 149, 157, 186, 191, | ||
970 | 139, 140, 192, 255, 133, 145, 128, 134, | ||
971 | 135, 137, 138, 255, 166, 167, 129, 155, | ||
972 | 187, 149, 181, 143, 175, 137, 169, 131, | ||
973 | 140, 191, 192, 255, 160, 163, 164, 165, | ||
974 | 184, 185, 186, 128, 159, 161, 162, 166, | ||
975 | 191, 133, 191, 192, 255, 132, 160, 163, | ||
976 | 167, 179, 184, 186, 128, 164, 165, 168, | ||
977 | 169, 187, 188, 191, 130, 135, 137, 139, | ||
978 | 144, 147, 151, 153, 155, 157, 159, 163, | ||
979 | 171, 179, 184, 189, 191, 128, 140, 141, | ||
980 | 148, 149, 160, 161, 164, 165, 166, 167, | ||
981 | 190, 138, 164, 170, 128, 155, 156, 160, | ||
982 | 161, 187, 188, 191, 128, 191, 155, 156, | ||
983 | 128, 191, 151, 191, 192, 255, 156, 157, | ||
984 | 160, 128, 191, 181, 191, 192, 255, 158, | ||
985 | 159, 186, 128, 185, 187, 191, 192, 255, | ||
986 | 162, 191, 192, 255, 160, 168, 128, 159, | ||
987 | 161, 167, 169, 191, 158, 191, 192, 255, | ||
988 | 10, 13, 128, 191, 192, 223, 224, 239, | ||
989 | 240, 247, 248, 255, 128, 191, 128, 191, | ||
990 | 128, 191, 128, 191, 128, 191, 10, 128, | ||
991 | 191, 128, 191, 128, 191, 36, 123, 37, | ||
992 | 123, 10, 128, 191, 128, 191, 128, 191, | ||
993 | 36, 123, 37, 123, 170, 181, 183, 186, | ||
994 | 128, 150, 152, 182, 184, 255, 192, 255, | ||
995 | 128, 255, 173, 130, 133, 146, 159, 165, | ||
996 | 171, 175, 255, 181, 190, 184, 185, 192, | ||
997 | 255, 140, 134, 138, 142, 161, 163, 255, | ||
998 | 182, 130, 136, 137, 176, 151, 152, 154, | ||
999 | 160, 190, 136, 144, 192, 255, 135, 129, | ||
1000 | 130, 132, 133, 144, 170, 176, 178, 144, | ||
1001 | 154, 160, 191, 128, 169, 174, 255, 148, | ||
1002 | 169, 157, 158, 189, 190, 192, 255, 144, | ||
1003 | 255, 139, 140, 178, 255, 186, 128, 181, | ||
1004 | 160, 161, 162, 163, 164, 165, 166, 167, | ||
1005 | 168, 169, 170, 171, 172, 173, 174, 175, | ||
1006 | 176, 177, 178, 179, 180, 181, 182, 183, | ||
1007 | 184, 185, 186, 187, 188, 189, 190, 191, | ||
1008 | 128, 173, 128, 155, 160, 180, 182, 189, | ||
1009 | 148, 161, 163, 255, 176, 164, 165, 132, | ||
1010 | 169, 177, 141, 142, 145, 146, 179, 181, | ||
1011 | 186, 187, 158, 133, 134, 137, 138, 143, | ||
1012 | 150, 152, 155, 164, 165, 178, 255, 188, | ||
1013 | 129, 131, 133, 138, 143, 144, 147, 168, | ||
1014 | 170, 176, 178, 179, 181, 182, 184, 185, | ||
1015 | 190, 255, 157, 131, 134, 137, 138, 142, | ||
1016 | 144, 146, 152, 159, 165, 182, 255, 129, | ||
1017 | 131, 133, 141, 143, 145, 147, 168, 170, | ||
1018 | 176, 178, 179, 181, 185, 188, 255, 134, | ||
1019 | 138, 142, 143, 145, 159, 164, 165, 176, | ||
1020 | 184, 186, 255, 129, 131, 133, 140, 143, | ||
1021 | 144, 147, 168, 170, 176, 178, 179, 181, | ||
1022 | 185, 188, 191, 177, 128, 132, 135, 136, | ||
1023 | 139, 141, 150, 151, 156, 157, 159, 163, | ||
1024 | 166, 175, 156, 130, 131, 133, 138, 142, | ||
1025 | 144, 146, 149, 153, 154, 158, 159, 163, | ||
1026 | 164, 168, 170, 174, 185, 190, 191, 144, | ||
1027 | 151, 128, 130, 134, 136, 138, 141, 166, | ||
1028 | 175, 128, 131, 133, 140, 142, 144, 146, | ||
1029 | 168, 170, 185, 189, 255, 133, 137, 151, | ||
1030 | 142, 148, 155, 159, 164, 165, 176, 255, | ||
1031 | 128, 131, 133, 140, 142, 144, 146, 168, | ||
1032 | 170, 179, 181, 185, 188, 191, 158, 128, | ||
1033 | 132, 134, 136, 138, 141, 149, 150, 160, | ||
1034 | 163, 166, 175, 177, 178, 129, 131, 133, | ||
1035 | 140, 142, 144, 146, 186, 189, 255, 133, | ||
1036 | 137, 143, 147, 152, 158, 164, 165, 176, | ||
1037 | 185, 192, 255, 189, 130, 131, 133, 150, | ||
1038 | 154, 177, 179, 187, 138, 150, 128, 134, | ||
1039 | 143, 148, 152, 159, 166, 175, 178, 179, | ||
1040 | 129, 186, 128, 142, 144, 153, 132, 138, | ||
1041 | 141, 165, 167, 129, 130, 135, 136, 148, | ||
1042 | 151, 153, 159, 161, 163, 170, 171, 173, | ||
1043 | 185, 187, 189, 134, 128, 132, 136, 141, | ||
1044 | 144, 153, 156, 159, 128, 181, 183, 185, | ||
1045 | 152, 153, 160, 169, 190, 191, 128, 135, | ||
1046 | 137, 172, 177, 191, 128, 132, 134, 151, | ||
1047 | 153, 188, 134, 128, 129, 130, 131, 137, | ||
1048 | 138, 139, 140, 141, 142, 143, 144, 153, | ||
1049 | 154, 155, 156, 157, 158, 159, 160, 161, | ||
1050 | 162, 163, 164, 165, 166, 167, 168, 169, | ||
1051 | 170, 173, 175, 176, 177, 178, 179, 181, | ||
1052 | 182, 183, 188, 189, 190, 191, 132, 152, | ||
1053 | 172, 184, 185, 187, 128, 191, 128, 137, | ||
1054 | 144, 255, 158, 159, 134, 187, 136, 140, | ||
1055 | 142, 143, 137, 151, 153, 142, 143, 158, | ||
1056 | 159, 137, 177, 142, 143, 182, 183, 191, | ||
1057 | 255, 128, 130, 133, 136, 150, 152, 255, | ||
1058 | 145, 150, 151, 155, 156, 160, 168, 178, | ||
1059 | 255, 128, 143, 160, 255, 182, 183, 190, | ||
1060 | 255, 129, 255, 173, 174, 192, 255, 129, | ||
1061 | 154, 160, 255, 171, 173, 185, 255, 128, | ||
1062 | 140, 142, 148, 160, 180, 128, 147, 160, | ||
1063 | 172, 174, 176, 178, 179, 148, 150, 152, | ||
1064 | 155, 158, 159, 170, 255, 139, 141, 144, | ||
1065 | 153, 160, 255, 184, 255, 128, 170, 176, | ||
1066 | 255, 182, 255, 128, 158, 160, 171, 176, | ||
1067 | 187, 134, 173, 176, 180, 128, 171, 176, | ||
1068 | 255, 138, 143, 155, 255, 128, 155, 160, | ||
1069 | 255, 159, 189, 190, 192, 255, 167, 128, | ||
1070 | 137, 144, 153, 176, 189, 140, 143, 154, | ||
1071 | 170, 180, 255, 180, 255, 128, 183, 128, | ||
1072 | 137, 141, 189, 128, 136, 144, 146, 148, | ||
1073 | 182, 184, 185, 128, 181, 187, 191, 150, | ||
1074 | 151, 158, 159, 152, 154, 156, 158, 134, | ||
1075 | 135, 142, 143, 190, 255, 190, 128, 180, | ||
1076 | 182, 188, 130, 132, 134, 140, 144, 147, | ||
1077 | 150, 155, 160, 172, 178, 180, 182, 188, | ||
1078 | 128, 129, 130, 131, 132, 133, 134, 176, | ||
1079 | 177, 178, 179, 180, 181, 182, 183, 191, | ||
1080 | 255, 129, 147, 149, 176, 178, 190, 192, | ||
1081 | 255, 144, 156, 161, 144, 156, 165, 176, | ||
1082 | 130, 135, 149, 164, 166, 168, 138, 147, | ||
1083 | 152, 157, 170, 185, 188, 191, 142, 133, | ||
1084 | 137, 160, 255, 137, 255, 128, 174, 176, | ||
1085 | 255, 159, 165, 170, 180, 255, 167, 173, | ||
1086 | 128, 165, 176, 255, 168, 174, 176, 190, | ||
1087 | 192, 255, 128, 150, 160, 166, 168, 174, | ||
1088 | 176, 182, 184, 190, 128, 134, 136, 142, | ||
1089 | 144, 150, 152, 158, 160, 191, 128, 129, | ||
1090 | 130, 131, 132, 133, 134, 135, 144, 145, | ||
1091 | 255, 133, 135, 161, 175, 177, 181, 184, | ||
1092 | 188, 160, 151, 152, 187, 192, 255, 133, | ||
1093 | 173, 177, 255, 143, 159, 187, 255, 176, | ||
1094 | 191, 182, 183, 184, 191, 192, 255, 150, | ||
1095 | 255, 128, 146, 147, 148, 152, 153, 154, | ||
1096 | 155, 156, 158, 159, 160, 161, 162, 163, | ||
1097 | 164, 165, 166, 167, 168, 169, 170, 171, | ||
1098 | 172, 173, 174, 175, 176, 129, 255, 141, | ||
1099 | 255, 144, 189, 141, 143, 172, 255, 191, | ||
1100 | 128, 175, 180, 189, 151, 159, 162, 255, | ||
1101 | 175, 137, 138, 184, 255, 183, 255, 168, | ||
1102 | 255, 128, 179, 188, 134, 143, 154, 159, | ||
1103 | 184, 186, 190, 255, 128, 173, 176, 255, | ||
1104 | 148, 159, 189, 255, 129, 142, 154, 159, | ||
1105 | 191, 255, 128, 182, 128, 141, 144, 153, | ||
1106 | 160, 182, 186, 255, 128, 130, 155, 157, | ||
1107 | 160, 175, 178, 182, 129, 134, 137, 142, | ||
1108 | 145, 150, 160, 166, 168, 174, 176, 255, | ||
1109 | 155, 166, 175, 128, 170, 172, 173, 176, | ||
1110 | 185, 158, 159, 160, 255, 164, 175, 135, | ||
1111 | 138, 188, 255, 164, 169, 171, 172, 173, | ||
1112 | 174, 175, 180, 181, 182, 183, 184, 185, | ||
1113 | 187, 188, 189, 190, 191, 165, 186, 174, | ||
1114 | 175, 154, 255, 190, 128, 134, 147, 151, | ||
1115 | 157, 168, 170, 182, 184, 188, 128, 129, | ||
1116 | 131, 132, 134, 255, 147, 255, 190, 255, | ||
1117 | 144, 145, 136, 175, 188, 255, 128, 143, | ||
1118 | 160, 175, 179, 180, 141, 143, 176, 180, | ||
1119 | 182, 255, 189, 255, 191, 144, 153, 161, | ||
1120 | 186, 129, 154, 166, 255, 191, 255, 130, | ||
1121 | 135, 138, 143, 146, 151, 154, 156, 144, | ||
1122 | 145, 146, 147, 148, 150, 151, 152, 155, | ||
1123 | 157, 158, 160, 170, 171, 172, 175, 161, | ||
1124 | 169, 128, 129, 130, 131, 133, 135, 138, | ||
1125 | 139, 140, 141, 142, 143, 144, 145, 146, | ||
1126 | 147, 148, 149, 152, 156, 157, 160, 161, | ||
1127 | 162, 163, 164, 166, 168, 169, 170, 171, | ||
1128 | 172, 173, 174, 176, 177, 153, 155, 178, | ||
1129 | 179, 128, 139, 141, 166, 168, 186, 188, | ||
1130 | 189, 191, 255, 142, 143, 158, 255, 187, | ||
1131 | 255, 128, 180, 189, 128, 156, 160, 255, | ||
1132 | 145, 159, 161, 255, 128, 159, 176, 255, | ||
1133 | 139, 143, 187, 255, 128, 157, 160, 255, | ||
1134 | 144, 132, 135, 150, 255, 158, 159, 170, | ||
1135 | 175, 148, 151, 188, 255, 128, 167, 176, | ||
1136 | 255, 164, 255, 183, 255, 128, 149, 160, | ||
1137 | 167, 136, 188, 128, 133, 138, 181, 183, | ||
1138 | 184, 191, 255, 150, 159, 183, 255, 128, | ||
1139 | 158, 160, 178, 180, 181, 128, 149, 160, | ||
1140 | 185, 128, 183, 190, 191, 191, 128, 131, | ||
1141 | 133, 134, 140, 147, 149, 151, 153, 179, | ||
1142 | 184, 186, 160, 188, 128, 156, 128, 135, | ||
1143 | 137, 166, 128, 181, 128, 149, 160, 178, | ||
1144 | 128, 145, 128, 178, 129, 130, 131, 132, | ||
1145 | 133, 135, 136, 138, 139, 140, 141, 144, | ||
1146 | 145, 146, 147, 150, 151, 152, 153, 154, | ||
1147 | 155, 156, 162, 163, 171, 176, 177, 178, | ||
1148 | 128, 134, 135, 165, 176, 190, 144, 168, | ||
1149 | 176, 185, 128, 180, 182, 191, 182, 144, | ||
1150 | 179, 155, 133, 137, 141, 143, 157, 255, | ||
1151 | 190, 128, 145, 147, 183, 136, 128, 134, | ||
1152 | 138, 141, 143, 157, 159, 168, 176, 255, | ||
1153 | 171, 175, 186, 255, 128, 131, 133, 140, | ||
1154 | 143, 144, 147, 168, 170, 176, 178, 179, | ||
1155 | 181, 185, 188, 191, 144, 151, 128, 132, | ||
1156 | 135, 136, 139, 141, 157, 163, 166, 172, | ||
1157 | 176, 180, 128, 138, 144, 153, 134, 136, | ||
1158 | 143, 154, 255, 128, 181, 184, 255, 129, | ||
1159 | 151, 158, 255, 129, 131, 133, 143, 154, | ||
1160 | 255, 128, 137, 128, 153, 157, 171, 176, | ||
1161 | 185, 160, 255, 170, 190, 192, 255, 128, | ||
1162 | 184, 128, 136, 138, 182, 184, 191, 128, | ||
1163 | 144, 153, 178, 255, 168, 144, 145, 183, | ||
1164 | 255, 128, 142, 145, 149, 129, 141, 144, | ||
1165 | 146, 147, 148, 175, 255, 132, 255, 128, | ||
1166 | 144, 129, 143, 144, 153, 145, 152, 135, | ||
1167 | 255, 160, 168, 169, 171, 172, 173, 174, | ||
1168 | 188, 189, 190, 191, 161, 167, 185, 255, | ||
1169 | 128, 158, 160, 169, 144, 173, 176, 180, | ||
1170 | 128, 131, 144, 153, 163, 183, 189, 255, | ||
1171 | 144, 255, 133, 143, 191, 255, 143, 159, | ||
1172 | 160, 128, 129, 255, 159, 160, 171, 172, | ||
1173 | 255, 173, 255, 179, 255, 128, 176, 177, | ||
1174 | 178, 128, 129, 171, 175, 189, 255, 128, | ||
1175 | 136, 144, 153, 157, 158, 133, 134, 137, | ||
1176 | 144, 145, 146, 147, 148, 149, 154, 155, | ||
1177 | 156, 157, 158, 159, 168, 169, 170, 150, | ||
1178 | 153, 165, 169, 173, 178, 187, 255, 131, | ||
1179 | 132, 140, 169, 174, 255, 130, 132, 149, | ||
1180 | 157, 173, 186, 188, 160, 161, 163, 164, | ||
1181 | 167, 168, 132, 134, 149, 157, 186, 139, | ||
1182 | 140, 191, 255, 134, 128, 132, 138, 144, | ||
1183 | 146, 255, 166, 167, 129, 155, 187, 149, | ||
1184 | 181, 143, 175, 137, 169, 131, 140, 141, | ||
1185 | 192, 255, 128, 182, 187, 255, 173, 180, | ||
1186 | 182, 255, 132, 155, 159, 161, 175, 128, | ||
1187 | 160, 163, 164, 165, 184, 185, 186, 161, | ||
1188 | 162, 128, 134, 136, 152, 155, 161, 163, | ||
1189 | 164, 166, 170, 133, 143, 151, 255, 139, | ||
1190 | 143, 154, 255, 164, 167, 185, 187, 128, | ||
1191 | 131, 133, 159, 161, 162, 169, 178, 180, | ||
1192 | 183, 130, 135, 137, 139, 148, 151, 153, | ||
1193 | 155, 157, 159, 164, 190, 141, 143, 145, | ||
1194 | 146, 161, 162, 167, 170, 172, 178, 180, | ||
1195 | 183, 185, 188, 128, 137, 139, 155, 161, | ||
1196 | 163, 165, 169, 171, 187, 155, 156, 151, | ||
1197 | 255, 156, 157, 160, 181, 255, 186, 187, | ||
1198 | 255, 162, 255, 160, 168, 161, 167, 158, | ||
1199 | 255, 160, 132, 135, 133, 134, 176, 255, | ||
1200 | 128, 191, 154, 164, 168, 128, 149, 150, | ||
1201 | 191, 128, 152, 153, 191, 181, 128, 159, | ||
1202 | 160, 189, 190, 191, 189, 128, 131, 132, | ||
1203 | 185, 186, 191, 144, 128, 151, 152, 161, | ||
1204 | 162, 176, 177, 255, 169, 177, 129, 132, | ||
1205 | 141, 142, 145, 146, 179, 181, 186, 188, | ||
1206 | 190, 191, 192, 255, 142, 158, 128, 155, | ||
1207 | 156, 161, 162, 175, 176, 177, 178, 191, | ||
1208 | 169, 177, 180, 183, 128, 132, 133, 138, | ||
1209 | 139, 142, 143, 144, 145, 146, 147, 185, | ||
1210 | 186, 191, 157, 128, 152, 153, 158, 159, | ||
1211 | 177, 178, 180, 181, 191, 142, 146, 169, | ||
1212 | 177, 180, 189, 128, 132, 133, 185, 186, | ||
1213 | 191, 144, 185, 128, 159, 160, 161, 162, | ||
1214 | 191, 169, 177, 180, 189, 128, 132, 133, | ||
1215 | 140, 141, 142, 143, 144, 145, 146, 147, | ||
1216 | 185, 186, 191, 158, 177, 128, 155, 156, | ||
1217 | 161, 162, 191, 131, 145, 155, 157, 128, | ||
1218 | 132, 133, 138, 139, 141, 142, 149, 150, | ||
1219 | 152, 153, 159, 160, 162, 163, 164, 165, | ||
1220 | 167, 168, 170, 171, 173, 174, 185, 186, | ||
1221 | 191, 144, 128, 191, 141, 145, 169, 189, | ||
1222 | 128, 132, 133, 185, 186, 191, 128, 151, | ||
1223 | 152, 154, 155, 159, 160, 161, 162, 191, | ||
1224 | 128, 141, 145, 169, 180, 189, 129, 132, | ||
1225 | 133, 185, 186, 191, 158, 128, 159, 160, | ||
1226 | 161, 162, 176, 177, 178, 179, 191, 141, | ||
1227 | 145, 189, 128, 132, 133, 186, 187, 191, | ||
1228 | 142, 128, 147, 148, 150, 151, 158, 159, | ||
1229 | 161, 162, 185, 186, 191, 178, 188, 128, | ||
1230 | 132, 133, 150, 151, 153, 154, 189, 190, | ||
1231 | 191, 128, 134, 135, 191, 128, 177, 129, | ||
1232 | 179, 180, 191, 128, 131, 137, 141, 152, | ||
1233 | 160, 164, 166, 172, 177, 189, 129, 132, | ||
1234 | 133, 134, 135, 138, 139, 147, 148, 167, | ||
1235 | 168, 169, 170, 179, 180, 191, 133, 128, | ||
1236 | 134, 135, 155, 156, 159, 160, 191, 128, | ||
1237 | 129, 191, 136, 128, 172, 173, 191, 128, | ||
1238 | 135, 136, 140, 141, 191, 191, 128, 170, | ||
1239 | 171, 190, 161, 128, 143, 144, 149, 150, | ||
1240 | 153, 154, 157, 158, 164, 165, 166, 167, | ||
1241 | 173, 174, 176, 177, 180, 181, 255, 130, | ||
1242 | 141, 143, 159, 134, 187, 136, 140, 142, | ||
1243 | 143, 137, 151, 153, 142, 143, 158, 159, | ||
1244 | 137, 177, 191, 142, 143, 182, 183, 192, | ||
1245 | 255, 129, 151, 128, 133, 134, 135, 136, | ||
1246 | 255, 145, 150, 151, 155, 191, 192, 255, | ||
1247 | 128, 143, 144, 159, 160, 255, 182, 183, | ||
1248 | 190, 191, 192, 255, 128, 129, 255, 173, | ||
1249 | 174, 192, 255, 128, 129, 154, 155, 159, | ||
1250 | 160, 255, 171, 173, 185, 191, 192, 255, | ||
1251 | 141, 128, 145, 146, 159, 160, 177, 178, | ||
1252 | 191, 173, 128, 145, 146, 159, 160, 176, | ||
1253 | 177, 191, 128, 179, 180, 191, 151, 156, | ||
1254 | 128, 191, 128, 159, 160, 255, 184, 191, | ||
1255 | 192, 255, 169, 128, 170, 171, 175, 176, | ||
1256 | 255, 182, 191, 192, 255, 128, 158, 159, | ||
1257 | 191, 128, 143, 144, 173, 174, 175, 176, | ||
1258 | 180, 181, 191, 128, 171, 172, 175, 176, | ||
1259 | 255, 138, 191, 192, 255, 128, 150, 151, | ||
1260 | 159, 160, 255, 149, 191, 192, 255, 167, | ||
1261 | 128, 191, 128, 132, 133, 179, 180, 191, | ||
1262 | 128, 132, 133, 139, 140, 191, 128, 130, | ||
1263 | 131, 160, 161, 173, 174, 175, 176, 185, | ||
1264 | 186, 255, 166, 191, 192, 255, 128, 163, | ||
1265 | 164, 191, 128, 140, 141, 143, 144, 153, | ||
1266 | 154, 189, 190, 191, 128, 136, 137, 191, | ||
1267 | 173, 128, 168, 169, 177, 178, 180, 181, | ||
1268 | 182, 183, 191, 0, 127, 192, 255, 150, | ||
1269 | 151, 158, 159, 152, 154, 156, 158, 134, | ||
1270 | 135, 142, 143, 190, 191, 192, 255, 181, | ||
1271 | 189, 191, 128, 190, 133, 181, 128, 129, | ||
1272 | 130, 140, 141, 143, 144, 147, 148, 149, | ||
1273 | 150, 155, 156, 159, 160, 172, 173, 177, | ||
1274 | 178, 188, 189, 191, 177, 191, 128, 190, | ||
1275 | 128, 143, 144, 156, 157, 191, 130, 135, | ||
1276 | 148, 164, 166, 168, 128, 137, 138, 149, | ||
1277 | 150, 151, 152, 157, 158, 169, 170, 185, | ||
1278 | 186, 187, 188, 191, 142, 128, 132, 133, | ||
1279 | 137, 138, 159, 160, 255, 137, 191, 192, | ||
1280 | 255, 175, 128, 255, 159, 165, 170, 175, | ||
1281 | 177, 180, 191, 192, 255, 166, 173, 128, | ||
1282 | 167, 168, 175, 176, 255, 168, 174, 176, | ||
1283 | 191, 192, 255, 167, 175, 183, 191, 128, | ||
1284 | 150, 151, 159, 160, 190, 135, 143, 151, | ||
1285 | 128, 158, 159, 191, 128, 132, 133, 135, | ||
1286 | 136, 160, 161, 169, 170, 176, 177, 181, | ||
1287 | 182, 183, 184, 188, 189, 191, 160, 151, | ||
1288 | 154, 187, 192, 255, 128, 132, 133, 173, | ||
1289 | 174, 176, 177, 255, 143, 159, 187, 191, | ||
1290 | 192, 255, 128, 175, 176, 191, 150, 191, | ||
1291 | 192, 255, 141, 191, 192, 255, 128, 143, | ||
1292 | 144, 189, 190, 191, 141, 143, 160, 169, | ||
1293 | 172, 191, 192, 255, 191, 128, 174, 175, | ||
1294 | 190, 128, 157, 158, 159, 160, 255, 176, | ||
1295 | 191, 192, 255, 128, 150, 151, 159, 160, | ||
1296 | 161, 162, 255, 175, 137, 138, 184, 191, | ||
1297 | 192, 255, 128, 182, 183, 255, 130, 134, | ||
1298 | 139, 163, 191, 192, 255, 128, 129, 130, | ||
1299 | 179, 180, 191, 187, 189, 128, 177, 178, | ||
1300 | 183, 184, 191, 128, 137, 138, 165, 166, | ||
1301 | 175, 176, 255, 135, 159, 189, 191, 192, | ||
1302 | 255, 128, 131, 132, 178, 179, 191, 143, | ||
1303 | 165, 191, 128, 159, 160, 175, 176, 185, | ||
1304 | 186, 190, 128, 168, 169, 191, 131, 186, | ||
1305 | 128, 139, 140, 159, 160, 182, 183, 189, | ||
1306 | 190, 255, 176, 178, 180, 183, 184, 190, | ||
1307 | 191, 192, 255, 129, 128, 130, 131, 154, | ||
1308 | 155, 157, 158, 159, 160, 170, 171, 177, | ||
1309 | 178, 180, 181, 191, 128, 167, 175, 129, | ||
1310 | 134, 135, 136, 137, 142, 143, 144, 145, | ||
1311 | 150, 151, 159, 160, 255, 155, 166, 175, | ||
1312 | 128, 162, 163, 191, 164, 175, 135, 138, | ||
1313 | 188, 191, 192, 255, 174, 175, 154, 191, | ||
1314 | 192, 255, 157, 169, 183, 189, 191, 128, | ||
1315 | 134, 135, 146, 147, 151, 152, 158, 159, | ||
1316 | 190, 130, 133, 128, 255, 178, 191, 192, | ||
1317 | 255, 128, 146, 147, 255, 190, 191, 192, | ||
1318 | 255, 128, 143, 144, 255, 144, 145, 136, | ||
1319 | 175, 188, 191, 192, 255, 181, 128, 175, | ||
1320 | 176, 255, 189, 191, 192, 255, 128, 160, | ||
1321 | 161, 186, 187, 191, 128, 129, 154, 155, | ||
1322 | 165, 166, 255, 191, 192, 255, 128, 129, | ||
1323 | 130, 135, 136, 137, 138, 143, 144, 145, | ||
1324 | 146, 151, 152, 153, 154, 156, 157, 191, | ||
1325 | 128, 191, 128, 129, 130, 131, 133, 138, | ||
1326 | 139, 140, 141, 142, 143, 144, 145, 146, | ||
1327 | 147, 148, 149, 152, 156, 157, 160, 161, | ||
1328 | 162, 163, 164, 166, 168, 169, 170, 171, | ||
1329 | 172, 173, 174, 176, 177, 132, 151, 153, | ||
1330 | 155, 158, 175, 178, 179, 180, 191, 140, | ||
1331 | 167, 187, 190, 128, 255, 142, 143, 158, | ||
1332 | 191, 192, 255, 187, 191, 192, 255, 128, | ||
1333 | 180, 181, 191, 128, 156, 157, 159, 160, | ||
1334 | 255, 145, 191, 192, 255, 128, 159, 160, | ||
1335 | 175, 176, 255, 139, 143, 182, 191, 192, | ||
1336 | 255, 144, 132, 135, 150, 191, 192, 255, | ||
1337 | 158, 175, 148, 151, 188, 191, 192, 255, | ||
1338 | 128, 167, 168, 175, 176, 255, 164, 191, | ||
1339 | 192, 255, 183, 191, 192, 255, 128, 149, | ||
1340 | 150, 159, 160, 167, 168, 191, 136, 182, | ||
1341 | 188, 128, 133, 134, 137, 138, 184, 185, | ||
1342 | 190, 191, 255, 150, 159, 183, 191, 192, | ||
1343 | 255, 179, 128, 159, 160, 181, 182, 191, | ||
1344 | 128, 149, 150, 159, 160, 185, 186, 191, | ||
1345 | 128, 183, 184, 189, 190, 191, 128, 148, | ||
1346 | 152, 129, 143, 144, 179, 180, 191, 128, | ||
1347 | 159, 160, 188, 189, 191, 128, 156, 157, | ||
1348 | 191, 136, 128, 164, 165, 191, 128, 181, | ||
1349 | 182, 191, 128, 149, 150, 159, 160, 178, | ||
1350 | 179, 191, 128, 145, 146, 191, 128, 178, | ||
1351 | 179, 191, 128, 130, 131, 132, 133, 134, | ||
1352 | 135, 136, 138, 139, 140, 141, 144, 145, | ||
1353 | 146, 147, 150, 151, 152, 153, 154, 156, | ||
1354 | 162, 163, 171, 176, 177, 178, 129, 191, | ||
1355 | 128, 130, 131, 183, 184, 191, 128, 130, | ||
1356 | 131, 175, 176, 191, 128, 143, 144, 168, | ||
1357 | 169, 191, 128, 130, 131, 166, 167, 191, | ||
1358 | 182, 128, 143, 144, 178, 179, 191, 128, | ||
1359 | 130, 131, 178, 179, 191, 128, 154, 156, | ||
1360 | 129, 132, 133, 191, 146, 128, 171, 172, | ||
1361 | 191, 135, 137, 142, 158, 128, 168, 169, | ||
1362 | 175, 176, 255, 159, 191, 192, 255, 144, | ||
1363 | 128, 156, 157, 161, 162, 191, 128, 134, | ||
1364 | 135, 138, 139, 191, 128, 175, 176, 191, | ||
1365 | 134, 128, 131, 132, 135, 136, 191, 128, | ||
1366 | 174, 175, 191, 128, 151, 152, 155, 156, | ||
1367 | 191, 132, 128, 191, 128, 170, 171, 191, | ||
1368 | 128, 153, 154, 191, 160, 190, 192, 255, | ||
1369 | 128, 184, 185, 191, 137, 128, 174, 175, | ||
1370 | 191, 128, 129, 177, 178, 255, 144, 191, | ||
1371 | 192, 255, 128, 142, 143, 144, 145, 146, | ||
1372 | 149, 129, 148, 150, 191, 175, 191, 192, | ||
1373 | 255, 132, 191, 192, 255, 128, 144, 129, | ||
1374 | 143, 145, 191, 144, 153, 128, 143, 145, | ||
1375 | 152, 154, 191, 135, 191, 192, 255, 160, | ||
1376 | 168, 169, 171, 172, 173, 174, 188, 189, | ||
1377 | 190, 191, 128, 159, 161, 167, 170, 187, | ||
1378 | 185, 191, 192, 255, 128, 143, 144, 173, | ||
1379 | 174, 191, 128, 131, 132, 162, 163, 183, | ||
1380 | 184, 188, 189, 255, 133, 143, 145, 191, | ||
1381 | 192, 255, 128, 146, 147, 159, 160, 191, | ||
1382 | 160, 128, 191, 128, 129, 191, 192, 255, | ||
1383 | 159, 160, 171, 128, 170, 172, 191, 192, | ||
1384 | 255, 173, 191, 192, 255, 179, 191, 192, | ||
1385 | 255, 128, 176, 177, 178, 129, 191, 128, | ||
1386 | 129, 130, 191, 171, 175, 189, 191, 192, | ||
1387 | 255, 128, 136, 137, 143, 144, 153, 154, | ||
1388 | 191, 144, 145, 146, 147, 148, 149, 154, | ||
1389 | 155, 156, 157, 158, 159, 128, 143, 150, | ||
1390 | 153, 160, 191, 149, 157, 173, 186, 188, | ||
1391 | 160, 161, 163, 164, 167, 168, 132, 134, | ||
1392 | 149, 157, 186, 191, 139, 140, 192, 255, | ||
1393 | 133, 145, 128, 134, 135, 137, 138, 255, | ||
1394 | 166, 167, 129, 155, 187, 149, 181, 143, | ||
1395 | 175, 137, 169, 131, 140, 191, 192, 255, | ||
1396 | 160, 163, 164, 165, 184, 185, 186, 128, | ||
1397 | 159, 161, 162, 166, 191, 133, 191, 192, | ||
1398 | 255, 132, 160, 163, 167, 179, 184, 186, | ||
1399 | 128, 164, 165, 168, 169, 187, 188, 191, | ||
1400 | 130, 135, 137, 139, 144, 147, 151, 153, | ||
1401 | 155, 157, 159, 163, 171, 179, 184, 189, | ||
1402 | 191, 128, 140, 141, 148, 149, 160, 161, | ||
1403 | 164, 165, 166, 167, 190, 138, 164, 170, | ||
1404 | 128, 155, 156, 160, 161, 187, 188, 191, | ||
1405 | 128, 191, 155, 156, 128, 191, 151, 191, | ||
1406 | 192, 255, 156, 157, 160, 128, 191, 181, | ||
1407 | 191, 192, 255, 158, 159, 186, 128, 185, | ||
1408 | 187, 191, 192, 255, 162, 191, 192, 255, | ||
1409 | 160, 168, 128, 159, 161, 167, 169, 191, | ||
1410 | 158, 191, 192, 255, 9, 10, 13, 32, | ||
1411 | 33, 34, 35, 38, 46, 47, 60, 61, | ||
1412 | 62, 64, 92, 95, 123, 124, 125, 126, | ||
1413 | 127, 194, 195, 198, 199, 203, 204, 205, | ||
1414 | 206, 207, 210, 212, 213, 214, 215, 216, | ||
1415 | 217, 219, 220, 221, 222, 223, 224, 225, | ||
1416 | 226, 227, 228, 233, 234, 237, 238, 239, | ||
1417 | 240, 0, 36, 37, 45, 48, 57, 58, | ||
1418 | 63, 65, 90, 91, 96, 97, 122, 192, | ||
1419 | 193, 196, 218, 229, 236, 241, 247, 9, | ||
1420 | 32, 10, 61, 10, 38, 46, 42, 47, | ||
1425 | 46, 69, 101, 48, 57, 60, 61, 61, | 1421 | 46, 69, 101, 48, 57, 60, 61, 61, |
1426 | 62, 61, 45, 95, 194, 195, 198, 199, | 1422 | 62, 61, 45, 95, 194, 195, 198, 199, |
1427 | 203, 204, 205, 206, 207, 210, 212, 213, | 1423 | 203, 204, 205, 206, 207, 210, 212, 213, |
@@ -1472,229 +1468,131 @@ var _hcltok_trans_keys []byte = []byte{ | |||
1472 | 159, 161, 169, 173, 191, 128, 191, 10, | 1468 | 159, 161, 169, 173, 191, 128, 191, 10, |
1473 | 13, 34, 36, 37, 92, 128, 191, 192, | 1469 | 13, 34, 36, 37, 92, 128, 191, 192, |
1474 | 223, 224, 239, 240, 247, 248, 255, 10, | 1470 | 223, 224, 239, 240, 247, 248, 255, 10, |
1475 | 13, 34, 36, 37, 92, 128, 191, 192, | 1471 | 13, 34, 92, 36, 37, 128, 191, 192, |
1476 | 223, 224, 239, 240, 247, 248, 255, 10, | 1472 | 223, 224, 239, 240, 247, 248, 255, 10, |
1477 | 13, 34, 36, 37, 92, 128, 191, 192, | 1473 | 13, 36, 123, 123, 126, 126, 37, 123, |
1474 | 126, 10, 13, 128, 191, 192, 223, 224, | ||
1475 | 239, 240, 247, 248, 255, 128, 191, 128, | ||
1476 | 191, 128, 191, 10, 13, 36, 37, 128, | ||
1477 | 191, 192, 223, 224, 239, 240, 247, 248, | ||
1478 | 255, 10, 13, 36, 37, 128, 191, 192, | ||
1478 | 223, 224, 239, 240, 247, 248, 255, 10, | 1479 | 223, 224, 239, 240, 247, 248, 255, 10, |
1479 | 13, 34, 36, 37, 92, 128, 191, 192, | 1480 | 13, 10, 13, 123, 10, 13, 126, 10, |
1481 | 13, 126, 126, 128, 191, 128, 191, 128, | ||
1482 | 191, 10, 13, 36, 37, 128, 191, 192, | ||
1480 | 223, 224, 239, 240, 247, 248, 255, 10, | 1483 | 223, 224, 239, 240, 247, 248, 255, 10, |
1481 | 13, 36, 37, 92, 128, 191, 192, 223, | 1484 | 13, 36, 37, 128, 191, 192, 223, 224, |
1482 | 224, 239, 240, 247, 248, 255, 36, 37, | 1485 | 239, 240, 247, 248, 255, 10, 13, 10, |
1483 | 92, 123, 192, 223, 224, 239, 240, 247, | 1486 | 13, 123, 10, 13, 126, 10, 13, 126, |
1484 | 10, 13, 34, 36, 37, 92, 123, 128, | 1487 | 126, 128, 191, 128, 191, 128, 191, 95, |
1485 | 191, 192, 223, 224, 239, 240, 247, 248, | 1488 | 194, 195, 198, 199, 203, 204, 205, 206, |
1486 | 255, 10, 13, 34, 36, 37, 92, 123, | 1489 | 207, 210, 212, 213, 214, 215, 216, 217, |
1487 | 128, 191, 192, 223, 224, 239, 240, 247, | 1490 | 219, 220, 221, 222, 223, 224, 225, 226, |
1488 | 248, 255, 10, 13, 34, 36, 37, 92, | 1491 | 227, 228, 233, 234, 237, 238, 239, 240, |
1489 | 123, 128, 191, 192, 223, 224, 239, 240, | 1492 | 65, 90, 97, 122, 128, 191, 192, 193, |
1490 | 247, 248, 255, 10, 13, 34, 36, 37, | 1493 | 196, 218, 229, 236, 241, 247, 248, 255, |
1491 | 92, 128, 191, 192, 223, 224, 239, 240, | 1494 | 45, 95, 194, 195, 198, 199, 203, 204, |
1492 | 247, 248, 255, 36, 37, 92, 123, 192, | 1495 | 205, 206, 207, 210, 212, 213, 214, 215, |
1493 | 223, 224, 239, 240, 247, 10, 13, 34, | 1496 | 216, 217, 219, 220, 221, 222, 223, 224, |
1494 | 36, 37, 92, 123, 128, 191, 192, 223, | 1497 | 225, 226, 227, 228, 233, 234, 237, 239, |
1495 | 224, 239, 240, 247, 248, 255, 10, 13, | 1498 | 240, 243, 48, 57, 65, 90, 97, 122, |
1496 | 34, 36, 37, 92, 128, 191, 192, 223, | 1499 | 196, 218, 229, 236, 128, 191, 170, 181, |
1497 | 224, 239, 240, 247, 248, 255, 10, 13, | 1500 | 186, 128, 191, 151, 183, 128, 255, 192, |
1498 | 34, 36, 37, 92, 128, 191, 192, 223, | 1501 | 255, 0, 127, 173, 130, 133, 146, 159, |
1499 | 224, 239, 240, 247, 248, 255, 10, 13, | 1502 | 165, 171, 175, 191, 192, 255, 181, 190, |
1500 | 34, 36, 37, 92, 128, 191, 192, 223, | 1503 | 128, 175, 176, 183, 184, 185, 186, 191, |
1501 | 224, 239, 240, 247, 248, 255, 10, 13, | 1504 | 134, 139, 141, 162, 128, 135, 136, 255, |
1502 | 34, 36, 37, 92, 128, 191, 192, 223, | 1505 | 182, 130, 137, 176, 151, 152, 154, 160, |
1503 | 224, 239, 240, 247, 248, 255, 10, 13, | 1506 | 136, 191, 192, 255, 128, 143, 144, 170, |
1504 | 34, 36, 37, 92, 128, 191, 192, 223, | 1507 | 171, 175, 176, 178, 179, 191, 128, 159, |
1505 | 224, 239, 240, 247, 248, 255, 10, 13, | 1508 | 160, 191, 176, 128, 138, 139, 173, 174, |
1506 | 34, 36, 37, 92, 128, 191, 192, 223, | 1509 | 255, 148, 150, 164, 167, 173, 176, 185, |
1507 | 224, 239, 240, 247, 248, 255, 10, 13, | 1510 | 189, 190, 192, 255, 144, 128, 145, 146, |
1508 | 34, 36, 37, 92, 128, 191, 192, 223, | 1511 | 175, 176, 191, 128, 140, 141, 255, 166, |
1509 | 224, 239, 240, 247, 248, 255, 123, 126, | 1512 | 176, 178, 191, 192, 255, 186, 128, 137, |
1510 | 123, 126, 128, 191, 128, 191, 128, 191, | 1513 | 138, 170, 171, 179, 180, 181, 182, 191, |
1511 | 10, 13, 36, 37, 128, 191, 192, 223, | 1514 | 160, 161, 162, 164, 165, 166, 167, 168, |
1512 | 224, 239, 240, 247, 248, 255, 10, 13, | 1515 | 169, 170, 171, 172, 173, 174, 175, 176, |
1513 | 36, 37, 128, 191, 192, 223, 224, 239, | 1516 | 177, 178, 179, 180, 181, 182, 183, 184, |
1514 | 240, 247, 248, 255, 10, 13, 36, 37, | 1517 | 185, 186, 187, 188, 189, 190, 128, 191, |
1515 | 128, 191, 192, 223, 224, 239, 240, 247, | 1518 | 128, 129, 130, 131, 137, 138, 139, 140, |
1516 | 248, 255, 10, 13, 36, 37, 128, 191, | 1519 | 141, 142, 143, 144, 153, 154, 155, 156, |
1517 | 192, 223, 224, 239, 240, 247, 248, 255, | 1520 | 157, 158, 159, 160, 161, 162, 163, 164, |
1518 | 126, 126, 128, 191, 128, 191, 128, 191, | ||
1519 | 10, 13, 36, 37, 128, 191, 192, 223, | ||
1520 | 224, 239, 240, 247, 248, 255, 10, 13, | ||
1521 | 36, 37, 128, 191, 192, 223, 224, 239, | ||
1522 | 240, 247, 248, 255, 126, 126, 128, 191, | ||
1523 | 128, 191, 128, 191, 95, 194, 195, 198, | ||
1524 | 199, 203, 204, 205, 206, 207, 210, 212, | ||
1525 | 213, 214, 215, 216, 217, 219, 220, 221, | ||
1526 | 222, 223, 224, 225, 226, 227, 228, 233, | ||
1527 | 234, 237, 238, 239, 240, 65, 90, 97, | ||
1528 | 122, 128, 191, 192, 193, 196, 218, 229, | ||
1529 | 236, 241, 247, 248, 255, 45, 95, 194, | ||
1530 | 195, 198, 199, 203, 204, 205, 206, 207, | ||
1531 | 210, 212, 213, 214, 215, 216, 217, 219, | ||
1532 | 220, 221, 222, 223, 224, 225, 226, 227, | ||
1533 | 228, 233, 234, 237, 239, 240, 243, 48, | ||
1534 | 57, 65, 90, 97, 122, 196, 218, 229, | ||
1535 | 236, 128, 191, 170, 181, 186, 128, 191, | ||
1536 | 151, 183, 128, 255, 192, 255, 0, 127, | ||
1537 | 173, 130, 133, 146, 159, 165, 171, 175, | ||
1538 | 191, 192, 255, 181, 190, 128, 175, 176, | ||
1539 | 183, 184, 185, 186, 191, 134, 139, 141, | ||
1540 | 162, 128, 135, 136, 255, 182, 130, 137, | ||
1541 | 176, 151, 152, 154, 160, 136, 191, 192, | ||
1542 | 255, 128, 143, 144, 170, 171, 175, 176, | ||
1543 | 178, 179, 191, 128, 159, 160, 191, 176, | ||
1544 | 128, 138, 139, 173, 174, 255, 148, 150, | ||
1545 | 164, 167, 173, 176, 185, 189, 190, 192, | ||
1546 | 255, 144, 128, 145, 146, 175, 176, 191, | ||
1547 | 128, 140, 141, 255, 166, 176, 178, 191, | ||
1548 | 192, 255, 186, 128, 137, 138, 170, 171, | ||
1549 | 179, 180, 181, 182, 191, 160, 161, 162, | ||
1550 | 164, 165, 166, 167, 168, 169, 170, 171, | ||
1551 | 172, 173, 174, 175, 176, 177, 178, 179, | ||
1552 | 180, 181, 182, 183, 184, 185, 186, 187, | ||
1553 | 188, 189, 190, 128, 191, 128, 129, 130, | ||
1554 | 131, 137, 138, 139, 140, 141, 142, 143, | ||
1555 | 144, 153, 154, 155, 156, 157, 158, 159, | ||
1556 | 160, 161, 162, 163, 164, 165, 166, 167, | ||
1557 | 168, 169, 170, 171, 172, 173, 174, 175, | ||
1558 | 176, 177, 178, 179, 180, 182, 183, 184, | ||
1559 | 188, 189, 190, 191, 132, 187, 129, 130, | ||
1560 | 132, 133, 134, 176, 177, 178, 179, 180, | ||
1561 | 181, 182, 183, 128, 191, 128, 129, 130, | ||
1562 | 131, 132, 133, 134, 135, 144, 136, 143, | ||
1563 | 145, 191, 192, 255, 182, 183, 184, 128, | ||
1564 | 191, 128, 191, 191, 128, 190, 192, 255, | ||
1565 | 128, 146, 147, 148, 152, 153, 154, 155, | ||
1566 | 156, 158, 159, 160, 161, 162, 163, 164, | ||
1567 | 165, 166, 167, 168, 169, 170, 171, 172, | 1521 | 165, 166, 167, 168, 169, 170, 171, 172, |
1568 | 173, 174, 175, 176, 129, 191, 192, 255, | 1522 | 173, 174, 175, 176, 177, 178, 179, 180, |
1569 | 158, 159, 128, 157, 160, 191, 192, 255, | 1523 | 182, 183, 184, 188, 189, 190, 191, 132, |
1570 | 128, 191, 164, 169, 171, 172, 173, 174, | 1524 | 187, 129, 130, 132, 133, 134, 176, 177, |
1571 | 175, 180, 181, 182, 183, 184, 185, 187, | 1525 | 178, 179, 180, 181, 182, 183, 128, 191, |
1572 | 188, 189, 190, 191, 128, 163, 165, 186, | 1526 | 128, 129, 130, 131, 132, 133, 134, 135, |
1573 | 144, 145, 146, 147, 148, 150, 151, 152, | 1527 | 144, 136, 143, 145, 191, 192, 255, 182, |
1574 | 155, 157, 158, 160, 170, 171, 172, 175, | 1528 | 183, 184, 128, 191, 128, 191, 191, 128, |
1575 | 128, 159, 161, 169, 173, 191, 128, 191, | 1529 | 190, 192, 255, 128, 146, 147, 148, 152, |
1530 | 153, 154, 155, 156, 158, 159, 160, 161, | ||
1531 | 162, 163, 164, 165, 166, 167, 168, 169, | ||
1532 | 170, 171, 172, 173, 174, 175, 176, 129, | ||
1533 | 191, 192, 255, 158, 159, 128, 157, 160, | ||
1534 | 191, 192, 255, 128, 191, 164, 169, 171, | ||
1535 | 172, 173, 174, 175, 180, 181, 182, 183, | ||
1536 | 184, 185, 187, 188, 189, 190, 191, 128, | ||
1537 | 163, 165, 186, 144, 145, 146, 147, 148, | ||
1538 | 150, 151, 152, 155, 157, 158, 160, 170, | ||
1539 | 171, 172, 175, 128, 159, 161, 169, 173, | ||
1540 | 191, 128, 191, | ||
1576 | } | 1541 | } |
1577 | 1542 | ||
1578 | var _hcltok_single_lengths []byte = []byte{ | 1543 | var _hcltok_single_lengths []byte = []byte{ |
1579 | 0, 1, 1, 1, 2, 3, 2, 0, | 1544 | 0, 1, 1, 2, 3, 2, 0, 32, |
1580 | 32, 31, 36, 1, 4, 0, 0, 0, | 1545 | 31, 36, 1, 4, 0, 0, 0, 0, |
1581 | 0, 1, 2, 1, 1, 1, 1, 0, | 1546 | 1, 2, 1, 1, 1, 1, 0, 1, |
1582 | 1, 1, 0, 0, 2, 0, 0, 0, | 1547 | 1, 0, 0, 2, 0, 0, 0, 1, |
1583 | 1, 32, 0, 0, 0, 0, 1, 3, | 1548 | 32, 0, 0, 0, 0, 1, 3, 1, |
1584 | 1, 1, 1, 0, 2, 0, 1, 1, | 1549 | 1, 1, 0, 2, 0, 1, 1, 2, |
1585 | 2, 0, 3, 0, 1, 0, 2, 1, | 1550 | 0, 3, 0, 1, 0, 2, 1, 2, |
1586 | 2, 0, 0, 5, 1, 4, 0, 0, | 1551 | 0, 0, 5, 1, 4, 0, 0, 1, |
1587 | 1, 43, 0, 0, 0, 2, 3, 2, | 1552 | 43, 0, 0, 0, 2, 3, 2, 1, |
1588 | 1, 1, 0, 0, 0, 0, 0, 0, | 1553 | 1, 0, 0, 0, 0, 0, 0, 0, |
1589 | 0, 0, 0, 0, 0, 0, 0, 0, | 1554 | 0, 0, 0, 0, 0, 0, 0, 0, |
1590 | 0, 0, 0, 0, 0, 1, 1, 0, | 1555 | 0, 0, 0, 0, 1, 1, 0, 0, |
1591 | 0, 0, 0, 0, 0, 0, 0, 4, | 1556 | 0, 0, 0, 0, 0, 0, 4, 1, |
1592 | 1, 0, 15, 0, 0, 0, 1, 6, | 1557 | 0, 15, 0, 0, 0, 1, 6, 1, |
1593 | 1, 0, 0, 1, 0, 2, 0, 0, | 1558 | 0, 0, 1, 0, 2, 0, 0, 0, |
1594 | 0, 9, 0, 1, 1, 0, 0, 0, | 1559 | 9, 0, 1, 1, 0, 0, 0, 3, |
1595 | 3, 0, 1, 0, 28, 0, 0, 0, | 1560 | 0, 1, 0, 28, 0, 0, 0, 1, |
1596 | 1, 0, 1, 0, 0, 0, 1, 0, | 1561 | 0, 1, 0, 0, 0, 1, 0, 0, |
1562 | 0, 0, 0, 0, 0, 1, 0, 2, | ||
1563 | 0, 0, 18, 0, 0, 1, 0, 0, | ||
1597 | 0, 0, 0, 0, 0, 0, 1, 0, | 1564 | 0, 0, 0, 0, 0, 0, 1, 0, |
1598 | 2, 0, 0, 18, 0, 0, 1, 0, | 1565 | 0, 0, 16, 36, 0, 0, 0, 0, |
1599 | 0, 0, 0, 0, 0, 0, 0, 1, | 1566 | 1, 0, 0, 0, 0, 0, 1, 0, |
1600 | 0, 0, 0, 16, 36, 0, 0, 0, | 1567 | 0, 0, 0, 0, 0, 2, 0, 0, |
1601 | 0, 1, 0, 0, 0, 0, 0, 1, | ||
1602 | 0, 0, 0, 0, 0, 0, 2, 0, | ||
1603 | 0, 0, 0, 0, 1, 0, 0, 0, | ||
1604 | 0, 0, 0, 0, 28, 0, 0, 0, | ||
1605 | 1, 1, 1, 1, 0, 0, 2, 0, | ||
1606 | 1, 0, 0, 0, 0, 0, 0, 0, | ||
1607 | 0, 0, 1, 1, 4, 0, 0, 2, | ||
1608 | 2, 0, 11, 0, 0, 0, 0, 0, | ||
1609 | 0, 0, 1, 1, 3, 0, 0, 4, | ||
1610 | 0, 0, 0, 18, 0, 0, 0, 1, | ||
1611 | 4, 1, 4, 1, 0, 3, 2, 2, | ||
1612 | 2, 1, 0, 0, 1, 8, 0, 0, | ||
1613 | 0, 4, 12, 0, 2, 0, 3, 0, | ||
1614 | 1, 0, 2, 0, 1, 2, 0, 3, | ||
1615 | 1, 2, 0, 0, 0, 0, 0, 1, | ||
1616 | 1, 0, 0, 1, 28, 3, 0, 1, | ||
1617 | 1, 2, 1, 0, 1, 1, 2, 1, | ||
1618 | 1, 2, 1, 1, 0, 2, 1, 1, | ||
1619 | 1, 1, 0, 0, 6, 1, 1, 0, | ||
1620 | 0, 46, 1, 1, 0, 0, 0, 0, | ||
1621 | 2, 1, 0, 0, 0, 1, 0, 0, | ||
1622 | 0, 0, 0, 0, 0, 13, 2, 0, | ||
1623 | 0, 0, 9, 0, 1, 28, 0, 1, | ||
1624 | 3, 0, 2, 0, 0, 0, 1, 0, | ||
1625 | 1, 1, 2, 0, 18, 2, 0, 0, | ||
1626 | 16, 35, 0, 0, 0, 1, 0, 28, | ||
1627 | 0, 0, 0, 0, 1, 0, 2, 0, | ||
1628 | 0, 1, 0, 0, 1, 0, 0, 1, | ||
1629 | 0, 0, 0, 0, 1, 11, 0, 0, | ||
1630 | 0, 0, 4, 0, 12, 1, 7, 0, | ||
1631 | 4, 0, 0, 0, 0, 1, 2, 1, | ||
1632 | 1, 1, 1, 0, 1, 1, 0, 0, | ||
1633 | 2, 0, 0, 0, 1, 32, 0, 0, | ||
1634 | 0, 0, 1, 3, 1, 1, 1, 0, | ||
1635 | 2, 0, 1, 1, 2, 0, 3, 0, | ||
1636 | 1, 0, 2, 1, 2, 0, 0, 5, | ||
1637 | 1, 4, 0, 0, 1, 43, 0, 0, | ||
1638 | 0, 2, 3, 2, 1, 1, 0, 0, | ||
1639 | 0, 0, 0, 0, 0, 0, 0, 0, | ||
1640 | 0, 0, 0, 0, 0, 0, 0, 0, | ||
1641 | 0, 1, 1, 0, 0, 0, 0, 0, | ||
1642 | 0, 0, 0, 4, 1, 0, 15, 0, | ||
1643 | 0, 0, 1, 6, 1, 0, 0, 1, | ||
1644 | 0, 2, 0, 0, 0, 9, 0, 1, | ||
1645 | 1, 0, 0, 0, 3, 0, 1, 0, | ||
1646 | 28, 0, 0, 0, 1, 0, 1, 0, | ||
1647 | 0, 0, 1, 0, 0, 0, 0, 0, | ||
1648 | 0, 0, 1, 0, 2, 0, 0, 18, | ||
1649 | 0, 0, 1, 0, 0, 0, 0, 0, | ||
1650 | 0, 0, 0, 1, 0, 0, 0, 16, | ||
1651 | 36, 0, 0, 0, 0, 1, 0, 0, | ||
1652 | 0, 0, 0, 1, 0, 0, 0, 0, | 1568 | 0, 0, 0, 1, 0, 0, 0, 0, |
1653 | 0, 0, 2, 0, 0, 0, 0, 0, | 1569 | 0, 0, 0, 28, 0, 0, 0, 1, |
1654 | 1, 0, 0, 0, 0, 0, 0, 0, | 1570 | 1, 1, 1, 0, 0, 2, 0, 1, |
1655 | 28, 0, 0, 0, 1, 1, 1, 1, | 1571 | 0, 0, 0, 0, 0, 0, 0, 0, |
1656 | 0, 0, 2, 0, 1, 0, 0, 0, | 1572 | 0, 1, 1, 4, 0, 0, 2, 2, |
1657 | 0, 0, 0, 0, 0, 0, 1, 1, | 1573 | 0, 11, 0, 0, 0, 0, 0, 0, |
1658 | 4, 0, 0, 2, 2, 0, 11, 0, | 1574 | 0, 1, 1, 3, 0, 0, 4, 0, |
1659 | 0, 0, 0, 0, 0, 0, 1, 1, | 1575 | 0, 0, 18, 0, 0, 0, 1, 4, |
1660 | 3, 0, 0, 4, 0, 0, 0, 18, | 1576 | 1, 4, 1, 0, 3, 2, 2, 2, |
1661 | 0, 0, 0, 1, 4, 1, 4, 1, | 1577 | 1, 0, 0, 1, 8, 0, 0, 0, |
1662 | 0, 3, 2, 2, 2, 1, 0, 0, | 1578 | 4, 12, 0, 2, 0, 3, 0, 1, |
1663 | 1, 8, 0, 0, 0, 4, 12, 0, | 1579 | 0, 2, 0, 1, 2, 0, 3, 1, |
1664 | 2, 0, 3, 0, 1, 0, 2, 0, | 1580 | 2, 0, 0, 0, 0, 0, 1, 1, |
1665 | 1, 2, 0, 0, 3, 0, 1, 1, | 1581 | 0, 0, 1, 28, 3, 0, 1, 1, |
1666 | 1, 2, 2, 4, 1, 6, 2, 4, | 1582 | 2, 1, 0, 1, 1, 2, 1, 1, |
1667 | 2, 4, 1, 4, 0, 6, 1, 3, | 1583 | 2, 1, 1, 0, 2, 1, 1, 1, |
1668 | 1, 2, 0, 2, 11, 1, 1, 1, | 1584 | 1, 0, 0, 6, 1, 1, 0, 0, |
1669 | 0, 1, 1, 0, 2, 0, 3, 3, | 1585 | 46, 1, 1, 0, 0, 0, 0, 2, |
1670 | 2, 1, 0, 0, 0, 1, 0, 1, | 1586 | 1, 0, 0, 0, 1, 0, 0, 0, |
1671 | 0, 1, 1, 0, 2, 0, 0, 1, | 1587 | 0, 0, 0, 0, 13, 2, 0, 0, |
1672 | 0, 0, 0, 0, 0, 0, 0, 1, | 1588 | 0, 9, 0, 1, 28, 0, 1, 3, |
1673 | 0, 0, 0, 0, 0, 0, 0, 1, | 1589 | 0, 2, 0, 0, 0, 1, 0, 1, |
1674 | 0, 0, 0, 4, 3, 2, 2, 0, | 1590 | 1, 2, 0, 18, 2, 0, 0, 16, |
1675 | 6, 1, 0, 1, 1, 0, 2, 0, | 1591 | 35, 0, 0, 0, 1, 0, 28, 0, |
1676 | 4, 3, 0, 1, 1, 0, 0, 0, | 1592 | 0, 0, 0, 1, 0, 2, 0, 0, |
1677 | 0, 0, 0, 0, 1, 0, 0, 0, | 1593 | 1, 0, 0, 1, 0, 0, 1, 0, |
1678 | 1, 0, 3, 0, 2, 0, 0, 0, | 1594 | 0, 0, 0, 1, 11, 0, 0, 0, |
1679 | 3, 0, 2, 1, 1, 3, 1, 0, | 1595 | 0, 4, 0, 12, 1, 7, 0, 4, |
1680 | 0, 0, 0, 0, 5, 2, 0, 0, | ||
1681 | 0, 0, 0, 0, 1, 0, 0, 1, | ||
1682 | 1, 0, 0, 35, 4, 0, 0, 0, | ||
1683 | 0, 0, 0, 0, 1, 0, 0, 0, | ||
1684 | 0, 0, 0, 3, 0, 1, 0, 0, | ||
1685 | 3, 0, 0, 1, 0, 0, 0, 0, | ||
1686 | 28, 0, 0, 0, 0, 1, 0, 3, | ||
1687 | 1, 4, 0, 1, 0, 0, 1, 0, | ||
1688 | 0, 1, 0, 0, 0, 0, 1, 1, | ||
1689 | 0, 7, 0, 0, 2, 2, 0, 11, | ||
1690 | 0, 0, 0, 0, 0, 1, 1, 3, | ||
1691 | 0, 0, 4, 0, 0, 0, 12, 1, | ||
1692 | 4, 1, 5, 2, 0, 3, 2, 2, | ||
1693 | 2, 1, 7, 0, 7, 17, 3, 0, | ||
1694 | 2, 0, 3, 0, 0, 1, 0, 2, | ||
1695 | 0, 1, 1, 0, 0, 0, 0, 0, | ||
1696 | 1, 1, 1, 0, 0, 0, 1, 1, | ||
1697 | 1, 1, 0, 0, 0, 1, 1, 4, | ||
1698 | 0, 0, 0, 0, 1, 2, 1, 1, | 1596 | 0, 0, 0, 0, 1, 2, 1, 1, |
1699 | 1, 1, 0, 1, 1, 0, 0, 2, | 1597 | 1, 1, 0, 1, 1, 0, 0, 2, |
1700 | 0, 0, 0, 1, 32, 0, 0, 0, | 1598 | 0, 0, 0, 1, 32, 0, 0, 0, |
@@ -1759,145 +1657,143 @@ var _hcltok_single_lengths []byte = []byte{ | |||
1759 | 1, 5, 2, 0, 3, 2, 2, 2, | 1657 | 1, 5, 2, 0, 3, 2, 2, 2, |
1760 | 1, 7, 0, 7, 17, 3, 0, 2, | 1658 | 1, 7, 0, 7, 17, 3, 0, 2, |
1761 | 0, 3, 0, 0, 1, 0, 2, 0, | 1659 | 0, 3, 0, 0, 1, 0, 2, 0, |
1762 | 54, 2, 1, 1, 1, 1, 1, 2, | 1660 | 2, 0, 0, 0, 0, 0, 1, 0, |
1763 | 1, 3, 2, 2, 1, 34, 1, 1, | 1661 | 0, 0, 2, 2, 1, 0, 0, 0, |
1764 | 0, 3, 2, 0, 0, 0, 1, 2, | 1662 | 2, 2, 4, 0, 0, 0, 0, 1, |
1765 | 4, 1, 0, 1, 0, 0, 0, 0, | 1663 | 2, 1, 1, 1, 1, 0, 1, 1, |
1766 | 1, 1, 1, 0, 0, 1, 30, 47, | 1664 | 0, 0, 2, 0, 0, 0, 1, 32, |
1767 | 13, 9, 3, 0, 1, 28, 2, 0, | 1665 | 0, 0, 0, 0, 1, 3, 1, 1, |
1768 | 18, 16, 0, 6, 6, 6, 6, 5, | 1666 | 1, 0, 2, 0, 1, 1, 2, 0, |
1769 | 4, 7, 7, 7, 6, 4, 7, 6, | 1667 | 3, 0, 1, 0, 2, 1, 2, 0, |
1770 | 6, 6, 6, 6, 6, 6, 1, 1, | 1668 | 0, 5, 1, 4, 0, 0, 1, 43, |
1771 | 1, 1, 0, 0, 0, 4, 4, 4, | 1669 | 0, 0, 0, 2, 3, 2, 1, 1, |
1772 | 4, 1, 1, 0, 0, 0, 4, 2, | 1670 | 0, 0, 0, 0, 0, 0, 0, 0, |
1773 | 1, 1, 0, 0, 0, 33, 34, 0, | 1671 | 0, 0, 0, 0, 0, 0, 0, 0, |
1774 | 3, 2, 0, 0, 0, 1, 2, 4, | 1672 | 0, 0, 0, 1, 1, 0, 0, 0, |
1775 | 1, 0, 1, 0, 0, 0, 0, 1, | 1673 | 0, 0, 0, 0, 0, 4, 1, 0, |
1776 | 1, 1, 0, 0, 1, 30, 47, 13, | 1674 | 15, 0, 0, 0, 1, 6, 1, 0, |
1777 | 9, 3, 0, 1, 28, 2, 0, 18, | 1675 | 0, 1, 0, 2, 0, 0, 0, 9, |
1778 | 16, 0, | 1676 | 0, 1, 1, 0, 0, 0, 3, 0, |
1677 | 1, 0, 28, 0, 0, 0, 1, 0, | ||
1678 | 1, 0, 0, 0, 1, 0, 0, 0, | ||
1679 | 0, 0, 0, 0, 1, 0, 2, 0, | ||
1680 | 0, 18, 0, 0, 1, 0, 0, 0, | ||
1681 | 0, 0, 0, 0, 0, 1, 0, 0, | ||
1682 | 0, 16, 36, 0, 0, 0, 0, 1, | ||
1683 | 0, 0, 0, 0, 0, 1, 0, 0, | ||
1684 | 0, 0, 0, 0, 2, 0, 0, 0, | ||
1685 | 0, 0, 1, 0, 0, 0, 0, 0, | ||
1686 | 0, 0, 28, 0, 0, 0, 1, 1, | ||
1687 | 1, 1, 0, 0, 2, 0, 1, 0, | ||
1688 | 0, 0, 0, 0, 0, 0, 0, 0, | ||
1689 | 1, 1, 4, 0, 0, 2, 2, 0, | ||
1690 | 11, 0, 0, 0, 0, 0, 0, 0, | ||
1691 | 1, 1, 3, 0, 0, 4, 0, 0, | ||
1692 | 0, 18, 0, 0, 0, 1, 4, 1, | ||
1693 | 4, 1, 0, 3, 2, 2, 2, 1, | ||
1694 | 0, 0, 1, 8, 0, 0, 0, 4, | ||
1695 | 12, 0, 2, 0, 3, 0, 1, 0, | ||
1696 | 2, 0, 1, 2, 0, 0, 3, 0, | ||
1697 | 1, 1, 1, 2, 2, 4, 1, 6, | ||
1698 | 2, 4, 2, 4, 1, 4, 0, 6, | ||
1699 | 1, 3, 1, 2, 0, 2, 11, 1, | ||
1700 | 1, 1, 0, 1, 1, 0, 2, 0, | ||
1701 | 3, 3, 2, 1, 0, 0, 0, 1, | ||
1702 | 0, 1, 0, 1, 1, 0, 2, 0, | ||
1703 | 0, 1, 0, 0, 0, 0, 0, 0, | ||
1704 | 0, 1, 0, 0, 0, 0, 0, 0, | ||
1705 | 0, 1, 0, 0, 0, 4, 3, 2, | ||
1706 | 2, 0, 6, 1, 0, 1, 1, 0, | ||
1707 | 2, 0, 4, 3, 0, 1, 1, 0, | ||
1708 | 0, 0, 0, 0, 0, 0, 1, 0, | ||
1709 | 0, 0, 1, 0, 3, 0, 2, 0, | ||
1710 | 0, 0, 3, 0, 2, 1, 1, 3, | ||
1711 | 1, 0, 0, 0, 0, 0, 5, 2, | ||
1712 | 0, 0, 0, 0, 0, 0, 1, 0, | ||
1713 | 0, 1, 1, 0, 0, 35, 4, 0, | ||
1714 | 0, 0, 0, 0, 0, 0, 1, 0, | ||
1715 | 0, 0, 0, 0, 0, 3, 0, 1, | ||
1716 | 0, 0, 3, 0, 0, 1, 0, 0, | ||
1717 | 0, 0, 28, 0, 0, 0, 0, 1, | ||
1718 | 0, 3, 1, 4, 0, 1, 0, 0, | ||
1719 | 1, 0, 0, 1, 0, 0, 0, 0, | ||
1720 | 1, 1, 0, 7, 0, 0, 2, 2, | ||
1721 | 0, 11, 0, 0, 0, 0, 0, 1, | ||
1722 | 1, 3, 0, 0, 4, 0, 0, 0, | ||
1723 | 12, 1, 4, 1, 5, 2, 0, 3, | ||
1724 | 2, 2, 2, 1, 7, 0, 7, 17, | ||
1725 | 3, 0, 2, 0, 3, 0, 0, 1, | ||
1726 | 0, 2, 0, 53, 2, 1, 1, 1, | ||
1727 | 1, 1, 2, 3, 2, 2, 1, 34, | ||
1728 | 1, 1, 0, 3, 2, 0, 0, 0, | ||
1729 | 1, 2, 4, 1, 0, 1, 0, 0, | ||
1730 | 0, 0, 1, 1, 1, 0, 0, 1, | ||
1731 | 30, 47, 13, 9, 3, 0, 1, 28, | ||
1732 | 2, 0, 18, 16, 0, 6, 4, 2, | ||
1733 | 2, 0, 1, 1, 1, 2, 1, 2, | ||
1734 | 0, 0, 0, 4, 2, 2, 3, 3, | ||
1735 | 2, 1, 1, 0, 0, 0, 4, 2, | ||
1736 | 2, 3, 3, 2, 1, 1, 0, 0, | ||
1737 | 0, 33, 34, 0, 3, 2, 0, 0, | ||
1738 | 0, 1, 2, 4, 1, 0, 1, 0, | ||
1739 | 0, 0, 0, 1, 1, 1, 0, 0, | ||
1740 | 1, 30, 47, 13, 9, 3, 0, 1, | ||
1741 | 28, 2, 0, 18, 16, 0, | ||
1779 | } | 1742 | } |
1780 | 1743 | ||
1781 | var _hcltok_range_lengths []byte = []byte{ | 1744 | var _hcltok_range_lengths []byte = []byte{ |
1782 | 0, 0, 0, 0, 0, 1, 1, 1, | 1745 | 0, 0, 0, 0, 1, 1, 1, 5, |
1783 | 5, 5, 5, 0, 0, 3, 0, 1, | 1746 | 5, 5, 0, 0, 3, 0, 1, 1, |
1784 | 1, 4, 2, 3, 0, 1, 0, 2, | 1747 | 4, 2, 3, 0, 1, 0, 2, 2, |
1785 | 2, 4, 2, 2, 3, 1, 1, 1, | 1748 | 4, 2, 2, 3, 1, 1, 1, 1, |
1786 | 1, 0, 1, 1, 2, 2, 1, 4, | 1749 | 0, 1, 1, 2, 2, 1, 4, 6, |
1787 | 6, 9, 6, 8, 5, 8, 7, 10, | 1750 | 9, 6, 8, 5, 8, 7, 10, 4, |
1788 | 4, 6, 4, 7, 7, 5, 5, 4, | 1751 | 6, 4, 7, 7, 5, 5, 4, 5, |
1789 | 5, 1, 2, 8, 4, 3, 3, 3, | 1752 | 1, 2, 8, 4, 3, 3, 3, 0, |
1790 | 0, 3, 1, 2, 1, 2, 2, 3, | 1753 | 3, 1, 2, 1, 2, 2, 3, 3, |
1791 | 3, 1, 3, 2, 2, 1, 2, 2, | 1754 | 1, 3, 2, 2, 1, 2, 2, 2, |
1792 | 2, 3, 4, 4, 3, 1, 2, 1, | 1755 | 3, 4, 4, 3, 1, 2, 1, 3, |
1793 | 3, 2, 2, 2, 2, 2, 3, 3, | 1756 | 2, 2, 2, 2, 2, 3, 3, 1, |
1794 | 1, 1, 2, 1, 3, 2, 2, 3, | 1757 | 1, 2, 1, 3, 2, 2, 3, 2, |
1795 | 2, 7, 0, 1, 4, 1, 2, 4, | 1758 | 7, 0, 1, 4, 1, 2, 4, 2, |
1796 | 2, 1, 2, 0, 2, 2, 3, 5, | 1759 | 1, 2, 0, 2, 2, 3, 5, 5, |
1797 | 5, 1, 4, 1, 1, 2, 2, 1, | 1760 | 1, 4, 1, 1, 2, 2, 1, 0, |
1798 | 0, 0, 1, 1, 1, 1, 1, 2, | 1761 | 0, 1, 1, 1, 1, 1, 2, 2, |
1799 | 2, 2, 2, 1, 1, 1, 4, 2, | 1762 | 2, 2, 1, 1, 1, 4, 2, 2, |
1800 | 2, 3, 1, 4, 4, 6, 1, 3, | 1763 | 3, 1, 4, 4, 6, 1, 3, 1, |
1801 | 1, 1, 2, 1, 1, 1, 5, 3, | 1764 | 1, 2, 1, 1, 1, 5, 3, 1, |
1802 | 1, 1, 1, 2, 3, 3, 1, 2, | 1765 | 1, 1, 2, 3, 3, 1, 2, 2, |
1803 | 2, 1, 4, 1, 2, 5, 2, 1, | 1766 | 1, 4, 1, 2, 5, 2, 1, 1, |
1804 | 1, 0, 2, 2, 2, 2, 2, 2, | 1767 | 0, 2, 2, 2, 2, 2, 2, 2, |
1805 | 2, 2, 2, 1, 1, 2, 4, 2, | 1768 | 2, 2, 1, 1, 2, 4, 2, 1, |
1806 | 1, 2, 2, 2, 6, 1, 1, 2, | 1769 | 2, 2, 2, 6, 1, 1, 2, 1, |
1807 | 1, 2, 1, 1, 1, 2, 2, 2, | 1770 | 2, 1, 1, 1, 2, 2, 2, 1, |
1808 | 1, 3, 2, 5, 2, 8, 6, 2, | 1771 | 3, 2, 5, 2, 8, 6, 2, 2, |
1809 | 2, 2, 2, 3, 1, 3, 1, 2, | 1772 | 2, 2, 3, 1, 3, 1, 2, 1, |
1810 | 1, 3, 2, 2, 3, 1, 1, 1, | 1773 | 3, 2, 2, 3, 1, 1, 1, 1, |
1811 | 1, 1, 1, 1, 2, 2, 4, 1, | 1774 | 1, 1, 1, 2, 2, 4, 1, 2, |
1812 | 2, 1, 0, 1, 1, 1, 1, 0, | 1775 | 1, 0, 1, 1, 1, 1, 0, 1, |
1813 | 1, 2, 3, 1, 3, 3, 1, 0, | 1776 | 2, 3, 1, 3, 3, 1, 0, 3, |
1814 | 3, 0, 2, 3, 1, 0, 0, 0, | 1777 | 0, 2, 3, 1, 0, 0, 0, 0, |
1815 | 0, 2, 2, 2, 2, 1, 5, 2, | 1778 | 2, 2, 2, 2, 1, 5, 2, 2, |
1816 | 2, 5, 7, 5, 0, 1, 0, 1, | 1779 | 5, 7, 5, 0, 1, 0, 1, 1, |
1817 | 1, 1, 1, 1, 0, 1, 1, 0, | 1780 | 1, 1, 1, 0, 1, 1, 0, 3, |
1818 | 3, 3, 1, 1, 2, 1, 3, 5, | 1781 | 3, 1, 1, 2, 1, 3, 5, 1, |
1819 | 1, 1, 2, 2, 1, 1, 1, 1, | 1782 | 1, 2, 2, 1, 1, 1, 1, 2, |
1820 | 2, 6, 3, 7, 2, 6, 1, 6, | 1783 | 6, 3, 7, 2, 6, 1, 6, 2, |
1821 | 2, 8, 0, 4, 2, 5, 2, 3, | 1784 | 8, 0, 4, 2, 5, 2, 3, 3, |
1822 | 3, 3, 1, 2, 8, 2, 0, 2, | 1785 | 3, 1, 2, 8, 2, 0, 2, 1, |
1823 | 1, 2, 1, 5, 2, 1, 3, 3, | 1786 | 2, 1, 5, 2, 1, 3, 3, 0, |
1824 | 0, 2, 1, 2, 1, 0, 1, 1, | 1787 | 2, 1, 2, 1, 0, 1, 1, 3, |
1825 | 3, 1, 1, 2, 3, 0, 0, 3, | 1788 | 1, 1, 2, 3, 0, 0, 3, 2, |
1826 | 2, 4, 1, 4, 1, 1, 3, 1, | 1789 | 4, 1, 4, 1, 1, 3, 1, 1, |
1827 | 1, 1, 1, 2, 2, 1, 3, 1, | 1790 | 1, 1, 2, 2, 1, 3, 1, 4, |
1828 | 4, 3, 3, 1, 1, 5, 2, 1, | 1791 | 3, 3, 1, 1, 5, 2, 1, 1, |
1829 | 1, 2, 1, 2, 1, 3, 2, 0, | 1792 | 2, 1, 2, 1, 3, 2, 0, 1, |
1830 | 1, 1, 1, 1, 1, 1, 1, 2, | 1793 | 1, 1, 1, 1, 1, 1, 2, 1, |
1831 | 1, 1, 1, 1, 1, 1, 1, 0, | 1794 | 1, 1, 1, 1, 1, 1, 0, 1, |
1832 | 1, 1, 2, 2, 1, 1, 1, 3, | 1795 | 1, 2, 2, 1, 1, 1, 3, 2, |
1833 | 2, 1, 0, 2, 1, 1, 1, 1, | 1796 | 1, 0, 2, 1, 1, 1, 1, 0, |
1834 | 0, 3, 0, 1, 1, 4, 2, 3, | ||
1835 | 0, 1, 0, 2, 2, 4, 2, 2, | ||
1836 | 3, 1, 1, 1, 1, 0, 1, 1, | ||
1837 | 2, 2, 1, 4, 6, 9, 6, 8, | ||
1838 | 5, 8, 7, 10, 4, 6, 4, 7, | ||
1839 | 7, 5, 5, 4, 5, 1, 2, 8, | ||
1840 | 4, 3, 3, 3, 0, 3, 1, 2, | ||
1841 | 1, 2, 2, 3, 3, 1, 3, 2, | ||
1842 | 2, 1, 2, 2, 2, 3, 4, 4, | ||
1843 | 3, 1, 2, 1, 3, 2, 2, 2, | ||
1844 | 2, 2, 3, 3, 1, 1, 2, 1, | ||
1845 | 3, 2, 2, 3, 2, 7, 0, 1, | ||
1846 | 4, 1, 2, 4, 2, 1, 2, 0, | ||
1847 | 2, 2, 3, 5, 5, 1, 4, 1, | ||
1848 | 1, 2, 2, 1, 0, 0, 1, 1, | ||
1849 | 1, 1, 1, 2, 2, 2, 2, 1, | ||
1850 | 1, 1, 4, 2, 2, 3, 1, 4, | ||
1851 | 4, 6, 1, 3, 1, 1, 2, 1, | ||
1852 | 1, 1, 5, 3, 1, 1, 1, 2, | ||
1853 | 3, 3, 1, 2, 2, 1, 4, 1, | ||
1854 | 2, 5, 2, 1, 1, 0, 2, 2, | ||
1855 | 2, 2, 2, 2, 2, 2, 2, 1, | ||
1856 | 1, 2, 4, 2, 1, 2, 2, 2, | ||
1857 | 6, 1, 1, 2, 1, 2, 1, 1, | ||
1858 | 1, 2, 2, 2, 1, 3, 2, 5, | ||
1859 | 2, 8, 6, 2, 2, 2, 2, 3, | ||
1860 | 1, 3, 1, 2, 1, 3, 2, 2, | ||
1861 | 3, 1, 1, 1, 1, 1, 1, 1, | ||
1862 | 2, 2, 4, 1, 2, 1, 0, 1, | ||
1863 | 1, 1, 1, 0, 1, 2, 3, 1, | ||
1864 | 3, 3, 1, 0, 3, 0, 2, 3, | ||
1865 | 1, 0, 0, 0, 0, 2, 2, 2, | ||
1866 | 2, 1, 5, 2, 2, 5, 7, 5, | ||
1867 | 0, 1, 0, 1, 1, 1, 1, 1, | ||
1868 | 0, 1, 1, 1, 2, 2, 3, 3, | ||
1869 | 4, 7, 5, 7, 5, 3, 3, 7, | ||
1870 | 3, 13, 1, 3, 5, 3, 5, 3, | ||
1871 | 6, 5, 2, 2, 8, 4, 1, 2, | ||
1872 | 3, 2, 10, 2, 2, 0, 2, 3, | ||
1873 | 3, 1, 2, 3, 3, 1, 2, 3, | ||
1874 | 3, 4, 4, 2, 1, 2, 2, 3, | ||
1875 | 2, 2, 5, 3, 2, 3, 2, 1, | ||
1876 | 3, 3, 6, 2, 2, 5, 2, 5, | ||
1877 | 1, 1, 2, 4, 1, 11, 1, 3, | ||
1878 | 8, 4, 2, 1, 0, 4, 3, 3, | ||
1879 | 3, 2, 9, 1, 1, 4, 3, 2, | ||
1880 | 2, 2, 3, 4, 2, 3, 2, 4, | ||
1881 | 3, 2, 2, 3, 3, 4, 3, 3, | ||
1882 | 4, 2, 5, 4, 8, 7, 1, 2, | ||
1883 | 1, 3, 1, 2, 5, 1, 2, 2, | ||
1884 | 2, 2, 1, 3, 2, 2, 3, 3, | ||
1885 | 1, 9, 1, 5, 1, 3, 2, 2, | ||
1886 | 3, 2, 3, 3, 3, 1, 3, 3, | ||
1887 | 2, 2, 4, 5, 3, 3, 4, 3, | ||
1888 | 3, 3, 2, 2, 2, 4, 2, 2, | ||
1889 | 1, 3, 3, 3, 3, 3, 3, 2, | ||
1890 | 2, 3, 2, 3, 3, 2, 3, 2, | ||
1891 | 3, 1, 2, 2, 2, 2, 2, 2, | ||
1892 | 2, 2, 2, 2, 2, 3, 2, 3, | ||
1893 | 2, 3, 5, 3, 3, 1, 2, 3, | ||
1894 | 2, 2, 1, 2, 3, 4, 3, 0, | ||
1895 | 3, 0, 2, 3, 1, 0, 0, 0, | ||
1896 | 0, 2, 3, 2, 4, 6, 4, 1, | ||
1897 | 1, 2, 1, 2, 1, 3, 2, 3, | ||
1898 | 2, 0, 0, 1, 1, 1, 1, 1, | ||
1899 | 0, 0, 0, 1, 1, 1, 0, 0, | ||
1900 | 0, 0, 1, 1, 1, 0, 0, 0, | ||
1901 | 3, 0, 1, 1, 4, 2, 3, 0, | 1797 | 3, 0, 1, 1, 4, 2, 3, 0, |
1902 | 1, 0, 2, 2, 4, 2, 2, 3, | 1798 | 1, 0, 2, 2, 4, 2, 2, 3, |
1903 | 1, 1, 1, 1, 0, 1, 1, 2, | 1799 | 1, 1, 1, 1, 0, 1, 1, 2, |
@@ -1962,826 +1858,889 @@ var _hcltok_range_lengths []byte = []byte{ | |||
1962 | 0, 2, 3, 1, 0, 0, 0, 0, | 1858 | 0, 2, 3, 1, 0, 0, 0, 0, |
1963 | 2, 3, 2, 4, 6, 4, 1, 1, | 1859 | 2, 3, 2, 4, 6, 4, 1, 1, |
1964 | 2, 1, 2, 1, 3, 2, 3, 2, | 1860 | 2, 1, 2, 1, 3, 2, 3, 2, |
1965 | 11, 0, 0, 0, 0, 0, 0, 0, | 1861 | 5, 1, 1, 1, 1, 1, 0, 1, |
1966 | 0, 1, 0, 0, 0, 5, 0, 0, | 1862 | 1, 1, 0, 0, 0, 1, 1, 1, |
1967 | 1, 1, 1, 0, 1, 1, 5, 4, | 1863 | 0, 0, 0, 3, 0, 1, 1, 4, |
1968 | 2, 0, 1, 0, 2, 2, 5, 2, | 1864 | 2, 3, 0, 1, 0, 2, 2, 4, |
1969 | 3, 5, 3, 2, 3, 5, 1, 1, | 1865 | 2, 2, 3, 1, 1, 1, 1, 0, |
1970 | 1, 3, 1, 1, 2, 2, 3, 1, | 1866 | 1, 1, 2, 2, 1, 4, 6, 9, |
1971 | 2, 3, 1, 5, 5, 5, 5, 5, | 1867 | 6, 8, 5, 8, 7, 10, 4, 6, |
1972 | 3, 5, 5, 5, 5, 3, 5, 5, | 1868 | 4, 7, 7, 5, 5, 4, 5, 1, |
1973 | 5, 5, 5, 5, 5, 5, 0, 0, | 1869 | 2, 8, 4, 3, 3, 3, 0, 3, |
1974 | 0, 0, 1, 1, 1, 5, 5, 5, | 1870 | 1, 2, 1, 2, 2, 3, 3, 1, |
1975 | 5, 0, 0, 1, 1, 1, 5, 6, | 1871 | 3, 2, 2, 1, 2, 2, 2, 3, |
1976 | 0, 0, 1, 1, 1, 8, 5, 1, | 1872 | 4, 4, 3, 1, 2, 1, 3, 2, |
1977 | 1, 1, 0, 1, 1, 5, 4, 2, | 1873 | 2, 2, 2, 2, 3, 3, 1, 1, |
1978 | 0, 1, 0, 2, 2, 5, 2, 3, | 1874 | 2, 1, 3, 2, 2, 3, 2, 7, |
1979 | 5, 3, 2, 3, 5, 1, 1, 1, | 1875 | 0, 1, 4, 1, 2, 4, 2, 1, |
1980 | 3, 1, 1, 2, 2, 3, 1, 2, | 1876 | 2, 0, 2, 2, 3, 5, 5, 1, |
1981 | 3, 1, | 1877 | 4, 1, 1, 2, 2, 1, 0, 0, |
1878 | 1, 1, 1, 1, 1, 2, 2, 2, | ||
1879 | 2, 1, 1, 1, 4, 2, 2, 3, | ||
1880 | 1, 4, 4, 6, 1, 3, 1, 1, | ||
1881 | 2, 1, 1, 1, 5, 3, 1, 1, | ||
1882 | 1, 2, 3, 3, 1, 2, 2, 1, | ||
1883 | 4, 1, 2, 5, 2, 1, 1, 0, | ||
1884 | 2, 2, 2, 2, 2, 2, 2, 2, | ||
1885 | 2, 1, 1, 2, 4, 2, 1, 2, | ||
1886 | 2, 2, 6, 1, 1, 2, 1, 2, | ||
1887 | 1, 1, 1, 2, 2, 2, 1, 3, | ||
1888 | 2, 5, 2, 8, 6, 2, 2, 2, | ||
1889 | 2, 3, 1, 3, 1, 2, 1, 3, | ||
1890 | 2, 2, 3, 1, 1, 1, 1, 1, | ||
1891 | 1, 1, 2, 2, 4, 1, 2, 1, | ||
1892 | 0, 1, 1, 1, 1, 0, 1, 2, | ||
1893 | 3, 1, 3, 3, 1, 0, 3, 0, | ||
1894 | 2, 3, 1, 0, 0, 0, 0, 2, | ||
1895 | 2, 2, 2, 1, 5, 2, 2, 5, | ||
1896 | 7, 5, 0, 1, 0, 1, 1, 1, | ||
1897 | 1, 1, 0, 1, 1, 1, 2, 2, | ||
1898 | 3, 3, 4, 7, 5, 7, 5, 3, | ||
1899 | 3, 7, 3, 13, 1, 3, 5, 3, | ||
1900 | 5, 3, 6, 5, 2, 2, 8, 4, | ||
1901 | 1, 2, 3, 2, 10, 2, 2, 0, | ||
1902 | 2, 3, 3, 1, 2, 3, 3, 1, | ||
1903 | 2, 3, 3, 4, 4, 2, 1, 2, | ||
1904 | 2, 3, 2, 2, 5, 3, 2, 3, | ||
1905 | 2, 1, 3, 3, 6, 2, 2, 5, | ||
1906 | 2, 5, 1, 1, 2, 4, 1, 11, | ||
1907 | 1, 3, 8, 4, 2, 1, 0, 4, | ||
1908 | 3, 3, 3, 2, 9, 1, 1, 4, | ||
1909 | 3, 2, 2, 2, 3, 4, 2, 3, | ||
1910 | 2, 4, 3, 2, 2, 3, 3, 4, | ||
1911 | 3, 3, 4, 2, 5, 4, 8, 7, | ||
1912 | 1, 2, 1, 3, 1, 2, 5, 1, | ||
1913 | 2, 2, 2, 2, 1, 3, 2, 2, | ||
1914 | 3, 3, 1, 9, 1, 5, 1, 3, | ||
1915 | 2, 2, 3, 2, 3, 3, 3, 1, | ||
1916 | 3, 3, 2, 2, 4, 5, 3, 3, | ||
1917 | 4, 3, 3, 3, 2, 2, 2, 4, | ||
1918 | 2, 2, 1, 3, 3, 3, 3, 3, | ||
1919 | 3, 2, 2, 3, 2, 3, 3, 2, | ||
1920 | 3, 2, 3, 1, 2, 2, 2, 2, | ||
1921 | 2, 2, 2, 2, 2, 2, 2, 3, | ||
1922 | 2, 3, 2, 3, 5, 3, 3, 1, | ||
1923 | 2, 3, 2, 2, 1, 2, 3, 4, | ||
1924 | 3, 0, 3, 0, 2, 3, 1, 0, | ||
1925 | 0, 0, 0, 2, 3, 2, 4, 6, | ||
1926 | 4, 1, 1, 2, 1, 2, 1, 3, | ||
1927 | 2, 3, 2, 11, 0, 0, 0, 0, | ||
1928 | 0, 0, 0, 1, 0, 0, 0, 5, | ||
1929 | 0, 0, 1, 1, 1, 0, 1, 1, | ||
1930 | 5, 4, 2, 0, 1, 0, 2, 2, | ||
1931 | 5, 2, 3, 5, 3, 2, 3, 5, | ||
1932 | 1, 1, 1, 3, 1, 1, 2, 2, | ||
1933 | 3, 1, 2, 3, 1, 5, 6, 0, | ||
1934 | 0, 0, 0, 0, 0, 0, 0, 5, | ||
1935 | 1, 1, 1, 5, 6, 0, 0, 0, | ||
1936 | 0, 0, 0, 1, 1, 1, 5, 6, | ||
1937 | 0, 0, 0, 0, 0, 0, 1, 1, | ||
1938 | 1, 8, 5, 1, 1, 1, 0, 1, | ||
1939 | 1, 5, 4, 2, 0, 1, 0, 2, | ||
1940 | 2, 5, 2, 3, 5, 3, 2, 3, | ||
1941 | 5, 1, 1, 1, 3, 1, 1, 2, | ||
1942 | 2, 3, 1, 2, 3, 1, | ||
1982 | } | 1943 | } |
1983 | 1944 | ||
1984 | var _hcltok_index_offsets []int16 = []int16{ | 1945 | var _hcltok_index_offsets []int16 = []int16{ |
1985 | 0, 0, 2, 4, 6, 9, 14, 18, | 1946 | 0, 0, 2, 4, 7, 12, 16, 18, |
1986 | 20, 58, 95, 137, 139, 144, 148, 149, | 1947 | 56, 93, 135, 137, 142, 146, 147, 149, |
1987 | 151, 153, 159, 164, 169, 171, 174, 176, | 1948 | 151, 157, 162, 167, 169, 172, 174, 177, |
1988 | 179, 183, 189, 192, 195, 201, 203, 205, | 1949 | 181, 187, 190, 193, 199, 201, 203, 205, |
1989 | 207, 210, 243, 245, 247, 250, 253, 256, | 1950 | 208, 241, 243, 245, 248, 251, 254, 262, |
1990 | 264, 272, 283, 291, 300, 308, 317, 326, | 1951 | 270, 281, 289, 298, 306, 315, 324, 336, |
1991 | 338, 345, 352, 360, 368, 377, 383, 391, | 1952 | 343, 350, 358, 366, 375, 381, 389, 395, |
1992 | 397, 405, 407, 410, 424, 430, 438, 442, | 1953 | 403, 405, 408, 422, 428, 436, 440, 444, |
1993 | 446, 448, 495, 497, 500, 502, 507, 513, | 1954 | 446, 493, 495, 498, 500, 505, 511, 517, |
1994 | 519, 524, 527, 531, 534, 537, 539, 542, | 1955 | 522, 525, 529, 532, 535, 537, 540, 543, |
1995 | 545, 548, 552, 557, 562, 566, 568, 571, | 1956 | 546, 550, 555, 560, 564, 566, 569, 571, |
1996 | 573, 577, 580, 583, 586, 589, 593, 598, | 1957 | 575, 578, 581, 584, 587, 591, 596, 600, |
1997 | 602, 604, 606, 609, 611, 615, 618, 621, | 1958 | 602, 604, 607, 609, 613, 616, 619, 627, |
1998 | 629, 633, 641, 657, 659, 664, 666, 670, | 1959 | 631, 639, 655, 657, 662, 664, 668, 679, |
1999 | 681, 685, 687, 690, 692, 695, 700, 704, | 1960 | 683, 685, 688, 690, 693, 698, 702, 708, |
2000 | 710, 716, 727, 732, 735, 738, 741, 744, | 1961 | 714, 725, 730, 733, 736, 739, 742, 744, |
2001 | 746, 750, 751, 754, 756, 786, 788, 790, | 1962 | 748, 749, 752, 754, 784, 786, 788, 791, |
2002 | 793, 797, 800, 804, 806, 808, 810, 816, | 1963 | 795, 798, 802, 804, 806, 808, 814, 817, |
2003 | 819, 822, 826, 828, 833, 838, 845, 848, | 1964 | 820, 824, 826, 831, 836, 843, 846, 850, |
2004 | 852, 856, 858, 861, 881, 883, 885, 892, | 1965 | 854, 856, 859, 879, 881, 883, 890, 894, |
2005 | 896, 898, 900, 902, 905, 909, 913, 915, | 1966 | 896, 898, 900, 903, 907, 911, 913, 917, |
2006 | 919, 922, 924, 929, 947, 986, 992, 995, | 1967 | 920, 922, 927, 945, 984, 990, 993, 995, |
2007 | 997, 999, 1001, 1004, 1007, 1010, 1013, 1016, | 1968 | 997, 999, 1002, 1005, 1008, 1011, 1014, 1018, |
2008 | 1020, 1023, 1026, 1029, 1031, 1033, 1036, 1043, | 1969 | 1021, 1024, 1027, 1029, 1031, 1034, 1041, 1044, |
2009 | 1046, 1048, 1051, 1054, 1057, 1065, 1067, 1069, | 1970 | 1046, 1049, 1052, 1055, 1063, 1065, 1067, 1070, |
2010 | 1072, 1074, 1077, 1079, 1081, 1111, 1114, 1117, | 1971 | 1072, 1075, 1077, 1079, 1109, 1112, 1115, 1118, |
2011 | 1120, 1123, 1128, 1132, 1139, 1142, 1151, 1160, | 1972 | 1121, 1126, 1130, 1137, 1140, 1149, 1158, 1161, |
2012 | 1163, 1167, 1170, 1173, 1177, 1179, 1183, 1185, | 1973 | 1165, 1168, 1171, 1175, 1177, 1181, 1183, 1186, |
2013 | 1188, 1190, 1194, 1198, 1202, 1210, 1212, 1214, | 1974 | 1188, 1192, 1196, 1200, 1208, 1210, 1212, 1216, |
2014 | 1218, 1222, 1224, 1237, 1239, 1242, 1245, 1250, | 1975 | 1220, 1222, 1235, 1237, 1240, 1243, 1248, 1250, |
2015 | 1252, 1255, 1257, 1259, 1262, 1267, 1269, 1271, | 1976 | 1253, 1255, 1257, 1260, 1265, 1267, 1269, 1274, |
2016 | 1276, 1278, 1281, 1285, 1305, 1309, 1313, 1315, | 1977 | 1276, 1279, 1283, 1303, 1307, 1311, 1313, 1315, |
2017 | 1317, 1325, 1327, 1334, 1339, 1341, 1345, 1348, | 1978 | 1323, 1325, 1332, 1337, 1339, 1343, 1346, 1349, |
2018 | 1351, 1354, 1358, 1361, 1364, 1368, 1378, 1384, | 1979 | 1352, 1356, 1359, 1362, 1366, 1376, 1382, 1385, |
2019 | 1387, 1390, 1400, 1420, 1426, 1429, 1431, 1435, | 1980 | 1388, 1398, 1418, 1424, 1427, 1429, 1433, 1435, |
2020 | 1437, 1440, 1442, 1446, 1448, 1450, 1454, 1456, | 1981 | 1438, 1440, 1444, 1446, 1448, 1452, 1454, 1458, |
2021 | 1460, 1465, 1471, 1473, 1475, 1478, 1480, 1484, | 1982 | 1463, 1469, 1471, 1473, 1476, 1478, 1482, 1489, |
2022 | 1491, 1494, 1496, 1499, 1503, 1533, 1538, 1540, | 1983 | 1492, 1494, 1497, 1501, 1531, 1536, 1538, 1541, |
2023 | 1543, 1547, 1556, 1561, 1569, 1573, 1581, 1585, | 1984 | 1545, 1554, 1559, 1567, 1571, 1579, 1583, 1591, |
2024 | 1593, 1597, 1608, 1610, 1616, 1619, 1627, 1631, | 1985 | 1595, 1606, 1608, 1614, 1617, 1625, 1629, 1634, |
2025 | 1636, 1641, 1646, 1648, 1651, 1666, 1670, 1672, | 1986 | 1639, 1644, 1646, 1649, 1664, 1668, 1670, 1673, |
2026 | 1675, 1677, 1726, 1729, 1736, 1739, 1741, 1745, | 1987 | 1675, 1724, 1727, 1734, 1737, 1739, 1743, 1747, |
2027 | 1749, 1752, 1756, 1758, 1761, 1763, 1765, 1767, | 1988 | 1750, 1754, 1756, 1759, 1761, 1763, 1765, 1767, |
2028 | 1769, 1773, 1775, 1777, 1780, 1784, 1798, 1801, | 1989 | 1771, 1773, 1775, 1778, 1782, 1796, 1799, 1803, |
2029 | 1805, 1808, 1813, 1824, 1829, 1832, 1862, 1866, | 1990 | 1806, 1811, 1822, 1827, 1830, 1860, 1864, 1867, |
2030 | 1869, 1874, 1876, 1880, 1883, 1886, 1888, 1893, | 1991 | 1872, 1874, 1878, 1881, 1884, 1886, 1891, 1893, |
2031 | 1895, 1901, 1906, 1912, 1914, 1934, 1942, 1945, | 1992 | 1899, 1904, 1910, 1912, 1932, 1940, 1943, 1945, |
2032 | 1947, 1965, 2003, 2005, 2008, 2010, 2015, 2018, | 1993 | 1963, 2001, 2003, 2006, 2008, 2013, 2016, 2045, |
2033 | 2047, 2049, 2051, 2053, 2055, 2058, 2060, 2064, | 1994 | 2047, 2049, 2051, 2053, 2056, 2058, 2062, 2065, |
2034 | 2067, 2069, 2072, 2074, 2076, 2079, 2081, 2083, | 1995 | 2067, 2070, 2072, 2074, 2077, 2079, 2081, 2083, |
2035 | 2085, 2087, 2089, 2092, 2095, 2098, 2111, 2113, | 1996 | 2085, 2087, 2090, 2093, 2096, 2109, 2111, 2115, |
2036 | 2117, 2120, 2122, 2127, 2130, 2144, 2147, 2156, | 1997 | 2118, 2120, 2125, 2128, 2142, 2145, 2154, 2156, |
2037 | 2158, 2163, 2167, 2168, 2170, 2172, 2178, 2183, | 1998 | 2161, 2165, 2166, 2168, 2170, 2176, 2181, 2186, |
2038 | 2188, 2190, 2193, 2195, 2198, 2202, 2208, 2211, | 1999 | 2188, 2191, 2193, 2196, 2200, 2206, 2209, 2212, |
2039 | 2214, 2220, 2222, 2224, 2226, 2229, 2262, 2264, | 2000 | 2218, 2220, 2222, 2224, 2227, 2260, 2262, 2264, |
2040 | 2266, 2269, 2272, 2275, 2283, 2291, 2302, 2310, | 2001 | 2267, 2270, 2273, 2281, 2289, 2300, 2308, 2317, |
2041 | 2319, 2327, 2336, 2345, 2357, 2364, 2371, 2379, | 2002 | 2325, 2334, 2343, 2355, 2362, 2369, 2377, 2385, |
2042 | 2387, 2396, 2402, 2410, 2416, 2424, 2426, 2429, | 2003 | 2394, 2400, 2408, 2414, 2422, 2424, 2427, 2441, |
2043 | 2443, 2449, 2457, 2461, 2465, 2467, 2514, 2516, | 2004 | 2447, 2455, 2459, 2463, 2465, 2512, 2514, 2517, |
2044 | 2519, 2521, 2526, 2532, 2538, 2543, 2546, 2550, | 2005 | 2519, 2524, 2530, 2536, 2541, 2544, 2548, 2551, |
2045 | 2553, 2556, 2558, 2561, 2564, 2567, 2571, 2576, | 2006 | 2554, 2556, 2559, 2562, 2565, 2569, 2574, 2579, |
2046 | 2581, 2585, 2587, 2590, 2592, 2596, 2599, 2602, | 2007 | 2583, 2585, 2588, 2590, 2594, 2597, 2600, 2603, |
2047 | 2605, 2608, 2612, 2617, 2621, 2623, 2625, 2628, | 2008 | 2606, 2610, 2615, 2619, 2621, 2623, 2626, 2628, |
2048 | 2630, 2634, 2637, 2640, 2648, 2652, 2660, 2676, | 2009 | 2632, 2635, 2638, 2646, 2650, 2658, 2674, 2676, |
2049 | 2678, 2683, 2685, 2689, 2700, 2704, 2706, 2709, | 2010 | 2681, 2683, 2687, 2698, 2702, 2704, 2707, 2709, |
2050 | 2711, 2714, 2719, 2723, 2729, 2735, 2746, 2751, | 2011 | 2712, 2717, 2721, 2727, 2733, 2744, 2749, 2752, |
2051 | 2754, 2757, 2760, 2763, 2765, 2769, 2770, 2773, | 2012 | 2755, 2758, 2761, 2763, 2767, 2768, 2771, 2773, |
2052 | 2775, 2805, 2807, 2809, 2812, 2816, 2819, 2823, | 2013 | 2803, 2805, 2807, 2810, 2814, 2817, 2821, 2823, |
2053 | 2825, 2827, 2829, 2835, 2838, 2841, 2845, 2847, | 2014 | 2825, 2827, 2833, 2836, 2839, 2843, 2845, 2850, |
2054 | 2852, 2857, 2864, 2867, 2871, 2875, 2877, 2880, | 2015 | 2855, 2862, 2865, 2869, 2873, 2875, 2878, 2898, |
2055 | 2900, 2902, 2904, 2911, 2915, 2917, 2919, 2921, | 2016 | 2900, 2902, 2909, 2913, 2915, 2917, 2919, 2922, |
2056 | 2924, 2928, 2932, 2934, 2938, 2941, 2943, 2948, | 2017 | 2926, 2930, 2932, 2936, 2939, 2941, 2946, 2964, |
2057 | 2966, 3005, 3011, 3014, 3016, 3018, 3020, 3023, | 2018 | 3003, 3009, 3012, 3014, 3016, 3018, 3021, 3024, |
2058 | 3026, 3029, 3032, 3035, 3039, 3042, 3045, 3048, | 2019 | 3027, 3030, 3033, 3037, 3040, 3043, 3046, 3048, |
2059 | 3050, 3052, 3055, 3062, 3065, 3067, 3070, 3073, | 2020 | 3050, 3053, 3060, 3063, 3065, 3068, 3071, 3074, |
2060 | 3076, 3084, 3086, 3088, 3091, 3093, 3096, 3098, | 2021 | 3082, 3084, 3086, 3089, 3091, 3094, 3096, 3098, |
2061 | 3100, 3130, 3133, 3136, 3139, 3142, 3147, 3151, | 2022 | 3128, 3131, 3134, 3137, 3140, 3145, 3149, 3156, |
2062 | 3158, 3161, 3170, 3179, 3182, 3186, 3189, 3192, | 2023 | 3159, 3168, 3177, 3180, 3184, 3187, 3190, 3194, |
2063 | 3196, 3198, 3202, 3204, 3207, 3209, 3213, 3217, | 2024 | 3196, 3200, 3202, 3205, 3207, 3211, 3215, 3219, |
2064 | 3221, 3229, 3231, 3233, 3237, 3241, 3243, 3256, | 2025 | 3227, 3229, 3231, 3235, 3239, 3241, 3254, 3256, |
2065 | 3258, 3261, 3264, 3269, 3271, 3274, 3276, 3278, | 2026 | 3259, 3262, 3267, 3269, 3272, 3274, 3276, 3279, |
2066 | 3281, 3286, 3288, 3290, 3295, 3297, 3300, 3304, | 2027 | 3284, 3286, 3288, 3293, 3295, 3298, 3302, 3322, |
2067 | 3324, 3328, 3332, 3334, 3336, 3344, 3346, 3353, | 2028 | 3326, 3330, 3332, 3334, 3342, 3344, 3351, 3356, |
2068 | 3358, 3360, 3364, 3367, 3370, 3373, 3377, 3380, | 2029 | 3358, 3362, 3365, 3368, 3371, 3375, 3378, 3381, |
2069 | 3383, 3387, 3397, 3403, 3406, 3409, 3419, 3439, | 2030 | 3385, 3395, 3401, 3404, 3407, 3417, 3437, 3443, |
2070 | 3445, 3448, 3450, 3454, 3456, 3459, 3461, 3465, | 2031 | 3446, 3448, 3452, 3454, 3457, 3459, 3463, 3465, |
2071 | 3467, 3469, 3473, 3475, 3477, 3483, 3486, 3491, | 2032 | 3467, 3471, 3473, 3475, 3481, 3484, 3489, 3494, |
2072 | 3496, 3502, 3512, 3520, 3532, 3539, 3549, 3555, | 2033 | 3500, 3510, 3518, 3530, 3537, 3547, 3553, 3565, |
2073 | 3567, 3573, 3591, 3594, 3602, 3608, 3618, 3625, | 2034 | 3571, 3589, 3592, 3600, 3606, 3616, 3623, 3630, |
2074 | 3632, 3640, 3648, 3651, 3656, 3676, 3682, 3685, | 2035 | 3638, 3646, 3649, 3654, 3674, 3680, 3683, 3687, |
2075 | 3689, 3693, 3697, 3709, 3712, 3717, 3718, 3724, | 2036 | 3691, 3695, 3707, 3710, 3715, 3716, 3722, 3729, |
2076 | 3731, 3737, 3740, 3743, 3747, 3751, 3754, 3757, | 2037 | 3735, 3738, 3741, 3745, 3749, 3752, 3755, 3760, |
2077 | 3762, 3766, 3772, 3778, 3781, 3785, 3788, 3791, | 2038 | 3764, 3770, 3776, 3779, 3783, 3786, 3789, 3794, |
2078 | 3796, 3799, 3802, 3808, 3812, 3815, 3819, 3822, | 2039 | 3797, 3800, 3806, 3810, 3813, 3817, 3820, 3823, |
2079 | 3825, 3829, 3833, 3840, 3843, 3846, 3852, 3855, | 2040 | 3827, 3831, 3838, 3841, 3844, 3850, 3853, 3860, |
2080 | 3862, 3864, 3866, 3869, 3878, 3883, 3897, 3901, | 2041 | 3862, 3864, 3867, 3876, 3881, 3895, 3899, 3903, |
2081 | 3905, 3920, 3926, 3929, 3932, 3934, 3939, 3945, | 2042 | 3918, 3924, 3927, 3930, 3932, 3937, 3943, 3947, |
2082 | 3949, 3957, 3963, 3973, 3976, 3979, 3984, 3988, | 2043 | 3955, 3961, 3971, 3974, 3977, 3982, 3986, 3989, |
2083 | 3991, 3994, 3997, 4001, 4006, 4010, 4014, 4017, | 2044 | 3992, 3995, 3999, 4004, 4008, 4012, 4015, 4020, |
2084 | 4022, 4027, 4030, 4036, 4040, 4046, 4051, 4055, | 2045 | 4025, 4028, 4034, 4038, 4044, 4049, 4053, 4057, |
2085 | 4059, 4067, 4070, 4078, 4084, 4094, 4105, 4108, | 2046 | 4065, 4068, 4076, 4082, 4092, 4103, 4106, 4109, |
2086 | 4111, 4113, 4117, 4119, 4122, 4133, 4137, 4140, | 2047 | 4111, 4115, 4117, 4120, 4131, 4135, 4138, 4141, |
2087 | 4143, 4146, 4149, 4151, 4155, 4159, 4162, 4166, | 2048 | 4144, 4147, 4149, 4153, 4157, 4160, 4164, 4169, |
2088 | 4171, 4174, 4184, 4186, 4227, 4233, 4237, 4240, | 2049 | 4172, 4182, 4184, 4225, 4231, 4235, 4238, 4241, |
2089 | 4243, 4247, 4250, 4254, 4258, 4263, 4265, 4269, | 2050 | 4245, 4248, 4252, 4256, 4261, 4263, 4267, 4271, |
2090 | 4273, 4276, 4279, 4284, 4293, 4297, 4302, 4307, | 2051 | 4274, 4277, 4282, 4291, 4295, 4300, 4305, 4309, |
2091 | 4311, 4318, 4322, 4325, 4329, 4332, 4337, 4340, | 2052 | 4316, 4320, 4323, 4327, 4330, 4335, 4338, 4341, |
2092 | 4343, 4373, 4377, 4381, 4385, 4389, 4394, 4398, | 2053 | 4371, 4375, 4379, 4383, 4387, 4392, 4396, 4402, |
2093 | 4404, 4408, 4416, 4419, 4424, 4428, 4431, 4436, | 2054 | 4406, 4414, 4417, 4422, 4426, 4429, 4434, 4437, |
2094 | 4439, 4443, 4446, 4449, 4452, 4455, 4458, 4462, | 2055 | 4441, 4444, 4447, 4450, 4453, 4456, 4460, 4464, |
2095 | 4466, 4469, 4479, 4482, 4485, 4490, 4496, 4499, | 2056 | 4467, 4477, 4480, 4483, 4488, 4494, 4497, 4512, |
2096 | 4514, 4517, 4521, 4527, 4531, 4535, 4538, 4542, | 2057 | 4515, 4519, 4525, 4529, 4533, 4536, 4540, 4547, |
2097 | 4549, 4552, 4555, 4561, 4564, 4568, 4573, 4589, | 2058 | 4550, 4553, 4559, 4562, 4566, 4571, 4587, 4589, |
2098 | 4591, 4599, 4601, 4609, 4615, 4617, 4621, 4624, | 2059 | 4597, 4599, 4607, 4613, 4615, 4619, 4622, 4625, |
2099 | 4627, 4630, 4634, 4645, 4648, 4660, 4684, 4692, | 2060 | 4628, 4632, 4643, 4646, 4658, 4682, 4690, 4692, |
2100 | 4694, 4698, 4701, 4706, 4709, 4711, 4716, 4719, | 2061 | 4696, 4699, 4704, 4707, 4709, 4714, 4717, 4723, |
2101 | 4725, 4728, 4730, 4732, 4734, 4736, 4738, 4740, | 2062 | 4726, 4734, 4736, 4738, 4740, 4742, 4744, 4746, |
2102 | 4742, 4744, 4746, 4748, 4750, 4752, 4754, 4756, | 2063 | 4748, 4750, 4752, 4755, 4758, 4760, 4762, 4764, |
2103 | 4758, 4760, 4762, 4764, 4766, 4768, 4770, 4772, | 2064 | 4766, 4769, 4772, 4777, 4781, 4782, 4784, 4786, |
2104 | 4777, 4781, 4782, 4784, 4786, 4792, 4797, 4802, | 2065 | 4792, 4797, 4802, 4804, 4807, 4809, 4812, 4816, |
2105 | 4804, 4807, 4809, 4812, 4816, 4822, 4825, 4828, | 2066 | 4822, 4825, 4828, 4834, 4836, 4838, 4840, 4843, |
2106 | 4834, 4836, 4838, 4840, 4843, 4876, 4878, 4880, | 2067 | 4876, 4878, 4880, 4883, 4886, 4889, 4897, 4905, |
2107 | 4883, 4886, 4889, 4897, 4905, 4916, 4924, 4933, | 2068 | 4916, 4924, 4933, 4941, 4950, 4959, 4971, 4978, |
2108 | 4941, 4950, 4959, 4971, 4978, 4985, 4993, 5001, | 2069 | 4985, 4993, 5001, 5010, 5016, 5024, 5030, 5038, |
2109 | 5010, 5016, 5024, 5030, 5038, 5040, 5043, 5057, | 2070 | 5040, 5043, 5057, 5063, 5071, 5075, 5079, 5081, |
2110 | 5063, 5071, 5075, 5079, 5081, 5128, 5130, 5133, | 2071 | 5128, 5130, 5133, 5135, 5140, 5146, 5152, 5157, |
2111 | 5135, 5140, 5146, 5152, 5157, 5160, 5164, 5167, | 2072 | 5160, 5164, 5167, 5170, 5172, 5175, 5178, 5181, |
2112 | 5170, 5172, 5175, 5178, 5181, 5185, 5190, 5195, | 2073 | 5185, 5190, 5195, 5199, 5201, 5204, 5206, 5210, |
2113 | 5199, 5201, 5204, 5206, 5210, 5213, 5216, 5219, | 2074 | 5213, 5216, 5219, 5222, 5226, 5231, 5235, 5237, |
2114 | 5222, 5226, 5231, 5235, 5237, 5239, 5242, 5244, | 2075 | 5239, 5242, 5244, 5248, 5251, 5254, 5262, 5266, |
2115 | 5248, 5251, 5254, 5262, 5266, 5274, 5290, 5292, | 2076 | 5274, 5290, 5292, 5297, 5299, 5303, 5314, 5318, |
2116 | 5297, 5299, 5303, 5314, 5318, 5320, 5323, 5325, | 2077 | 5320, 5323, 5325, 5328, 5333, 5337, 5343, 5349, |
2117 | 5328, 5333, 5337, 5343, 5349, 5360, 5365, 5368, | 2078 | 5360, 5365, 5368, 5371, 5374, 5377, 5379, 5383, |
2118 | 5371, 5374, 5377, 5379, 5383, 5384, 5387, 5389, | 2079 | 5384, 5387, 5389, 5419, 5421, 5423, 5426, 5430, |
2119 | 5419, 5421, 5423, 5426, 5430, 5433, 5437, 5439, | 2080 | 5433, 5437, 5439, 5441, 5443, 5449, 5452, 5455, |
2120 | 5441, 5443, 5449, 5452, 5455, 5459, 5461, 5466, | 2081 | 5459, 5461, 5466, 5471, 5478, 5481, 5485, 5489, |
2121 | 5471, 5478, 5481, 5485, 5489, 5491, 5494, 5514, | 2082 | 5491, 5494, 5514, 5516, 5518, 5525, 5529, 5531, |
2122 | 5516, 5518, 5525, 5529, 5531, 5533, 5535, 5538, | 2083 | 5533, 5535, 5538, 5542, 5546, 5548, 5552, 5555, |
2123 | 5542, 5546, 5548, 5552, 5555, 5557, 5562, 5580, | 2084 | 5557, 5562, 5580, 5619, 5625, 5628, 5630, 5632, |
2124 | 5619, 5625, 5628, 5630, 5632, 5634, 5637, 5640, | 2085 | 5634, 5637, 5640, 5643, 5646, 5649, 5653, 5656, |
2125 | 5643, 5646, 5649, 5653, 5656, 5659, 5662, 5664, | 2086 | 5659, 5662, 5664, 5666, 5669, 5676, 5679, 5681, |
2126 | 5666, 5669, 5676, 5679, 5681, 5684, 5687, 5690, | 2087 | 5684, 5687, 5690, 5698, 5700, 5702, 5705, 5707, |
2127 | 5698, 5700, 5702, 5705, 5707, 5710, 5712, 5714, | 2088 | 5710, 5712, 5714, 5744, 5747, 5750, 5753, 5756, |
2128 | 5744, 5747, 5750, 5753, 5756, 5761, 5765, 5772, | 2089 | 5761, 5765, 5772, 5775, 5784, 5793, 5796, 5800, |
2129 | 5775, 5784, 5793, 5796, 5800, 5803, 5806, 5810, | 2090 | 5803, 5806, 5810, 5812, 5816, 5818, 5821, 5823, |
2130 | 5812, 5816, 5818, 5821, 5823, 5827, 5831, 5835, | 2091 | 5827, 5831, 5835, 5843, 5845, 5847, 5851, 5855, |
2131 | 5843, 5845, 5847, 5851, 5855, 5857, 5870, 5872, | 2092 | 5857, 5870, 5872, 5875, 5878, 5883, 5885, 5888, |
2132 | 5875, 5878, 5883, 5885, 5888, 5890, 5892, 5895, | 2093 | 5890, 5892, 5895, 5900, 5902, 5904, 5909, 5911, |
2133 | 5900, 5902, 5904, 5909, 5911, 5914, 5918, 5938, | 2094 | 5914, 5918, 5938, 5942, 5946, 5948, 5950, 5958, |
2134 | 5942, 5946, 5948, 5950, 5958, 5960, 5967, 5972, | 2095 | 5960, 5967, 5972, 5974, 5978, 5981, 5984, 5987, |
2135 | 5974, 5978, 5981, 5984, 5987, 5991, 5994, 5997, | 2096 | 5991, 5994, 5997, 6001, 6011, 6017, 6020, 6023, |
2136 | 6001, 6011, 6017, 6020, 6023, 6033, 6053, 6059, | 2097 | 6033, 6053, 6059, 6062, 6064, 6068, 6070, 6073, |
2137 | 6062, 6064, 6068, 6070, 6073, 6075, 6079, 6081, | 2098 | 6075, 6079, 6081, 6083, 6087, 6089, 6091, 6097, |
2138 | 6083, 6087, 6089, 6091, 6097, 6100, 6105, 6110, | 2099 | 6100, 6105, 6110, 6116, 6126, 6134, 6146, 6153, |
2139 | 6116, 6126, 6134, 6146, 6153, 6163, 6169, 6181, | 2100 | 6163, 6169, 6181, 6187, 6205, 6208, 6216, 6222, |
2140 | 6187, 6205, 6208, 6216, 6222, 6232, 6239, 6246, | 2101 | 6232, 6239, 6246, 6254, 6262, 6265, 6270, 6290, |
2141 | 6254, 6262, 6265, 6270, 6290, 6296, 6299, 6303, | 2102 | 6296, 6299, 6303, 6307, 6311, 6323, 6326, 6331, |
2142 | 6307, 6311, 6323, 6326, 6331, 6332, 6338, 6345, | 2103 | 6332, 6338, 6345, 6351, 6354, 6357, 6361, 6365, |
2143 | 6351, 6354, 6357, 6361, 6365, 6368, 6371, 6376, | 2104 | 6368, 6371, 6376, 6380, 6386, 6392, 6395, 6399, |
2144 | 6380, 6386, 6392, 6395, 6399, 6402, 6405, 6410, | 2105 | 6402, 6405, 6410, 6413, 6416, 6422, 6426, 6429, |
2145 | 6413, 6416, 6422, 6426, 6429, 6433, 6436, 6439, | 2106 | 6433, 6436, 6439, 6443, 6447, 6454, 6457, 6460, |
2146 | 6443, 6447, 6454, 6457, 6460, 6466, 6469, 6476, | 2107 | 6466, 6469, 6476, 6478, 6480, 6483, 6492, 6497, |
2147 | 6478, 6480, 6483, 6492, 6497, 6511, 6515, 6519, | 2108 | 6511, 6515, 6519, 6534, 6540, 6543, 6546, 6548, |
2148 | 6534, 6540, 6543, 6546, 6548, 6553, 6559, 6563, | 2109 | 6553, 6559, 6563, 6571, 6577, 6587, 6590, 6593, |
2149 | 6571, 6577, 6587, 6590, 6593, 6598, 6602, 6605, | 2110 | 6598, 6602, 6605, 6608, 6611, 6615, 6620, 6624, |
2150 | 6608, 6611, 6615, 6620, 6624, 6628, 6631, 6636, | 2111 | 6628, 6631, 6636, 6641, 6644, 6650, 6654, 6660, |
2151 | 6641, 6644, 6650, 6654, 6660, 6665, 6669, 6673, | 2112 | 6665, 6669, 6673, 6681, 6684, 6692, 6698, 6708, |
2152 | 6681, 6684, 6692, 6698, 6708, 6719, 6722, 6725, | 2113 | 6719, 6722, 6725, 6727, 6731, 6733, 6736, 6747, |
2153 | 6727, 6731, 6733, 6736, 6747, 6751, 6754, 6757, | 2114 | 6751, 6754, 6757, 6760, 6763, 6765, 6769, 6773, |
2154 | 6760, 6763, 6765, 6769, 6773, 6776, 6780, 6785, | 2115 | 6776, 6780, 6785, 6788, 6798, 6800, 6841, 6847, |
2155 | 6788, 6798, 6800, 6841, 6847, 6851, 6854, 6857, | 2116 | 6851, 6854, 6857, 6861, 6864, 6868, 6872, 6877, |
2156 | 6861, 6864, 6868, 6872, 6877, 6879, 6883, 6887, | 2117 | 6879, 6883, 6887, 6890, 6893, 6898, 6907, 6911, |
2157 | 6890, 6893, 6898, 6907, 6911, 6916, 6921, 6925, | 2118 | 6916, 6921, 6925, 6932, 6936, 6939, 6943, 6946, |
2158 | 6932, 6936, 6939, 6943, 6946, 6951, 6954, 6957, | 2119 | 6951, 6954, 6957, 6987, 6991, 6995, 6999, 7003, |
2159 | 6987, 6991, 6995, 6999, 7003, 7008, 7012, 7018, | 2120 | 7008, 7012, 7018, 7022, 7030, 7033, 7038, 7042, |
2160 | 7022, 7030, 7033, 7038, 7042, 7045, 7050, 7053, | 2121 | 7045, 7050, 7053, 7057, 7060, 7063, 7066, 7069, |
2161 | 7057, 7060, 7063, 7066, 7069, 7072, 7076, 7080, | 2122 | 7072, 7076, 7080, 7083, 7093, 7096, 7099, 7104, |
2162 | 7083, 7093, 7096, 7099, 7104, 7110, 7113, 7128, | 2123 | 7110, 7113, 7128, 7131, 7135, 7141, 7145, 7149, |
2163 | 7131, 7135, 7141, 7145, 7149, 7152, 7156, 7163, | 2124 | 7152, 7156, 7163, 7166, 7169, 7175, 7178, 7182, |
2164 | 7166, 7169, 7175, 7178, 7182, 7187, 7203, 7205, | 2125 | 7187, 7203, 7205, 7213, 7215, 7223, 7229, 7231, |
2165 | 7213, 7215, 7223, 7229, 7231, 7235, 7238, 7241, | 2126 | 7235, 7238, 7241, 7244, 7248, 7259, 7262, 7274, |
2166 | 7244, 7248, 7259, 7262, 7274, 7298, 7306, 7308, | 2127 | 7298, 7306, 7308, 7312, 7315, 7320, 7323, 7325, |
2167 | 7312, 7315, 7320, 7323, 7325, 7330, 7333, 7339, | 2128 | 7330, 7333, 7339, 7342, 7407, 7410, 7412, 7414, |
2168 | 7342, 7408, 7411, 7413, 7415, 7417, 7419, 7421, | 2129 | 7416, 7418, 7420, 7423, 7428, 7431, 7434, 7436, |
2169 | 7424, 7426, 7431, 7434, 7437, 7439, 7479, 7481, | 2130 | 7476, 7478, 7480, 7482, 7487, 7491, 7492, 7494, |
2170 | 7483, 7485, 7490, 7494, 7495, 7497, 7499, 7506, | 2131 | 7496, 7503, 7510, 7517, 7519, 7521, 7523, 7526, |
2171 | 7513, 7520, 7522, 7524, 7526, 7529, 7532, 7538, | 2132 | 7529, 7535, 7538, 7543, 7550, 7555, 7558, 7562, |
2172 | 7541, 7546, 7553, 7558, 7561, 7565, 7572, 7604, | 2133 | 7569, 7601, 7650, 7665, 7678, 7683, 7685, 7689, |
2173 | 7653, 7668, 7681, 7686, 7688, 7692, 7723, 7729, | 2134 | 7720, 7726, 7728, 7749, 7769, 7771, 7783, 7794, |
2174 | 7731, 7752, 7772, 7774, 7786, 7798, 7810, 7822, | 2135 | 7797, 7800, 7801, 7803, 7805, 7807, 7810, 7812, |
2175 | 7833, 7841, 7854, 7867, 7880, 7892, 7900, 7913, | 2136 | 7820, 7822, 7824, 7826, 7836, 7845, 7848, 7852, |
2176 | 7925, 7937, 7949, 7961, 7973, 7985, 7997, 7999, | 2137 | 7856, 7859, 7861, 7863, 7865, 7867, 7869, 7879, |
2177 | 8001, 8003, 8005, 8007, 8009, 8011, 8021, 8031, | 2138 | 7888, 7891, 7895, 7899, 7902, 7904, 7906, 7908, |
2178 | 8041, 8051, 8053, 8055, 8057, 8059, 8061, 8071, | 2139 | 7910, 7912, 7954, 7994, 7996, 8001, 8005, 8006, |
2179 | 8080, 8082, 8084, 8086, 8088, 8090, 8132, 8172, | 2140 | 8008, 8010, 8017, 8024, 8031, 8033, 8035, 8037, |
2180 | 8174, 8179, 8183, 8184, 8186, 8188, 8195, 8202, | 2141 | 8040, 8043, 8049, 8052, 8057, 8064, 8069, 8072, |
2181 | 8209, 8211, 8213, 8215, 8218, 8221, 8227, 8230, | 2142 | 8076, 8083, 8115, 8164, 8179, 8192, 8197, 8199, |
2182 | 8235, 8242, 8247, 8250, 8254, 8261, 8293, 8342, | 2143 | 8203, 8234, 8240, 8242, 8263, 8283, |
2183 | 8357, 8370, 8375, 8377, 8381, 8412, 8418, 8420, | ||
2184 | 8441, 8461, | ||
2185 | } | 2144 | } |
2186 | 2145 | ||
2187 | var _hcltok_indicies []int16 = []int16{ | 2146 | var _hcltok_indicies []int16 = []int16{ |
2188 | 2, 1, 4, 3, 6, 5, 6, 7, | 2147 | 1, 0, 3, 2, 3, 4, 2, 6, |
2189 | 5, 9, 11, 11, 10, 8, 12, 12, | 2148 | 8, 8, 7, 5, 9, 9, 7, 5, |
2190 | 10, 8, 10, 8, 13, 14, 15, 16, | 2149 | 7, 5, 10, 11, 12, 13, 15, 16, |
2191 | 18, 19, 20, 21, 22, 23, 24, 25, | 2150 | 17, 18, 19, 20, 21, 22, 23, 24, |
2192 | 26, 27, 28, 29, 30, 31, 32, 33, | 2151 | 25, 26, 27, 28, 29, 30, 31, 32, |
2193 | 34, 35, 36, 37, 38, 39, 40, 42, | 2152 | 33, 34, 35, 36, 37, 39, 40, 41, |
2194 | 43, 44, 45, 46, 14, 14, 17, 17, | 2153 | 42, 43, 11, 11, 14, 14, 38, 0, |
2195 | 41, 3, 14, 15, 16, 18, 19, 20, | 2154 | 11, 12, 13, 15, 16, 17, 18, 19, |
2196 | 21, 22, 23, 24, 25, 26, 27, 28, | 2155 | 20, 21, 22, 23, 24, 25, 26, 27, |
2197 | 29, 30, 31, 32, 33, 34, 35, 36, | 2156 | 28, 29, 30, 31, 32, 33, 34, 35, |
2198 | 37, 38, 39, 40, 42, 43, 44, 45, | 2157 | 36, 37, 39, 40, 41, 42, 43, 11, |
2199 | 46, 14, 14, 17, 17, 41, 3, 47, | 2158 | 11, 14, 14, 38, 0, 44, 45, 11, |
2200 | 48, 14, 14, 49, 16, 18, 19, 20, | 2159 | 11, 46, 13, 15, 16, 17, 16, 47, |
2201 | 19, 50, 51, 23, 52, 25, 26, 53, | 2160 | 48, 20, 49, 22, 23, 50, 51, 52, |
2202 | 54, 55, 56, 57, 58, 59, 60, 61, | 2161 | 53, 54, 55, 56, 57, 58, 59, 60, |
2203 | 62, 63, 64, 65, 40, 42, 66, 44, | 2162 | 61, 62, 37, 39, 63, 41, 64, 65, |
2204 | 67, 68, 69, 14, 14, 14, 17, 41, | 2163 | 66, 11, 11, 11, 14, 38, 0, 44, |
2205 | 3, 47, 3, 14, 14, 14, 14, 3, | 2164 | 0, 11, 11, 11, 11, 0, 11, 11, |
2206 | 14, 14, 14, 3, 14, 3, 14, 3, | 2165 | 11, 0, 11, 0, 11, 11, 0, 0, |
2207 | 14, 3, 3, 3, 3, 3, 14, 3, | 2166 | 0, 0, 0, 0, 11, 0, 0, 0, |
2208 | 3, 3, 3, 14, 14, 14, 14, 14, | 2167 | 0, 11, 11, 11, 11, 11, 0, 0, |
2209 | 3, 3, 14, 3, 3, 14, 3, 14, | 2168 | 11, 0, 0, 11, 0, 11, 0, 0, |
2210 | 3, 3, 14, 3, 3, 3, 14, 14, | 2169 | 11, 0, 0, 0, 11, 11, 11, 11, |
2211 | 14, 14, 14, 14, 3, 14, 14, 3, | 2170 | 11, 11, 0, 11, 11, 0, 11, 11, |
2212 | 14, 14, 3, 3, 3, 3, 3, 3, | 2171 | 0, 0, 0, 0, 0, 0, 11, 11, |
2213 | 14, 14, 3, 3, 14, 3, 14, 14, | 2172 | 0, 0, 11, 0, 11, 11, 11, 0, |
2214 | 14, 3, 70, 71, 72, 73, 17, 74, | 2173 | 67, 68, 69, 70, 14, 71, 72, 73, |
2215 | 75, 76, 77, 78, 79, 80, 81, 82, | 2174 | 74, 75, 76, 77, 78, 79, 80, 81, |
2216 | 83, 84, 85, 86, 87, 88, 89, 90, | 2175 | 82, 83, 84, 85, 86, 87, 88, 89, |
2217 | 91, 92, 93, 94, 95, 96, 97, 98, | 2176 | 90, 91, 92, 93, 94, 95, 96, 97, |
2218 | 99, 100, 3, 14, 3, 14, 3, 14, | 2177 | 0, 11, 0, 11, 0, 11, 11, 0, |
2219 | 14, 3, 14, 14, 3, 3, 3, 14, | 2178 | 11, 11, 0, 0, 0, 11, 0, 0, |
2220 | 3, 3, 3, 3, 3, 3, 3, 14, | 2179 | 0, 0, 0, 0, 0, 11, 0, 0, |
2221 | 3, 3, 3, 3, 3, 3, 3, 14, | 2180 | 0, 0, 0, 0, 0, 11, 11, 11, |
2222 | 14, 14, 14, 14, 14, 14, 14, 14, | 2181 | 11, 11, 11, 11, 11, 11, 11, 11, |
2223 | 14, 14, 3, 3, 3, 3, 3, 3, | 2182 | 0, 0, 0, 0, 0, 0, 0, 0, |
2224 | 3, 3, 14, 14, 14, 14, 14, 14, | 2183 | 11, 11, 11, 11, 11, 11, 11, 11, |
2225 | 14, 14, 14, 3, 3, 3, 3, 3, | 2184 | 11, 0, 0, 0, 0, 0, 0, 0, |
2226 | 3, 3, 3, 14, 14, 14, 14, 14, | 2185 | 0, 11, 11, 11, 11, 11, 11, 11, |
2227 | 14, 14, 14, 14, 3, 14, 14, 14, | 2186 | 11, 11, 0, 11, 11, 11, 11, 11, |
2228 | 14, 14, 14, 14, 14, 3, 14, 14, | 2187 | 11, 11, 11, 0, 11, 11, 11, 11, |
2229 | 14, 14, 14, 14, 14, 14, 14, 14, | 2188 | 11, 11, 11, 11, 11, 11, 11, 0, |
2230 | 14, 3, 14, 14, 14, 14, 14, 14, | 2189 | 11, 11, 11, 11, 11, 11, 0, 11, |
2231 | 3, 14, 14, 14, 14, 14, 14, 3, | 2190 | 11, 11, 11, 11, 11, 0, 0, 0, |
2232 | 3, 3, 3, 3, 3, 3, 3, 14, | 2191 | 0, 0, 0, 0, 0, 11, 11, 11, |
2233 | 14, 14, 14, 14, 14, 14, 14, 3, | 2192 | 11, 11, 11, 11, 11, 0, 11, 11, |
2234 | 14, 14, 14, 14, 14, 14, 14, 14, | 2193 | 11, 11, 11, 11, 11, 11, 0, 11, |
2235 | 3, 14, 14, 14, 14, 14, 3, 3, | 2194 | 11, 11, 11, 11, 0, 0, 0, 0, |
2236 | 3, 3, 3, 3, 3, 3, 14, 14, | 2195 | 0, 0, 0, 0, 11, 11, 11, 11, |
2237 | 14, 14, 14, 14, 3, 14, 14, 14, | 2196 | 11, 11, 0, 11, 11, 11, 11, 11, |
2238 | 14, 14, 14, 14, 3, 14, 3, 14, | 2197 | 11, 11, 0, 11, 0, 11, 11, 0, |
2239 | 14, 3, 14, 14, 14, 14, 14, 14, | 2198 | 11, 11, 11, 11, 11, 11, 11, 11, |
2240 | 14, 14, 14, 14, 14, 14, 14, 3, | 2199 | 11, 11, 11, 11, 11, 0, 11, 11, |
2241 | 14, 14, 14, 14, 14, 3, 14, 14, | 2200 | 11, 11, 11, 0, 11, 11, 11, 11, |
2242 | 14, 14, 14, 14, 14, 3, 14, 14, | 2201 | 11, 11, 11, 0, 11, 11, 11, 0, |
2243 | 14, 3, 14, 14, 14, 3, 14, 3, | 2202 | 11, 11, 11, 0, 11, 0, 98, 99, |
2244 | 101, 102, 103, 104, 105, 106, 107, 108, | 2203 | 100, 101, 102, 103, 104, 105, 106, 107, |
2245 | 109, 110, 111, 112, 113, 114, 115, 116, | 2204 | 108, 109, 110, 111, 112, 113, 114, 16, |
2246 | 117, 19, 118, 119, 120, 121, 122, 123, | 2205 | 115, 116, 117, 118, 119, 120, 121, 122, |
2247 | 124, 125, 126, 127, 128, 129, 130, 131, | 2206 | 123, 124, 125, 126, 127, 128, 129, 130, |
2248 | 132, 133, 134, 135, 17, 18, 136, 137, | 2207 | 131, 132, 14, 15, 133, 134, 135, 136, |
2249 | 138, 139, 140, 17, 19, 17, 3, 14, | 2208 | 137, 14, 16, 14, 0, 11, 0, 11, |
2250 | 3, 14, 14, 3, 3, 14, 3, 3, | 2209 | 11, 0, 0, 11, 0, 0, 0, 0, |
2251 | 3, 3, 14, 3, 3, 3, 3, 3, | 2210 | 11, 0, 0, 0, 0, 0, 11, 0, |
2252 | 14, 3, 3, 3, 3, 3, 14, 14, | 2211 | 0, 0, 0, 0, 11, 11, 11, 11, |
2253 | 14, 14, 14, 3, 3, 3, 14, 3, | 2212 | 11, 0, 0, 0, 11, 0, 0, 0, |
2254 | 3, 3, 14, 14, 14, 3, 3, 3, | 2213 | 11, 11, 11, 0, 0, 0, 11, 11, |
2255 | 14, 14, 3, 3, 3, 14, 14, 14, | 2214 | 0, 0, 0, 11, 11, 11, 0, 0, |
2256 | 3, 3, 3, 14, 14, 14, 14, 3, | 2215 | 0, 11, 11, 11, 11, 0, 11, 11, |
2257 | 14, 14, 14, 14, 3, 3, 3, 3, | 2216 | 11, 11, 0, 0, 0, 0, 0, 11, |
2258 | 3, 14, 14, 14, 14, 3, 3, 14, | 2217 | 11, 11, 11, 0, 0, 11, 11, 11, |
2259 | 14, 14, 3, 3, 14, 14, 14, 14, | 2218 | 0, 0, 11, 11, 11, 11, 0, 11, |
2260 | 3, 14, 14, 3, 14, 14, 3, 3, | 2219 | 11, 0, 11, 11, 0, 0, 0, 11, |
2261 | 3, 14, 14, 14, 3, 3, 3, 3, | 2220 | 11, 11, 0, 0, 0, 0, 11, 11, |
2262 | 14, 14, 14, 14, 14, 3, 3, 3, | 2221 | 11, 11, 11, 0, 0, 0, 0, 11, |
2263 | 3, 14, 3, 14, 14, 3, 14, 14, | 2222 | 0, 11, 11, 0, 11, 11, 0, 11, |
2264 | 3, 14, 3, 14, 14, 14, 3, 14, | 2223 | 0, 11, 11, 11, 0, 11, 11, 0, |
2265 | 14, 3, 3, 3, 14, 3, 3, 3, | 2224 | 0, 0, 11, 0, 0, 0, 0, 0, |
2266 | 3, 3, 3, 3, 14, 14, 14, 14, | 2225 | 0, 0, 11, 11, 11, 11, 0, 11, |
2267 | 3, 14, 14, 14, 14, 14, 14, 14, | 2226 | 11, 11, 11, 11, 11, 11, 0, 138, |
2268 | 3, 141, 142, 143, 144, 145, 146, 147, | 2227 | 139, 140, 141, 142, 143, 144, 145, 146, |
2269 | 148, 149, 17, 150, 151, 152, 153, 154, | 2228 | 14, 147, 148, 149, 150, 151, 0, 11, |
2270 | 3, 14, 3, 3, 3, 3, 3, 14, | 2229 | 0, 0, 0, 0, 0, 11, 11, 0, |
2271 | 14, 3, 14, 14, 14, 3, 14, 14, | 2230 | 11, 11, 11, 0, 11, 11, 11, 11, |
2272 | 14, 14, 14, 14, 14, 14, 14, 14, | 2231 | 11, 11, 11, 11, 11, 11, 0, 11, |
2273 | 3, 14, 14, 14, 3, 3, 14, 14, | 2232 | 11, 11, 0, 0, 11, 11, 11, 0, |
2274 | 14, 3, 3, 14, 3, 3, 14, 14, | 2233 | 0, 11, 0, 0, 11, 11, 11, 11, |
2275 | 14, 14, 14, 3, 3, 3, 3, 14, | 2234 | 11, 0, 0, 0, 0, 11, 11, 11, |
2276 | 14, 14, 14, 14, 14, 3, 14, 14, | 2235 | 11, 11, 11, 0, 11, 11, 11, 11, |
2277 | 14, 14, 14, 3, 155, 112, 156, 157, | 2236 | 11, 0, 152, 109, 153, 154, 155, 14, |
2278 | 158, 17, 159, 160, 19, 17, 3, 14, | 2237 | 156, 157, 16, 14, 0, 11, 11, 11, |
2279 | 14, 14, 14, 3, 3, 3, 14, 3, | 2238 | 11, 0, 0, 0, 11, 0, 0, 11, |
2280 | 3, 14, 14, 14, 3, 3, 3, 14, | 2239 | 11, 11, 0, 0, 0, 11, 11, 0, |
2281 | 14, 3, 122, 3, 19, 17, 17, 161, | 2240 | 119, 0, 16, 14, 14, 158, 0, 14, |
2282 | 3, 17, 3, 14, 19, 162, 163, 19, | 2241 | 0, 11, 16, 159, 160, 16, 161, 162, |
2283 | 164, 165, 19, 60, 166, 167, 168, 169, | 2242 | 16, 57, 163, 164, 165, 166, 167, 16, |
2284 | 170, 19, 171, 172, 173, 19, 174, 175, | 2243 | 168, 169, 170, 16, 171, 172, 173, 15, |
2285 | 176, 18, 177, 178, 179, 18, 180, 19, | 2244 | 174, 175, 176, 15, 177, 16, 14, 0, |
2286 | 17, 3, 3, 14, 14, 3, 3, 3, | 2245 | 0, 11, 11, 0, 0, 0, 11, 11, |
2287 | 14, 14, 14, 14, 3, 14, 14, 3, | 2246 | 11, 11, 0, 11, 11, 0, 0, 0, |
2288 | 3, 3, 3, 14, 14, 3, 3, 14, | 2247 | 0, 11, 11, 0, 0, 11, 11, 0, |
2289 | 14, 3, 3, 3, 3, 3, 3, 14, | 2248 | 0, 0, 0, 0, 0, 11, 11, 11, |
2290 | 14, 14, 3, 3, 3, 14, 3, 3, | 2249 | 0, 0, 0, 11, 0, 0, 0, 11, |
2291 | 3, 14, 14, 3, 14, 14, 14, 14, | 2250 | 11, 0, 11, 11, 11, 11, 0, 11, |
2292 | 3, 14, 14, 14, 14, 3, 14, 14, | 2251 | 11, 11, 11, 0, 11, 11, 11, 11, |
2293 | 14, 14, 14, 14, 3, 3, 3, 14, | 2252 | 11, 11, 0, 0, 0, 11, 11, 11, |
2294 | 14, 14, 14, 3, 181, 182, 3, 17, | 2253 | 11, 0, 178, 179, 0, 14, 0, 11, |
2295 | 3, 14, 3, 3, 14, 19, 183, 184, | 2254 | 0, 0, 11, 16, 180, 181, 182, 183, |
2296 | 185, 186, 60, 187, 188, 58, 189, 190, | 2255 | 57, 184, 185, 55, 186, 187, 188, 189, |
2297 | 191, 192, 193, 194, 195, 196, 197, 17, | 2256 | 190, 191, 192, 193, 194, 14, 0, 0, |
2298 | 3, 3, 14, 3, 14, 14, 14, 14, | 2257 | 11, 0, 11, 11, 11, 11, 11, 11, |
2299 | 14, 14, 14, 3, 14, 14, 14, 3, | 2258 | 11, 0, 11, 11, 11, 0, 11, 0, |
2300 | 14, 3, 3, 14, 3, 14, 3, 3, | 2259 | 0, 11, 0, 11, 0, 0, 11, 11, |
2301 | 14, 14, 14, 14, 3, 14, 14, 14, | 2260 | 11, 11, 0, 11, 11, 11, 0, 0, |
2302 | 3, 3, 14, 14, 14, 14, 3, 14, | 2261 | 11, 11, 11, 11, 0, 11, 11, 0, |
2303 | 14, 3, 3, 14, 14, 14, 14, 14, | 2262 | 0, 11, 11, 11, 11, 11, 0, 195, |
2304 | 3, 198, 199, 200, 201, 202, 203, 204, | 2263 | 196, 197, 198, 199, 200, 201, 202, 203, |
2305 | 205, 206, 207, 208, 204, 209, 210, 211, | 2264 | 204, 205, 201, 206, 207, 208, 209, 38, |
2306 | 212, 41, 3, 213, 214, 19, 215, 216, | 2265 | 0, 210, 211, 16, 212, 213, 214, 215, |
2307 | 217, 218, 219, 220, 221, 222, 223, 19, | 2266 | 216, 217, 218, 219, 220, 16, 14, 221, |
2308 | 17, 224, 225, 226, 227, 19, 228, 229, | 2267 | 222, 223, 224, 16, 225, 226, 227, 228, |
2309 | 230, 231, 232, 233, 234, 235, 236, 237, | 2268 | 229, 230, 231, 232, 233, 234, 235, 236, |
2310 | 238, 239, 240, 241, 242, 19, 147, 17, | 2269 | 237, 238, 239, 16, 144, 14, 240, 0, |
2311 | 243, 3, 14, 14, 14, 14, 14, 3, | 2270 | 11, 11, 11, 11, 11, 0, 0, 0, |
2312 | 3, 3, 14, 3, 14, 14, 3, 14, | 2271 | 11, 0, 11, 11, 0, 11, 0, 11, |
2313 | 3, 14, 14, 3, 3, 3, 14, 14, | 2272 | 11, 0, 0, 0, 11, 11, 11, 0, |
2314 | 14, 3, 3, 3, 14, 14, 14, 3, | 2273 | 0, 0, 11, 11, 11, 0, 0, 0, |
2315 | 3, 3, 3, 14, 3, 3, 14, 3, | 2274 | 0, 11, 0, 0, 11, 0, 0, 11, |
2316 | 3, 14, 14, 14, 3, 3, 14, 3, | 2275 | 11, 11, 0, 0, 11, 0, 11, 11, |
2317 | 14, 14, 14, 3, 14, 14, 14, 14, | 2276 | 11, 0, 11, 11, 11, 11, 11, 11, |
2318 | 14, 14, 3, 3, 3, 14, 14, 3, | 2277 | 0, 0, 0, 11, 11, 0, 11, 11, |
2319 | 14, 14, 3, 14, 14, 3, 14, 14, | 2278 | 0, 11, 11, 0, 11, 11, 0, 11, |
2320 | 3, 14, 14, 14, 14, 14, 14, 14, | 2279 | 11, 11, 11, 11, 11, 11, 0, 11, |
2321 | 3, 14, 3, 14, 3, 14, 14, 3, | 2280 | 0, 11, 0, 11, 11, 0, 11, 0, |
2322 | 14, 3, 14, 14, 3, 14, 3, 14, | 2281 | 11, 11, 0, 11, 0, 11, 0, 241, |
2323 | 3, 244, 215, 245, 246, 247, 248, 249, | 2282 | 212, 242, 243, 244, 245, 246, 247, 248, |
2324 | 250, 251, 252, 253, 101, 254, 19, 255, | 2283 | 249, 250, 98, 251, 16, 252, 253, 254, |
2325 | 256, 257, 19, 258, 132, 259, 260, 261, | 2284 | 16, 255, 129, 256, 257, 258, 259, 260, |
2326 | 262, 263, 264, 265, 266, 19, 3, 3, | 2285 | 261, 262, 263, 16, 0, 0, 0, 11, |
2327 | 3, 14, 14, 14, 3, 14, 14, 3, | 2286 | 11, 11, 0, 11, 11, 0, 11, 11, |
2328 | 14, 14, 3, 3, 3, 3, 3, 14, | 2287 | 0, 0, 0, 0, 0, 11, 11, 11, |
2329 | 14, 14, 14, 3, 14, 14, 14, 14, | 2288 | 11, 0, 11, 11, 11, 11, 11, 11, |
2330 | 14, 14, 3, 3, 3, 14, 14, 14, | 2289 | 0, 0, 0, 11, 11, 11, 11, 11, |
2331 | 14, 14, 14, 14, 14, 14, 3, 14, | 2290 | 11, 11, 11, 11, 0, 11, 11, 11, |
2332 | 14, 14, 14, 14, 14, 14, 14, 3, | 2291 | 11, 11, 11, 11, 11, 0, 11, 11, |
2333 | 14, 14, 3, 3, 3, 3, 14, 14, | 2292 | 0, 0, 0, 0, 11, 11, 11, 0, |
2334 | 14, 3, 3, 3, 14, 3, 3, 3, | 2293 | 0, 0, 11, 0, 0, 0, 11, 11, |
2335 | 14, 14, 3, 14, 14, 14, 3, 14, | 2294 | 0, 11, 11, 11, 0, 11, 0, 0, |
2336 | 3, 3, 3, 14, 14, 3, 14, 14, | 2295 | 0, 11, 11, 0, 11, 11, 11, 0, |
2337 | 14, 3, 14, 14, 14, 3, 3, 3, | 2296 | 11, 11, 11, 0, 0, 0, 0, 11, |
2338 | 3, 14, 19, 184, 267, 268, 17, 19, | 2297 | 16, 181, 264, 265, 14, 16, 14, 0, |
2339 | 17, 3, 3, 14, 3, 14, 19, 267, | 2298 | 0, 11, 0, 11, 16, 264, 14, 0, |
2340 | 17, 3, 19, 269, 17, 3, 3, 14, | 2299 | 16, 266, 14, 0, 0, 11, 16, 267, |
2341 | 19, 270, 271, 272, 175, 273, 274, 19, | 2300 | 268, 269, 172, 270, 271, 16, 272, 273, |
2342 | 275, 276, 277, 17, 3, 3, 14, 14, | 2301 | 274, 14, 0, 0, 11, 11, 11, 0, |
2343 | 14, 3, 14, 14, 3, 14, 14, 14, | 2302 | 11, 11, 0, 11, 11, 11, 11, 0, |
2344 | 14, 3, 3, 14, 3, 3, 14, 14, | 2303 | 0, 11, 0, 0, 11, 11, 0, 11, |
2345 | 3, 14, 3, 19, 17, 3, 278, 19, | 2304 | 0, 16, 14, 0, 275, 16, 276, 0, |
2346 | 279, 3, 17, 3, 14, 3, 14, 280, | 2305 | 14, 0, 11, 0, 11, 277, 16, 278, |
2347 | 19, 281, 282, 3, 14, 3, 3, 3, | 2306 | 279, 0, 11, 0, 0, 0, 11, 11, |
2348 | 14, 14, 14, 14, 3, 283, 284, 285, | 2307 | 11, 11, 0, 280, 281, 282, 16, 283, |
2349 | 19, 286, 287, 288, 289, 290, 291, 292, | 2308 | 284, 285, 286, 287, 288, 289, 290, 291, |
2350 | 293, 294, 295, 296, 297, 298, 299, 17, | 2309 | 292, 293, 294, 295, 296, 14, 0, 11, |
2351 | 3, 14, 14, 14, 3, 3, 3, 3, | 2310 | 11, 11, 0, 0, 0, 0, 11, 11, |
2352 | 14, 14, 3, 3, 14, 3, 3, 3, | 2311 | 0, 0, 11, 0, 0, 0, 0, 0, |
2353 | 3, 3, 3, 3, 14, 3, 14, 3, | 2312 | 0, 0, 11, 0, 11, 0, 0, 0, |
2354 | 3, 3, 3, 3, 3, 14, 14, 14, | 2313 | 0, 0, 0, 11, 11, 11, 11, 11, |
2355 | 14, 14, 3, 3, 14, 3, 3, 3, | 2314 | 0, 0, 11, 0, 0, 0, 11, 0, |
2356 | 14, 3, 3, 14, 3, 3, 14, 3, | 2315 | 0, 11, 0, 0, 11, 0, 0, 11, |
2357 | 3, 14, 3, 3, 3, 14, 14, 14, | 2316 | 0, 0, 0, 11, 11, 11, 0, 0, |
2358 | 3, 3, 3, 14, 14, 14, 14, 3, | 2317 | 0, 11, 11, 11, 11, 0, 297, 16, |
2359 | 300, 19, 301, 19, 302, 303, 304, 305, | 2318 | 298, 16, 299, 300, 301, 302, 14, 0, |
2360 | 17, 3, 14, 14, 14, 14, 14, 3, | 2319 | 11, 11, 11, 11, 11, 0, 0, 0, |
2361 | 3, 3, 14, 3, 3, 14, 14, 14, | 2320 | 11, 0, 0, 11, 11, 11, 11, 11, |
2362 | 14, 14, 14, 14, 14, 14, 14, 3, | 2321 | 11, 11, 11, 11, 11, 0, 11, 11, |
2363 | 14, 14, 14, 14, 14, 14, 14, 14, | 2322 | 11, 11, 11, 11, 11, 11, 11, 11, |
2364 | 14, 14, 14, 14, 14, 14, 14, 14, | 2323 | 11, 11, 11, 11, 11, 11, 11, 11, |
2365 | 14, 14, 14, 3, 14, 14, 14, 14, | 2324 | 11, 0, 11, 11, 11, 11, 11, 0, |
2366 | 14, 3, 306, 19, 17, 3, 14, 307, | 2325 | 303, 16, 14, 0, 11, 304, 16, 100, |
2367 | 19, 103, 17, 3, 14, 308, 3, 17, | 2326 | 14, 0, 11, 305, 0, 14, 0, 11, |
2368 | 3, 14, 19, 309, 17, 3, 3, 14, | 2327 | 16, 306, 14, 0, 0, 11, 307, 0, |
2369 | 310, 3, 19, 311, 17, 3, 3, 14, | 2328 | 16, 308, 14, 0, 0, 11, 11, 11, |
2370 | 14, 14, 14, 3, 14, 14, 14, 14, | 2329 | 11, 0, 11, 11, 11, 11, 0, 11, |
2371 | 3, 14, 14, 14, 14, 14, 3, 3, | 2330 | 11, 11, 11, 11, 0, 0, 11, 0, |
2372 | 14, 3, 14, 14, 14, 3, 14, 3, | 2331 | 11, 11, 11, 0, 11, 0, 11, 11, |
2373 | 14, 14, 14, 3, 3, 3, 3, 3, | 2332 | 11, 0, 0, 0, 0, 0, 0, 0, |
2374 | 3, 3, 14, 14, 14, 3, 14, 3, | 2333 | 11, 11, 11, 0, 11, 0, 0, 0, |
2375 | 3, 3, 14, 14, 14, 14, 3, 312, | 2334 | 11, 11, 11, 11, 0, 309, 310, 69, |
2376 | 313, 72, 314, 315, 316, 317, 318, 319, | 2335 | 311, 312, 313, 314, 315, 316, 317, 318, |
2377 | 320, 321, 322, 323, 324, 325, 326, 327, | 2336 | 319, 320, 321, 322, 323, 324, 325, 326, |
2378 | 328, 329, 330, 331, 332, 334, 335, 336, | 2337 | 327, 328, 329, 331, 332, 333, 334, 335, |
2379 | 337, 338, 339, 333, 3, 14, 14, 14, | 2338 | 336, 330, 0, 11, 11, 11, 11, 0, |
2380 | 14, 3, 14, 3, 14, 14, 3, 14, | 2339 | 11, 0, 11, 11, 0, 11, 11, 11, |
2381 | 14, 14, 3, 3, 3, 3, 3, 3, | 2340 | 0, 0, 0, 0, 0, 0, 0, 0, |
2382 | 3, 3, 3, 14, 14, 14, 14, 14, | 2341 | 0, 11, 11, 11, 11, 11, 0, 11, |
2383 | 3, 14, 14, 14, 14, 14, 14, 14, | 2342 | 11, 11, 11, 11, 11, 11, 0, 11, |
2384 | 3, 14, 14, 14, 3, 14, 14, 14, | 2343 | 11, 11, 0, 11, 11, 11, 11, 11, |
2385 | 14, 14, 14, 14, 3, 14, 14, 14, | 2344 | 11, 11, 0, 11, 11, 11, 0, 11, |
2386 | 3, 14, 14, 14, 14, 14, 14, 14, | 2345 | 11, 11, 11, 11, 11, 11, 0, 11, |
2387 | 3, 14, 14, 14, 3, 14, 14, 14, | 2346 | 11, 11, 0, 11, 11, 11, 11, 11, |
2388 | 14, 14, 14, 14, 14, 14, 14, 3, | 2347 | 11, 11, 11, 11, 11, 0, 11, 0, |
2389 | 14, 3, 14, 14, 14, 14, 14, 3, | 2348 | 11, 11, 11, 11, 11, 0, 11, 11, |
2390 | 14, 14, 3, 14, 14, 14, 14, 14, | 2349 | 0, 11, 11, 11, 11, 11, 11, 11, |
2391 | 14, 14, 3, 14, 14, 14, 3, 14, | 2350 | 0, 11, 11, 11, 0, 11, 11, 11, |
2392 | 14, 14, 14, 3, 14, 14, 14, 14, | 2351 | 11, 0, 11, 11, 11, 11, 0, 11, |
2393 | 3, 14, 14, 14, 14, 3, 14, 3, | 2352 | 11, 11, 11, 0, 11, 0, 11, 11, |
2394 | 14, 14, 3, 14, 14, 14, 14, 14, | 2353 | 0, 11, 11, 11, 11, 11, 11, 11, |
2395 | 14, 14, 14, 14, 14, 14, 14, 14, | 2354 | 11, 11, 11, 11, 11, 11, 11, 0, |
2396 | 14, 3, 14, 14, 14, 3, 14, 3, | 2355 | 11, 11, 11, 0, 11, 0, 11, 11, |
2397 | 14, 14, 3, 14, 3, 340, 341, 342, | 2356 | 0, 11, 0, 337, 338, 339, 101, 102, |
2398 | 104, 105, 106, 107, 108, 343, 110, 111, | 2357 | 103, 104, 105, 340, 107, 108, 109, 110, |
2399 | 112, 113, 114, 115, 344, 345, 170, 346, | 2358 | 111, 112, 341, 342, 167, 343, 258, 117, |
2400 | 261, 120, 347, 122, 232, 272, 125, 348, | 2359 | 344, 119, 229, 269, 122, 345, 346, 347, |
2401 | 349, 350, 351, 352, 353, 354, 355, 356, | 2360 | 348, 349, 350, 351, 352, 353, 354, 131, |
2402 | 357, 134, 358, 19, 17, 18, 19, 137, | 2361 | 355, 16, 14, 15, 16, 134, 135, 136, |
2403 | 138, 139, 140, 17, 17, 3, 14, 14, | 2362 | 137, 14, 14, 0, 11, 11, 0, 11, |
2404 | 3, 14, 14, 14, 14, 14, 14, 3, | 2363 | 11, 11, 11, 11, 11, 0, 0, 0, |
2405 | 3, 3, 14, 3, 14, 14, 14, 14, | 2364 | 11, 0, 11, 11, 11, 11, 0, 11, |
2406 | 3, 14, 14, 14, 3, 14, 14, 3, | 2365 | 11, 11, 0, 11, 11, 0, 11, 11, |
2407 | 14, 14, 14, 3, 3, 14, 14, 14, | 2366 | 11, 0, 0, 11, 11, 11, 0, 0, |
2408 | 3, 3, 14, 14, 3, 14, 3, 14, | 2367 | 11, 11, 0, 11, 0, 11, 0, 11, |
2409 | 3, 14, 14, 14, 3, 3, 14, 14, | 2368 | 11, 11, 0, 0, 11, 11, 0, 11, |
2410 | 3, 14, 14, 3, 14, 14, 14, 3, | 2369 | 11, 0, 11, 11, 11, 0, 356, 140, |
2411 | 359, 143, 145, 146, 147, 148, 149, 17, | 2370 | 142, 143, 144, 145, 146, 14, 357, 148, |
2412 | 360, 151, 361, 153, 362, 3, 14, 14, | 2371 | 358, 150, 359, 0, 11, 11, 0, 0, |
2413 | 3, 3, 3, 3, 14, 3, 3, 14, | 2372 | 0, 0, 11, 0, 0, 11, 11, 11, |
2414 | 14, 14, 14, 14, 3, 363, 112, 364, | 2373 | 11, 11, 0, 360, 109, 361, 154, 155, |
2415 | 157, 158, 17, 159, 160, 19, 17, 3, | 2374 | 14, 156, 157, 16, 14, 0, 11, 11, |
2416 | 14, 14, 14, 14, 3, 3, 3, 14, | 2375 | 11, 11, 0, 0, 0, 11, 16, 159, |
2417 | 19, 162, 163, 19, 365, 366, 222, 311, | 2376 | 160, 16, 362, 363, 219, 308, 163, 164, |
2418 | 166, 167, 168, 367, 170, 368, 369, 370, | 2377 | 165, 364, 167, 365, 366, 367, 368, 369, |
2419 | 371, 372, 373, 374, 375, 376, 377, 178, | 2378 | 370, 371, 372, 373, 374, 175, 176, 15, |
2420 | 179, 18, 378, 19, 17, 3, 3, 3, | 2379 | 375, 16, 14, 0, 0, 0, 0, 11, |
2421 | 3, 14, 14, 14, 3, 3, 3, 3, | 2380 | 11, 11, 0, 0, 0, 0, 0, 11, |
2422 | 3, 14, 14, 3, 14, 14, 14, 3, | 2381 | 11, 0, 11, 11, 11, 0, 11, 11, |
2423 | 14, 14, 3, 3, 3, 14, 14, 3, | 2382 | 0, 0, 0, 11, 11, 0, 11, 11, |
2424 | 14, 14, 14, 14, 3, 14, 3, 14, | 2383 | 11, 11, 0, 11, 0, 11, 11, 11, |
2425 | 14, 14, 14, 14, 3, 3, 3, 3, | 2384 | 11, 11, 0, 0, 0, 0, 0, 11, |
2426 | 3, 14, 14, 14, 14, 14, 14, 3, | 2385 | 11, 11, 11, 11, 11, 0, 11, 0, |
2427 | 14, 3, 19, 183, 184, 379, 186, 60, | 2386 | 16, 180, 181, 376, 183, 57, 184, 185, |
2428 | 187, 188, 58, 189, 190, 380, 17, 193, | 2387 | 55, 186, 187, 377, 14, 190, 378, 192, |
2429 | 381, 195, 196, 197, 17, 3, 14, 14, | 2388 | 193, 194, 14, 0, 11, 11, 11, 11, |
2430 | 14, 14, 14, 14, 14, 3, 14, 14, | 2389 | 11, 11, 11, 0, 11, 11, 0, 11, |
2431 | 3, 14, 3, 382, 383, 200, 201, 202, | 2390 | 0, 379, 380, 197, 198, 199, 381, 201, |
2432 | 384, 204, 205, 385, 386, 387, 204, 209, | 2391 | 202, 382, 383, 384, 201, 206, 207, 208, |
2433 | 210, 211, 212, 41, 3, 213, 214, 19, | 2392 | 209, 38, 0, 210, 211, 16, 212, 213, |
2434 | 215, 216, 218, 388, 220, 389, 222, 223, | 2393 | 215, 385, 217, 386, 219, 220, 16, 14, |
2435 | 19, 17, 390, 225, 226, 227, 19, 228, | 2394 | 387, 222, 223, 224, 16, 225, 226, 227, |
2436 | 229, 230, 231, 232, 233, 234, 235, 391, | 2395 | 228, 229, 230, 231, 232, 388, 234, 235, |
2437 | 237, 238, 392, 240, 241, 242, 19, 147, | 2396 | 389, 237, 238, 239, 16, 144, 14, 240, |
2438 | 17, 243, 3, 3, 14, 3, 3, 14, | 2397 | 0, 0, 11, 0, 0, 11, 0, 11, |
2439 | 3, 14, 14, 14, 14, 14, 3, 14, | 2398 | 11, 11, 11, 11, 0, 11, 11, 0, |
2440 | 14, 3, 393, 394, 395, 396, 397, 398, | 2399 | 390, 391, 392, 393, 394, 395, 396, 397, |
2441 | 399, 400, 250, 401, 322, 402, 216, 403, | 2400 | 247, 398, 319, 399, 213, 400, 401, 402, |
2442 | 404, 405, 406, 407, 404, 408, 409, 410, | 2401 | 403, 404, 401, 405, 406, 407, 258, 408, |
2443 | 261, 411, 263, 412, 413, 274, 3, 14, | 2402 | 260, 409, 410, 271, 0, 11, 0, 11, |
2444 | 3, 14, 3, 14, 3, 14, 3, 14, | 2403 | 0, 11, 0, 11, 0, 11, 11, 0, |
2445 | 14, 3, 14, 3, 14, 14, 14, 3, | 2404 | 11, 0, 11, 11, 11, 0, 11, 11, |
2446 | 14, 14, 3, 3, 14, 14, 14, 3, | 2405 | 0, 0, 11, 11, 11, 0, 11, 0, |
2447 | 14, 3, 14, 3, 14, 14, 3, 14, | 2406 | 11, 0, 11, 11, 0, 11, 0, 11, |
2448 | 3, 14, 3, 14, 3, 14, 3, 14, | 2407 | 0, 11, 0, 11, 0, 11, 0, 0, |
2449 | 3, 3, 3, 14, 14, 14, 3, 14, | 2408 | 0, 11, 11, 11, 0, 11, 11, 0, |
2450 | 14, 3, 19, 270, 232, 414, 404, 415, | 2409 | 16, 267, 229, 411, 401, 412, 271, 16, |
2451 | 274, 19, 416, 417, 277, 17, 3, 14, | 2410 | 413, 414, 274, 14, 0, 11, 0, 11, |
2452 | 3, 14, 14, 14, 3, 3, 3, 14, | 2411 | 11, 11, 0, 0, 0, 11, 11, 0, |
2453 | 14, 3, 280, 19, 281, 418, 3, 14, | 2412 | 277, 16, 278, 415, 0, 11, 11, 0, |
2454 | 14, 3, 19, 286, 287, 288, 289, 290, | 2413 | 16, 283, 284, 285, 286, 287, 288, 289, |
2455 | 291, 292, 293, 294, 295, 419, 17, 3, | 2414 | 290, 291, 292, 416, 14, 0, 0, 0, |
2456 | 3, 3, 14, 19, 420, 19, 268, 303, | 2415 | 11, 16, 417, 16, 265, 300, 301, 302, |
2457 | 304, 305, 17, 3, 3, 14, 422, 422, | 2416 | 14, 0, 0, 11, 419, 419, 419, 419, |
2458 | 422, 422, 421, 422, 422, 422, 421, 422, | 2417 | 418, 419, 419, 419, 418, 419, 418, 419, |
2459 | 421, 422, 422, 421, 421, 421, 421, 421, | 2418 | 419, 418, 418, 418, 418, 418, 418, 419, |
2460 | 421, 422, 421, 421, 421, 421, 422, 422, | 2419 | 418, 418, 418, 418, 419, 419, 419, 419, |
2461 | 422, 422, 422, 421, 421, 422, 421, 421, | 2420 | 419, 418, 418, 419, 418, 418, 419, 418, |
2462 | 422, 421, 422, 421, 421, 422, 421, 421, | 2421 | 419, 418, 418, 419, 418, 418, 418, 419, |
2463 | 421, 422, 422, 422, 422, 422, 422, 421, | 2422 | 419, 419, 419, 419, 419, 418, 419, 419, |
2464 | 422, 422, 421, 422, 422, 421, 421, 421, | 2423 | 418, 419, 419, 418, 418, 418, 418, 418, |
2465 | 421, 421, 421, 422, 422, 421, 421, 422, | 2424 | 418, 419, 419, 418, 418, 419, 418, 419, |
2466 | 421, 422, 422, 422, 421, 423, 424, 425, | 2425 | 419, 419, 418, 421, 422, 423, 424, 425, |
2467 | 426, 427, 428, 429, 430, 431, 432, 433, | 2426 | 426, 427, 428, 429, 430, 431, 432, 433, |
2468 | 434, 435, 436, 437, 438, 439, 440, 441, | 2427 | 434, 435, 436, 437, 438, 439, 440, 441, |
2469 | 442, 443, 444, 445, 446, 447, 448, 449, | 2428 | 442, 443, 444, 445, 446, 447, 448, 449, |
2470 | 450, 451, 452, 453, 454, 421, 422, 421, | 2429 | 450, 451, 452, 418, 419, 418, 419, 418, |
2471 | 422, 421, 422, 422, 421, 422, 422, 421, | 2430 | 419, 419, 418, 419, 419, 418, 418, 418, |
2472 | 421, 421, 422, 421, 421, 421, 421, 421, | 2431 | 419, 418, 418, 418, 418, 418, 418, 418, |
2473 | 421, 421, 422, 421, 421, 421, 421, 421, | 2432 | 419, 418, 418, 418, 418, 418, 418, 418, |
2474 | 421, 421, 422, 422, 422, 422, 422, 422, | 2433 | 419, 419, 419, 419, 419, 419, 419, 419, |
2475 | 422, 422, 422, 422, 422, 421, 421, 421, | 2434 | 419, 419, 419, 418, 418, 418, 418, 418, |
2476 | 421, 421, 421, 421, 421, 422, 422, 422, | 2435 | 418, 418, 418, 419, 419, 419, 419, 419, |
2477 | 422, 422, 422, 422, 422, 422, 421, 421, | 2436 | 419, 419, 419, 419, 418, 418, 418, 418, |
2478 | 421, 421, 421, 421, 421, 421, 422, 422, | 2437 | 418, 418, 418, 418, 419, 419, 419, 419, |
2479 | 422, 422, 422, 422, 422, 422, 422, 421, | 2438 | 419, 419, 419, 419, 419, 418, 419, 419, |
2480 | 422, 422, 422, 422, 422, 422, 422, 422, | 2439 | 419, 419, 419, 419, 419, 419, 418, 419, |
2481 | 421, 422, 422, 422, 422, 422, 422, 422, | 2440 | 419, 419, 419, 419, 419, 419, 419, 419, |
2482 | 422, 422, 422, 422, 421, 422, 422, 422, | 2441 | 419, 419, 418, 419, 419, 419, 419, 419, |
2483 | 422, 422, 422, 421, 422, 422, 422, 422, | 2442 | 419, 418, 419, 419, 419, 419, 419, 419, |
2484 | 422, 422, 421, 421, 421, 421, 421, 421, | 2443 | 418, 418, 418, 418, 418, 418, 418, 418, |
2485 | 421, 421, 422, 422, 422, 422, 422, 422, | 2444 | 419, 419, 419, 419, 419, 419, 419, 419, |
2486 | 422, 422, 421, 422, 422, 422, 422, 422, | 2445 | 418, 419, 419, 419, 419, 419, 419, 419, |
2487 | 422, 422, 422, 421, 422, 422, 422, 422, | 2446 | 419, 418, 419, 419, 419, 419, 419, 418, |
2488 | 422, 421, 421, 421, 421, 421, 421, 421, | 2447 | 418, 418, 418, 418, 418, 418, 418, 419, |
2489 | 421, 422, 422, 422, 422, 422, 422, 421, | 2448 | 419, 419, 419, 419, 419, 418, 419, 419, |
2490 | 422, 422, 422, 422, 422, 422, 422, 421, | 2449 | 419, 419, 419, 419, 419, 418, 419, 418, |
2491 | 422, 421, 422, 422, 421, 422, 422, 422, | 2450 | 419, 419, 418, 419, 419, 419, 419, 419, |
2492 | 422, 422, 422, 422, 422, 422, 422, 422, | 2451 | 419, 419, 419, 419, 419, 419, 419, 419, |
2493 | 422, 422, 421, 422, 422, 422, 422, 422, | 2452 | 418, 419, 419, 419, 419, 419, 418, 419, |
2494 | 421, 422, 422, 422, 422, 422, 422, 422, | 2453 | 419, 419, 419, 419, 419, 419, 418, 419, |
2495 | 421, 422, 422, 422, 421, 422, 422, 422, | 2454 | 419, 419, 418, 419, 419, 419, 418, 419, |
2496 | 421, 422, 421, 455, 456, 457, 458, 459, | 2455 | 418, 453, 454, 455, 456, 457, 458, 459, |
2497 | 460, 461, 462, 463, 464, 465, 466, 467, | 2456 | 460, 461, 462, 463, 464, 465, 466, 467, |
2498 | 468, 469, 470, 471, 472, 473, 474, 475, | 2457 | 468, 469, 470, 471, 472, 473, 474, 475, |
2499 | 476, 477, 478, 479, 480, 481, 482, 483, | 2458 | 476, 477, 478, 479, 480, 481, 482, 483, |
2500 | 484, 485, 486, 487, 488, 489, 490, 427, | 2459 | 484, 485, 486, 487, 488, 425, 489, 490, |
2501 | 491, 492, 493, 494, 495, 496, 427, 472, | 2460 | 491, 492, 493, 494, 425, 470, 425, 418, |
2502 | 427, 421, 422, 421, 422, 422, 421, 421, | 2461 | 419, 418, 419, 419, 418, 418, 419, 418, |
2503 | 422, 421, 421, 421, 421, 422, 421, 421, | 2462 | 418, 418, 418, 419, 418, 418, 418, 418, |
2504 | 421, 421, 421, 422, 421, 421, 421, 421, | 2463 | 418, 419, 418, 418, 418, 418, 418, 419, |
2505 | 421, 422, 422, 422, 422, 422, 421, 421, | 2464 | 419, 419, 419, 419, 418, 418, 418, 419, |
2506 | 421, 422, 421, 421, 421, 422, 422, 422, | 2465 | 418, 418, 418, 419, 419, 419, 418, 418, |
2507 | 421, 421, 421, 422, 422, 421, 421, 421, | 2466 | 418, 419, 419, 418, 418, 418, 419, 419, |
2508 | 422, 422, 422, 421, 421, 421, 422, 422, | 2467 | 419, 418, 418, 418, 419, 419, 419, 419, |
2509 | 422, 422, 421, 422, 422, 422, 422, 421, | 2468 | 418, 419, 419, 419, 419, 418, 418, 418, |
2510 | 421, 421, 421, 421, 422, 422, 422, 422, | 2469 | 418, 418, 419, 419, 419, 419, 418, 418, |
2511 | 421, 421, 422, 422, 422, 421, 421, 422, | 2470 | 419, 419, 419, 418, 418, 419, 419, 419, |
2512 | 422, 422, 422, 421, 422, 422, 421, 422, | 2471 | 419, 418, 419, 419, 418, 419, 419, 418, |
2513 | 422, 421, 421, 421, 422, 422, 422, 421, | 2472 | 418, 418, 419, 419, 419, 418, 418, 418, |
2514 | 421, 421, 421, 422, 422, 422, 422, 422, | 2473 | 418, 419, 419, 419, 419, 419, 418, 418, |
2515 | 421, 421, 421, 421, 422, 421, 422, 422, | 2474 | 418, 418, 419, 418, 419, 419, 418, 419, |
2516 | 421, 422, 422, 421, 422, 421, 422, 422, | 2475 | 419, 418, 419, 418, 419, 419, 419, 418, |
2517 | 422, 421, 422, 422, 421, 421, 421, 422, | 2476 | 419, 419, 418, 418, 418, 419, 418, 418, |
2518 | 421, 421, 421, 421, 421, 421, 421, 422, | 2477 | 418, 418, 418, 418, 418, 419, 419, 419, |
2519 | 422, 422, 422, 421, 422, 422, 422, 422, | 2478 | 419, 418, 419, 419, 419, 419, 419, 419, |
2520 | 422, 422, 422, 421, 497, 498, 499, 500, | 2479 | 419, 418, 495, 496, 497, 498, 499, 500, |
2521 | 501, 502, 503, 504, 505, 427, 506, 507, | 2480 | 501, 502, 503, 425, 504, 505, 506, 507, |
2522 | 508, 509, 510, 421, 422, 421, 421, 421, | 2481 | 508, 418, 419, 418, 418, 418, 418, 418, |
2523 | 421, 421, 422, 422, 421, 422, 422, 422, | 2482 | 419, 419, 418, 419, 419, 419, 418, 419, |
2524 | 421, 422, 422, 422, 422, 422, 422, 422, | 2483 | 419, 419, 419, 419, 419, 419, 419, 419, |
2525 | 422, 422, 422, 421, 422, 422, 422, 421, | 2484 | 419, 418, 419, 419, 419, 418, 418, 419, |
2526 | 421, 422, 422, 422, 421, 421, 422, 421, | 2485 | 419, 419, 418, 418, 419, 418, 418, 419, |
2527 | 421, 422, 422, 422, 422, 422, 421, 421, | 2486 | 419, 419, 419, 419, 418, 418, 418, 418, |
2528 | 421, 421, 422, 422, 422, 422, 422, 422, | 2487 | 419, 419, 419, 419, 419, 419, 418, 419, |
2529 | 421, 422, 422, 422, 422, 422, 421, 511, | 2488 | 419, 419, 419, 419, 418, 509, 464, 510, |
2530 | 466, 512, 513, 514, 427, 515, 516, 472, | 2489 | 511, 512, 425, 513, 514, 470, 425, 418, |
2531 | 427, 421, 422, 422, 422, 422, 421, 421, | 2490 | 419, 419, 419, 419, 418, 418, 418, 419, |
2532 | 421, 422, 421, 421, 422, 422, 422, 421, | 2491 | 418, 418, 419, 419, 419, 418, 418, 418, |
2533 | 421, 421, 422, 422, 421, 477, 421, 472, | 2492 | 419, 419, 418, 475, 418, 470, 425, 425, |
2534 | 427, 427, 517, 421, 427, 421, 422, 472, | 2493 | 515, 418, 425, 418, 419, 470, 516, 517, |
2535 | 518, 519, 472, 520, 521, 472, 522, 523, | 2494 | 470, 518, 519, 470, 520, 521, 522, 523, |
2536 | 524, 525, 526, 527, 472, 528, 529, 530, | 2495 | 524, 525, 470, 526, 527, 528, 470, 529, |
2537 | 472, 531, 532, 533, 491, 534, 535, 536, | 2496 | 530, 531, 489, 532, 533, 534, 489, 535, |
2538 | 491, 537, 472, 427, 421, 421, 422, 422, | 2497 | 470, 425, 418, 418, 419, 419, 418, 418, |
2539 | 421, 421, 421, 422, 422, 422, 422, 421, | 2498 | 418, 419, 419, 419, 419, 418, 419, 419, |
2540 | 422, 422, 421, 421, 421, 421, 422, 422, | 2499 | 418, 418, 418, 418, 419, 419, 418, 418, |
2541 | 421, 421, 422, 422, 421, 421, 421, 421, | 2500 | 419, 419, 418, 418, 418, 418, 418, 418, |
2542 | 421, 421, 422, 422, 422, 421, 421, 421, | 2501 | 419, 419, 419, 418, 418, 418, 419, 418, |
2543 | 422, 421, 421, 421, 422, 422, 421, 422, | 2502 | 418, 418, 419, 419, 418, 419, 419, 419, |
2544 | 422, 422, 422, 421, 422, 422, 422, 422, | 2503 | 419, 418, 419, 419, 419, 419, 418, 419, |
2545 | 421, 422, 422, 422, 422, 422, 422, 421, | 2504 | 419, 419, 419, 419, 419, 418, 418, 418, |
2546 | 421, 421, 422, 422, 422, 422, 421, 538, | 2505 | 419, 419, 419, 419, 418, 536, 537, 418, |
2547 | 539, 421, 427, 421, 422, 421, 421, 422, | 2506 | 425, 418, 419, 418, 418, 419, 470, 538, |
2548 | 472, 540, 541, 542, 543, 522, 544, 545, | 2507 | 539, 540, 541, 520, 542, 543, 544, 545, |
2549 | 546, 547, 548, 549, 550, 551, 552, 553, | 2508 | 546, 547, 548, 549, 550, 551, 552, 553, |
2550 | 554, 555, 427, 421, 421, 422, 421, 422, | 2509 | 425, 418, 418, 419, 418, 419, 419, 419, |
2551 | 422, 422, 422, 422, 422, 422, 421, 422, | 2510 | 419, 419, 419, 419, 418, 419, 419, 419, |
2552 | 422, 422, 421, 422, 421, 421, 422, 421, | 2511 | 418, 419, 418, 418, 419, 418, 419, 418, |
2553 | 422, 421, 421, 422, 422, 422, 422, 421, | 2512 | 418, 419, 419, 419, 419, 418, 419, 419, |
2554 | 422, 422, 422, 421, 421, 422, 422, 422, | 2513 | 419, 418, 418, 419, 419, 419, 419, 418, |
2555 | 422, 421, 422, 422, 421, 421, 422, 422, | 2514 | 419, 419, 418, 418, 419, 419, 419, 419, |
2556 | 422, 422, 422, 421, 556, 557, 558, 559, | 2515 | 419, 418, 554, 555, 556, 557, 558, 559, |
2557 | 560, 561, 562, 563, 564, 565, 566, 562, | 2516 | 560, 561, 562, 563, 564, 560, 566, 567, |
2558 | 568, 569, 570, 571, 567, 421, 572, 573, | 2517 | 568, 569, 565, 418, 570, 571, 470, 572, |
2559 | 472, 574, 575, 576, 577, 578, 579, 580, | 2518 | 573, 574, 575, 576, 577, 578, 579, 580, |
2560 | 581, 582, 472, 427, 583, 584, 585, 586, | 2519 | 470, 425, 581, 582, 583, 584, 470, 585, |
2561 | 472, 587, 588, 589, 590, 591, 592, 593, | 2520 | 586, 587, 588, 589, 590, 591, 592, 593, |
2562 | 594, 595, 596, 597, 598, 599, 600, 601, | 2521 | 594, 595, 596, 597, 598, 599, 470, 501, |
2563 | 472, 503, 427, 602, 421, 422, 422, 422, | 2522 | 425, 600, 418, 419, 419, 419, 419, 419, |
2564 | 422, 422, 421, 421, 421, 422, 421, 422, | 2523 | 418, 418, 418, 419, 418, 419, 419, 418, |
2565 | 422, 421, 422, 421, 422, 422, 421, 421, | 2524 | 419, 418, 419, 419, 418, 418, 418, 419, |
2566 | 421, 422, 422, 422, 421, 421, 421, 422, | 2525 | 419, 419, 418, 418, 418, 419, 419, 419, |
2567 | 422, 422, 421, 421, 421, 421, 422, 421, | 2526 | 418, 418, 418, 418, 419, 418, 418, 419, |
2568 | 421, 422, 421, 421, 422, 422, 422, 421, | 2527 | 418, 418, 419, 419, 419, 418, 418, 419, |
2569 | 421, 422, 421, 422, 422, 422, 421, 422, | 2528 | 418, 419, 419, 419, 418, 419, 419, 419, |
2570 | 422, 422, 422, 422, 422, 421, 421, 421, | 2529 | 419, 419, 419, 418, 418, 418, 419, 419, |
2571 | 422, 422, 421, 422, 422, 421, 422, 422, | 2530 | 418, 419, 419, 418, 419, 419, 418, 419, |
2572 | 421, 422, 422, 421, 422, 422, 422, 422, | 2531 | 419, 418, 419, 419, 419, 419, 419, 419, |
2573 | 422, 422, 422, 421, 422, 421, 422, 421, | 2532 | 419, 418, 419, 418, 419, 418, 419, 419, |
2574 | 422, 422, 421, 422, 421, 422, 422, 421, | 2533 | 418, 419, 418, 419, 419, 418, 419, 418, |
2575 | 422, 421, 422, 421, 603, 574, 604, 605, | 2534 | 419, 418, 601, 572, 602, 603, 604, 605, |
2576 | 606, 607, 608, 609, 610, 611, 612, 455, | 2535 | 606, 607, 608, 609, 610, 453, 611, 470, |
2577 | 613, 472, 614, 615, 616, 472, 617, 487, | 2536 | 612, 613, 614, 470, 615, 485, 616, 617, |
2578 | 618, 619, 620, 621, 622, 623, 624, 625, | 2537 | 618, 619, 620, 621, 622, 623, 470, 418, |
2579 | 472, 421, 421, 421, 422, 422, 422, 421, | 2538 | 418, 418, 419, 419, 419, 418, 419, 419, |
2580 | 422, 422, 421, 422, 422, 421, 421, 421, | 2539 | 418, 419, 419, 418, 418, 418, 418, 418, |
2581 | 421, 421, 422, 422, 422, 422, 421, 422, | 2540 | 419, 419, 419, 419, 418, 419, 419, 419, |
2582 | 422, 422, 422, 422, 422, 421, 421, 421, | 2541 | 419, 419, 419, 418, 418, 418, 419, 419, |
2583 | 422, 422, 422, 422, 422, 422, 422, 422, | 2542 | 419, 419, 419, 419, 419, 419, 419, 418, |
2584 | 422, 421, 422, 422, 422, 422, 422, 422, | 2543 | 419, 419, 419, 419, 419, 419, 419, 419, |
2585 | 422, 422, 421, 422, 422, 421, 421, 421, | 2544 | 418, 419, 419, 418, 418, 418, 418, 419, |
2586 | 421, 422, 422, 422, 421, 421, 421, 422, | 2545 | 419, 419, 418, 418, 418, 419, 418, 418, |
2587 | 421, 421, 421, 422, 422, 421, 422, 422, | 2546 | 418, 419, 419, 418, 419, 419, 419, 418, |
2588 | 422, 421, 422, 421, 421, 421, 422, 422, | 2547 | 419, 418, 418, 418, 419, 419, 418, 419, |
2589 | 421, 422, 422, 422, 421, 422, 422, 422, | 2548 | 419, 419, 418, 419, 419, 419, 418, 418, |
2590 | 421, 421, 421, 421, 422, 472, 541, 626, | 2549 | 418, 418, 419, 470, 539, 624, 625, 425, |
2591 | 627, 427, 472, 427, 421, 421, 422, 421, | 2550 | 470, 425, 418, 418, 419, 418, 419, 470, |
2592 | 422, 472, 626, 427, 421, 472, 628, 427, | 2551 | 624, 425, 418, 470, 626, 425, 418, 418, |
2593 | 421, 421, 422, 472, 629, 630, 631, 532, | 2552 | 419, 470, 627, 628, 629, 530, 630, 631, |
2594 | 632, 633, 472, 634, 635, 636, 427, 421, | 2553 | 470, 632, 633, 634, 425, 418, 418, 419, |
2595 | 421, 422, 422, 422, 421, 422, 422, 421, | 2554 | 419, 419, 418, 419, 419, 418, 419, 419, |
2596 | 422, 422, 422, 422, 421, 421, 422, 421, | 2555 | 419, 419, 418, 418, 419, 418, 418, 419, |
2597 | 421, 422, 422, 421, 422, 421, 472, 427, | 2556 | 419, 418, 419, 418, 470, 425, 418, 635, |
2598 | 421, 637, 472, 638, 421, 427, 421, 422, | 2557 | 470, 636, 418, 425, 418, 419, 418, 419, |
2599 | 421, 422, 639, 472, 640, 641, 421, 422, | 2558 | 637, 470, 638, 639, 418, 419, 418, 418, |
2600 | 421, 421, 421, 422, 422, 422, 422, 421, | 2559 | 418, 419, 419, 419, 419, 418, 640, 641, |
2601 | 642, 643, 644, 472, 645, 646, 647, 648, | 2560 | 642, 470, 643, 644, 645, 646, 647, 648, |
2602 | 649, 650, 651, 652, 653, 654, 655, 656, | 2561 | 649, 650, 651, 652, 653, 654, 655, 656, |
2603 | 657, 658, 427, 421, 422, 422, 422, 421, | 2562 | 425, 418, 419, 419, 419, 418, 418, 418, |
2604 | 421, 421, 421, 422, 422, 421, 421, 422, | 2563 | 418, 419, 419, 418, 418, 419, 418, 418, |
2605 | 421, 421, 421, 421, 421, 421, 421, 422, | 2564 | 418, 418, 418, 418, 418, 419, 418, 419, |
2606 | 421, 422, 421, 421, 421, 421, 421, 421, | 2565 | 418, 418, 418, 418, 418, 418, 419, 419, |
2607 | 422, 422, 422, 422, 422, 421, 421, 422, | 2566 | 419, 419, 419, 418, 418, 419, 418, 418, |
2608 | 421, 421, 421, 422, 421, 421, 422, 421, | 2567 | 418, 419, 418, 418, 419, 418, 418, 419, |
2609 | 421, 422, 421, 421, 422, 421, 421, 421, | 2568 | 418, 418, 419, 418, 418, 418, 419, 419, |
2610 | 422, 422, 422, 421, 421, 421, 422, 422, | 2569 | 419, 418, 418, 418, 419, 419, 419, 419, |
2611 | 422, 422, 421, 659, 472, 660, 472, 661, | 2570 | 418, 657, 470, 658, 470, 659, 660, 661, |
2612 | 662, 663, 664, 427, 421, 422, 422, 422, | 2571 | 662, 425, 418, 419, 419, 419, 419, 419, |
2613 | 422, 422, 421, 421, 421, 422, 421, 421, | 2572 | 418, 418, 418, 419, 418, 418, 419, 419, |
2614 | 422, 422, 422, 422, 422, 422, 422, 422, | 2573 | 419, 419, 419, 419, 419, 419, 419, 419, |
2615 | 422, 422, 421, 422, 422, 422, 422, 422, | 2574 | 418, 419, 419, 419, 419, 419, 419, 419, |
2616 | 422, 422, 422, 422, 422, 422, 422, 422, | 2575 | 419, 419, 419, 419, 419, 419, 419, 419, |
2617 | 422, 422, 422, 422, 422, 422, 421, 422, | 2576 | 419, 419, 419, 419, 418, 419, 419, 419, |
2618 | 422, 422, 422, 422, 421, 665, 472, 427, | 2577 | 419, 419, 418, 663, 470, 425, 418, 419, |
2619 | 421, 422, 666, 472, 457, 427, 421, 422, | 2578 | 664, 470, 455, 425, 418, 419, 665, 418, |
2620 | 667, 421, 427, 421, 422, 472, 668, 427, | 2579 | 425, 418, 419, 470, 666, 425, 418, 418, |
2621 | 421, 421, 422, 669, 421, 472, 670, 427, | 2580 | 419, 667, 418, 470, 668, 425, 418, 418, |
2622 | 421, 421, 422, 672, 671, 422, 422, 422, | 2581 | 419, 670, 669, 419, 419, 419, 419, 670, |
2623 | 422, 672, 671, 422, 672, 671, 672, 672, | 2582 | 669, 419, 670, 669, 670, 670, 419, 670, |
2624 | 422, 672, 671, 422, 672, 422, 672, 671, | 2583 | 669, 419, 670, 419, 670, 669, 419, 670, |
2625 | 422, 672, 422, 672, 422, 671, 672, 672, | 2584 | 419, 670, 419, 669, 670, 670, 670, 670, |
2626 | 672, 672, 672, 672, 672, 672, 671, 422, | 2585 | 670, 670, 670, 670, 669, 419, 419, 670, |
2627 | 422, 672, 672, 422, 672, 422, 672, 671, | 2586 | 670, 419, 670, 419, 670, 669, 670, 670, |
2628 | 672, 672, 672, 672, 672, 422, 672, 422, | 2587 | 670, 670, 670, 419, 670, 419, 670, 419, |
2629 | 672, 422, 672, 671, 672, 672, 422, 672, | 2588 | 670, 669, 670, 670, 419, 670, 419, 670, |
2630 | 422, 672, 671, 672, 672, 672, 672, 672, | 2589 | 669, 670, 670, 670, 670, 670, 419, 670, |
2631 | 422, 672, 422, 672, 671, 422, 422, 672, | 2590 | 419, 670, 669, 419, 419, 670, 419, 670, |
2632 | 422, 672, 671, 672, 672, 672, 422, 672, | 2591 | 669, 670, 670, 670, 419, 670, 419, 670, |
2633 | 422, 672, 422, 672, 422, 672, 671, 672, | 2592 | 419, 670, 419, 670, 669, 670, 419, 670, |
2634 | 422, 672, 422, 672, 671, 422, 672, 672, | 2593 | 419, 670, 669, 419, 670, 670, 670, 670, |
2635 | 672, 672, 422, 672, 422, 672, 422, 672, | 2594 | 419, 670, 419, 670, 419, 670, 419, 670, |
2636 | 422, 672, 422, 672, 422, 672, 671, 422, | 2595 | 419, 670, 419, 670, 669, 419, 670, 669, |
2637 | 672, 671, 672, 672, 672, 422, 672, 422, | 2596 | 670, 670, 670, 419, 670, 419, 670, 669, |
2638 | 672, 671, 672, 422, 672, 422, 672, 671, | 2597 | 670, 419, 670, 419, 670, 669, 419, 670, |
2639 | 422, 672, 672, 672, 672, 422, 672, 422, | 2598 | 670, 670, 670, 419, 670, 419, 670, 669, |
2640 | 672, 671, 422, 672, 422, 672, 422, 672, | 2599 | 419, 670, 419, 670, 419, 670, 669, 670, |
2641 | 671, 672, 672, 422, 672, 422, 672, 671, | 2600 | 670, 419, 670, 419, 670, 669, 419, 670, |
2642 | 422, 672, 422, 672, 422, 672, 422, 671, | 2601 | 419, 670, 419, 670, 419, 669, 670, 670, |
2643 | 672, 672, 672, 422, 672, 422, 672, 671, | 2602 | 670, 419, 670, 419, 670, 669, 419, 670, |
2644 | 422, 672, 671, 672, 672, 422, 672, 671, | 2603 | 669, 670, 670, 419, 670, 669, 670, 670, |
2645 | 672, 672, 672, 422, 672, 672, 672, 672, | 2604 | 670, 419, 670, 670, 670, 670, 670, 670, |
2646 | 672, 672, 422, 422, 672, 422, 672, 422, | 2605 | 419, 419, 670, 419, 670, 419, 670, 419, |
2647 | 672, 422, 672, 671, 672, 422, 672, 422, | 2606 | 670, 669, 670, 419, 670, 419, 670, 669, |
2648 | 672, 671, 422, 672, 671, 672, 422, 672, | 2607 | 419, 670, 669, 670, 419, 670, 669, 670, |
2649 | 671, 672, 422, 672, 671, 422, 422, 672, | 2608 | 419, 670, 669, 419, 419, 670, 669, 419, |
2650 | 671, 422, 672, 422, 672, 422, 672, 422, | 2609 | 670, 419, 670, 419, 670, 419, 670, 419, |
2651 | 672, 422, 672, 422, 671, 672, 672, 422, | 2610 | 670, 419, 669, 670, 670, 419, 670, 670, |
2652 | 672, 672, 672, 672, 422, 422, 672, 672, | 2611 | 670, 670, 419, 419, 670, 670, 670, 670, |
2653 | 672, 672, 672, 422, 672, 672, 672, 672, | 2612 | 670, 419, 670, 670, 670, 670, 670, 669, |
2654 | 672, 671, 422, 672, 672, 422, 672, 422, | 2613 | 419, 670, 670, 419, 670, 419, 669, 670, |
2655 | 671, 672, 672, 422, 672, 671, 422, 422, | 2614 | 670, 419, 670, 669, 419, 419, 670, 419, |
2656 | 672, 422, 671, 672, 672, 671, 422, 672, | 2615 | 669, 670, 670, 669, 419, 670, 419, 669, |
2657 | 422, 671, 672, 671, 422, 672, 422, 672, | 2616 | 670, 669, 419, 670, 419, 670, 419, 669, |
2658 | 422, 671, 672, 672, 671, 422, 672, 422, | 2617 | 670, 670, 669, 419, 670, 419, 670, 419, |
2659 | 672, 422, 672, 671, 672, 422, 672, 422, | 2618 | 670, 669, 670, 419, 670, 419, 670, 669, |
2660 | 672, 671, 422, 672, 671, 422, 422, 672, | 2619 | 419, 670, 669, 419, 419, 670, 669, 670, |
2661 | 671, 672, 422, 671, 672, 671, 422, 672, | 2620 | 419, 669, 670, 669, 419, 670, 419, 670, |
2662 | 422, 672, 422, 671, 672, 671, 422, 422, | 2621 | 419, 669, 670, 669, 419, 419, 670, 669, |
2663 | 672, 671, 672, 422, 672, 422, 672, 671, | 2622 | 670, 419, 670, 419, 670, 669, 419, 670, |
2664 | 422, 672, 422, 671, 672, 671, 422, 422, | 2623 | 419, 669, 670, 669, 419, 419, 670, 419, |
2665 | 672, 422, 671, 672, 671, 422, 422, 672, | 2624 | 669, 670, 669, 419, 419, 670, 669, 670, |
2666 | 671, 672, 422, 672, 671, 672, 422, 672, | 2625 | 419, 670, 669, 670, 419, 670, 669, 670, |
2667 | 671, 672, 422, 672, 422, 672, 422, 671, | 2626 | 419, 670, 419, 670, 419, 669, 670, 669, |
2668 | 672, 671, 422, 422, 672, 671, 672, 422, | 2627 | 419, 419, 670, 669, 670, 419, 670, 419, |
2669 | 672, 422, 672, 671, 422, 672, 671, 672, | 2628 | 670, 669, 419, 670, 669, 670, 670, 419, |
2670 | 672, 422, 672, 422, 672, 671, 671, 422, | 2629 | 670, 419, 670, 669, 669, 419, 669, 419, |
2671 | 671, 422, 672, 672, 422, 672, 672, 672, | 2630 | 670, 670, 419, 670, 670, 670, 670, 670, |
2672 | 672, 672, 672, 672, 671, 422, 672, 672, | 2631 | 670, 670, 669, 419, 670, 670, 670, 419, |
2673 | 672, 422, 671, 672, 672, 672, 422, 672, | 2632 | 669, 670, 670, 670, 419, 670, 419, 670, |
2674 | 422, 672, 422, 672, 422, 672, 422, 672, | 2633 | 419, 670, 419, 670, 419, 670, 669, 419, |
2675 | 671, 422, 422, 672, 671, 672, 422, 672, | 2634 | 419, 670, 669, 670, 419, 670, 669, 419, |
2676 | 671, 422, 422, 672, 422, 422, 422, 672, | 2635 | 419, 670, 419, 419, 419, 670, 419, 670, |
2677 | 422, 672, 422, 672, 422, 672, 422, 671, | 2636 | 419, 670, 419, 670, 419, 669, 419, 670, |
2678 | 422, 672, 422, 672, 422, 671, 672, 671, | 2637 | 419, 670, 419, 669, 670, 669, 419, 670, |
2679 | 422, 672, 422, 671, 672, 422, 672, 672, | 2638 | 419, 669, 670, 419, 670, 670, 670, 669, |
2680 | 672, 671, 422, 672, 422, 422, 672, 422, | 2639 | 419, 670, 419, 419, 670, 419, 669, 670, |
2681 | 671, 672, 672, 671, 422, 672, 672, 672, | 2640 | 670, 669, 419, 670, 670, 670, 670, 419, |
2682 | 672, 422, 672, 422, 671, 672, 672, 672, | 2641 | 670, 419, 669, 670, 670, 670, 419, 670, |
2683 | 422, 672, 671, 672, 422, 672, 422, 672, | 2642 | 669, 670, 419, 670, 419, 670, 419, 670, |
2684 | 422, 672, 422, 672, 671, 672, 672, 422, | 2643 | 419, 670, 669, 670, 670, 419, 670, 669, |
2685 | 672, 671, 422, 672, 422, 672, 422, 671, | 2644 | 419, 670, 419, 670, 419, 669, 670, 670, |
2686 | 672, 672, 671, 422, 672, 422, 671, 672, | 2645 | 669, 419, 670, 419, 669, 670, 669, 419, |
2687 | 671, 422, 672, 671, 422, 672, 422, 672, | 2646 | 670, 669, 419, 670, 419, 670, 669, 670, |
2688 | 671, 672, 672, 672, 671, 422, 422, 422, | 2647 | 670, 670, 669, 419, 419, 419, 670, 669, |
2689 | 672, 671, 422, 672, 422, 671, 672, 671, | 2648 | 419, 670, 419, 669, 670, 669, 419, 670, |
2690 | 422, 672, 422, 672, 422, 671, 672, 672, | 2649 | 419, 670, 419, 669, 670, 670, 670, 669, |
2691 | 672, 671, 422, 672, 422, 671, 672, 672, | 2650 | 419, 670, 419, 669, 670, 670, 670, 670, |
2692 | 672, 672, 671, 422, 672, 422, 672, 671, | 2651 | 669, 419, 670, 419, 670, 669, 419, 419, |
2693 | 422, 422, 672, 422, 672, 671, 672, 422, | 2652 | 670, 419, 670, 669, 670, 419, 670, 419, |
2694 | 672, 422, 671, 672, 672, 671, 422, 672, | 2653 | 669, 670, 670, 669, 419, 670, 419, 670, |
2695 | 422, 672, 671, 422, 672, 672, 672, 422, | 2654 | 669, 419, 670, 670, 670, 419, 670, 419, |
2696 | 672, 422, 671, 422, 672, 671, 672, 422, | 2655 | 669, 419, 670, 669, 670, 419, 419, 670, |
2697 | 422, 672, 422, 672, 422, 671, 672, 672, | 2656 | 419, 670, 419, 669, 670, 670, 670, 670, |
2698 | 672, 672, 671, 422, 672, 422, 672, 422, | 2657 | 669, 419, 670, 419, 670, 419, 670, 419, |
2699 | 672, 422, 672, 422, 672, 671, 672, 672, | 2658 | 670, 419, 670, 669, 670, 670, 670, 419, |
2700 | 672, 422, 672, 422, 672, 422, 672, 422, | 2659 | 670, 419, 670, 419, 670, 419, 669, 670, |
2701 | 671, 672, 672, 422, 422, 672, 671, 672, | 2660 | 670, 419, 419, 670, 669, 670, 419, 670, |
2702 | 422, 672, 672, 671, 422, 672, 422, 672, | 2661 | 670, 669, 419, 670, 419, 670, 669, 419, |
2703 | 671, 422, 422, 672, 672, 672, 672, 422, | 2662 | 419, 670, 670, 670, 670, 419, 670, 419, |
2704 | 672, 422, 672, 422, 671, 672, 672, 422, | 2663 | 670, 419, 669, 670, 670, 419, 669, 670, |
2705 | 671, 672, 671, 422, 672, 422, 671, 672, | 2664 | 669, 419, 670, 419, 669, 670, 669, 419, |
2706 | 671, 422, 672, 422, 671, 672, 422, 672, | 2665 | 670, 419, 669, 670, 419, 670, 670, 669, |
2707 | 672, 671, 422, 672, 672, 422, 671, 672, | 2666 | 419, 670, 670, 419, 669, 670, 669, 419, |
2708 | 671, 422, 672, 422, 672, 671, 672, 422, | 2667 | 670, 419, 670, 669, 670, 419, 670, 419, |
2709 | 672, 422, 671, 672, 671, 422, 672, 422, | 2668 | 669, 670, 669, 419, 670, 419, 670, 419, |
2710 | 672, 422, 672, 422, 672, 422, 672, 671, | 2669 | 670, 419, 670, 419, 670, 669, 671, 669, |
2711 | 673, 671, 674, 675, 676, 677, 678, 679, | 2670 | 672, 673, 674, 675, 676, 677, 678, 679, |
2712 | 680, 681, 682, 683, 684, 676, 685, 686, | 2671 | 680, 681, 682, 674, 683, 684, 685, 686, |
2713 | 687, 688, 689, 676, 690, 691, 692, 693, | 2672 | 687, 674, 688, 689, 690, 691, 692, 693, |
2714 | 694, 695, 696, 697, 698, 699, 700, 701, | 2673 | 694, 695, 696, 697, 698, 699, 700, 701, |
2715 | 702, 703, 704, 676, 705, 673, 685, 673, | 2674 | 702, 674, 703, 671, 683, 671, 704, 671, |
2716 | 706, 673, 671, 672, 672, 672, 672, 422, | 2675 | 669, 670, 670, 670, 670, 419, 669, 670, |
2717 | 671, 672, 672, 671, 422, 672, 671, 422, | 2676 | 670, 669, 419, 670, 669, 419, 419, 670, |
2718 | 422, 672, 671, 422, 672, 422, 671, 672, | 2677 | 669, 419, 670, 419, 669, 670, 669, 419, |
2719 | 671, 422, 422, 672, 422, 671, 672, 672, | 2678 | 419, 670, 419, 669, 670, 670, 669, 419, |
2720 | 671, 422, 672, 672, 672, 671, 422, 672, | 2679 | 670, 670, 670, 669, 419, 670, 419, 670, |
2721 | 422, 672, 672, 671, 422, 422, 672, 422, | 2680 | 670, 669, 419, 419, 670, 419, 669, 670, |
2722 | 671, 672, 671, 422, 672, 671, 422, 422, | 2681 | 669, 419, 670, 669, 419, 419, 670, 419, |
2723 | 672, 422, 672, 671, 422, 672, 422, 422, | 2682 | 670, 669, 419, 670, 419, 419, 670, 419, |
2724 | 672, 422, 672, 422, 671, 672, 672, 671, | 2683 | 670, 419, 669, 670, 670, 669, 419, 670, |
2725 | 422, 672, 672, 422, 672, 671, 422, 672, | 2684 | 670, 419, 670, 669, 419, 670, 419, 670, |
2726 | 422, 672, 671, 422, 672, 422, 671, 422, | 2685 | 669, 419, 670, 419, 669, 419, 670, 670, |
2727 | 672, 672, 672, 422, 672, 671, 672, 422, | 2686 | 670, 419, 670, 669, 670, 419, 670, 669, |
2728 | 672, 671, 422, 672, 671, 672, 422, 672, | 2687 | 419, 670, 669, 670, 419, 670, 669, 419, |
2729 | 671, 422, 672, 671, 422, 672, 422, 672, | 2688 | 670, 669, 419, 670, 419, 670, 669, 419, |
2730 | 671, 422, 672, 671, 422, 672, 671, 707, | 2689 | 670, 669, 419, 670, 669, 705, 706, 707, |
2731 | 708, 709, 710, 711, 712, 713, 714, 715, | 2690 | 708, 709, 710, 711, 712, 713, 714, 715, |
2732 | 716, 717, 718, 678, 719, 720, 721, 722, | 2691 | 716, 676, 717, 718, 719, 720, 721, 718, |
2733 | 723, 720, 724, 725, 726, 727, 728, 729, | 2692 | 722, 723, 724, 725, 726, 727, 728, 729, |
2734 | 730, 731, 732, 673, 671, 672, 422, 672, | 2693 | 730, 671, 669, 670, 419, 670, 669, 670, |
2735 | 671, 672, 422, 672, 671, 672, 422, 672, | 2694 | 419, 670, 669, 670, 419, 670, 669, 670, |
2736 | 671, 672, 422, 672, 671, 422, 672, 422, | 2695 | 419, 670, 669, 419, 670, 419, 670, 669, |
2737 | 672, 671, 672, 422, 672, 671, 672, 422, | 2696 | 670, 419, 670, 669, 670, 419, 419, 419, |
2738 | 422, 422, 672, 671, 672, 422, 672, 671, | 2697 | 670, 669, 670, 419, 670, 669, 670, 670, |
2739 | 672, 672, 672, 672, 422, 672, 422, 671, | 2698 | 670, 670, 419, 670, 419, 669, 670, 669, |
2740 | 672, 671, 422, 422, 672, 422, 672, 671, | 2699 | 419, 419, 670, 419, 670, 669, 670, 419, |
2741 | 672, 422, 672, 671, 422, 672, 671, 672, | 2700 | 670, 669, 419, 670, 669, 670, 670, 419, |
2742 | 672, 422, 672, 671, 422, 672, 671, 672, | 2701 | 670, 669, 419, 670, 669, 670, 419, 670, |
2743 | 422, 672, 671, 422, 672, 671, 422, 672, | 2702 | 669, 419, 670, 669, 419, 670, 669, 419, |
2744 | 671, 422, 672, 671, 672, 671, 422, 422, | 2703 | 670, 669, 670, 669, 419, 419, 670, 669, |
2745 | 672, 671, 672, 422, 672, 671, 422, 672, | 2704 | 670, 419, 670, 669, 419, 670, 419, 669, |
2746 | 422, 671, 672, 671, 422, 676, 733, 673, | 2705 | 670, 669, 419, 674, 731, 671, 674, 732, |
2747 | 676, 734, 676, 735, 685, 673, 671, 672, | 2706 | 674, 733, 683, 671, 669, 670, 669, 419, |
2748 | 671, 422, 672, 671, 422, 676, 734, 685, | 2707 | 670, 669, 419, 674, 732, 683, 671, 669, |
2749 | 673, 671, 676, 736, 673, 685, 673, 671, | 2708 | 674, 734, 671, 683, 671, 669, 670, 669, |
2750 | 672, 671, 422, 676, 737, 694, 738, 720, | 2709 | 419, 674, 735, 692, 736, 718, 737, 730, |
2751 | 739, 732, 676, 740, 741, 742, 673, 685, | 2710 | 674, 738, 739, 740, 671, 683, 671, 669, |
2752 | 673, 671, 672, 671, 422, 672, 422, 672, | 2711 | 670, 669, 419, 670, 419, 670, 669, 419, |
2753 | 671, 422, 672, 422, 672, 422, 671, 672, | 2712 | 670, 419, 670, 419, 669, 670, 670, 669, |
2754 | 672, 671, 422, 672, 422, 672, 671, 422, | 2713 | 419, 670, 419, 670, 669, 419, 670, 669, |
2755 | 672, 671, 676, 685, 427, 671, 743, 676, | 2714 | 674, 683, 425, 669, 741, 674, 742, 683, |
2756 | 744, 685, 673, 671, 427, 672, 671, 422, | 2715 | 671, 669, 425, 670, 669, 419, 670, 669, |
2757 | 672, 671, 422, 745, 676, 746, 747, 673, | 2716 | 419, 743, 674, 744, 745, 671, 669, 419, |
2758 | 671, 422, 672, 671, 672, 672, 671, 422, | 2717 | 670, 669, 670, 670, 669, 419, 419, 670, |
2759 | 422, 672, 422, 672, 671, 676, 748, 749, | 2718 | 419, 670, 669, 674, 746, 747, 748, 749, |
2760 | 750, 751, 752, 753, 754, 755, 756, 757, | 2719 | 750, 751, 752, 753, 754, 755, 756, 671, |
2761 | 758, 673, 685, 673, 671, 672, 422, 672, | 2720 | 683, 671, 669, 670, 419, 670, 670, 670, |
2762 | 672, 672, 672, 672, 672, 672, 422, 672, | 2721 | 670, 670, 670, 670, 419, 670, 419, 670, |
2763 | 422, 672, 672, 672, 672, 672, 672, 671, | 2722 | 670, 670, 670, 670, 670, 669, 419, 670, |
2764 | 422, 672, 672, 422, 672, 422, 671, 672, | 2723 | 670, 419, 670, 419, 669, 670, 419, 670, |
2765 | 422, 672, 672, 672, 422, 672, 672, 422, | 2724 | 670, 670, 419, 670, 670, 419, 670, 670, |
2766 | 672, 672, 422, 672, 672, 422, 672, 672, | 2725 | 419, 670, 670, 419, 670, 670, 669, 419, |
2767 | 671, 422, 676, 759, 676, 735, 760, 761, | 2726 | 674, 757, 674, 733, 758, 759, 760, 671, |
2768 | 762, 673, 685, 673, 671, 672, 671, 422, | 2727 | 683, 671, 669, 670, 669, 419, 670, 670, |
2769 | 672, 672, 672, 422, 672, 672, 672, 422, | 2728 | 670, 419, 670, 670, 670, 419, 670, 419, |
2770 | 672, 422, 672, 671, 422, 422, 422, 422, | 2729 | 670, 669, 419, 419, 419, 419, 670, 670, |
2771 | 672, 672, 422, 422, 422, 422, 422, 672, | 2730 | 419, 419, 419, 419, 419, 670, 670, 670, |
2772 | 672, 672, 672, 672, 672, 672, 422, 672, | 2731 | 670, 670, 670, 670, 419, 670, 419, 670, |
2773 | 422, 672, 422, 671, 672, 672, 672, 422, | 2732 | 419, 669, 670, 670, 670, 419, 670, 419, |
2774 | 672, 422, 672, 671, 685, 427, 763, 676, | 2733 | 670, 669, 683, 425, 761, 674, 683, 425, |
2775 | 685, 427, 672, 671, 422, 764, 676, 765, | 2734 | 670, 669, 419, 762, 674, 763, 683, 425, |
2776 | 685, 427, 672, 671, 422, 672, 422, 766, | 2735 | 670, 669, 419, 670, 419, 764, 683, 671, |
2777 | 685, 673, 671, 427, 672, 671, 422, 676, | 2736 | 669, 425, 670, 669, 419, 674, 765, 671, |
2778 | 767, 673, 685, 673, 671, 672, 671, 422, | 2737 | 683, 671, 669, 670, 669, 419, 766, 766, |
2779 | 768, 769, 768, 770, 771, 768, 772, 768, | 2738 | 766, 768, 769, 770, 766, 767, 767, 771, |
2780 | 773, 768, 771, 774, 775, 774, 777, 776, | 2739 | 768, 771, 769, 771, 767, 772, 773, 772, |
2781 | 778, 779, 778, 780, 781, 776, 782, 776, | 2740 | 775, 774, 776, 774, 777, 774, 779, 778, |
2782 | 783, 778, 784, 779, 785, 780, 787, 786, | 2741 | 781, 782, 780, 781, 783, 780, 785, 784, |
2783 | 788, 789, 789, 786, 790, 786, 791, 788, | 2742 | 786, 784, 787, 784, 789, 788, 791, 792, |
2784 | 792, 789, 793, 789, 795, 795, 795, 795, | 2743 | 790, 791, 793, 790, 795, 795, 795, 795, |
2785 | 794, 795, 795, 795, 794, 795, 794, 795, | 2744 | 794, 795, 795, 795, 794, 795, 794, 795, |
2786 | 795, 794, 794, 794, 794, 794, 794, 795, | 2745 | 795, 794, 794, 794, 794, 794, 794, 795, |
2787 | 794, 794, 794, 794, 795, 795, 795, 795, | 2746 | 794, 794, 794, 794, 795, 795, 795, 795, |
@@ -3103,375 +3062,343 @@ var _hcltok_indicies []int16 = []int16{ | |||
3103 | 1046, 1045, 795, 1046, 795, 1140, 1059, 1047, | 3062 | 1046, 1045, 795, 1046, 795, 1140, 1059, 1047, |
3104 | 1045, 801, 1046, 1045, 795, 1050, 1141, 1047, | 3063 | 1045, 801, 1046, 1045, 795, 1050, 1141, 1047, |
3105 | 1059, 1047, 1045, 1046, 1045, 795, 1142, 1143, | 3064 | 1059, 1047, 1045, 1046, 1045, 795, 1142, 1143, |
3106 | 1144, 1142, 1145, 1146, 1147, 1148, 1149, 1150, | 3065 | 1144, 1142, 1145, 1146, 1147, 1149, 1150, 1151, |
3107 | 1151, 1152, 1153, 1154, 672, 672, 422, 1155, | 3066 | 1152, 1153, 1154, 670, 670, 419, 1155, 1156, |
3108 | 1156, 1157, 1158, 672, 1161, 1162, 1164, 1165, | 3067 | 1157, 1158, 670, 1161, 1162, 1164, 1165, 1166, |
3109 | 1166, 1160, 1167, 1168, 1169, 1170, 1171, 1172, | 3068 | 1160, 1167, 1168, 1169, 1170, 1171, 1172, 1173, |
3110 | 1173, 1174, 1175, 1176, 1177, 1178, 1179, 1180, | 3069 | 1174, 1175, 1176, 1177, 1178, 1179, 1180, 1181, |
3111 | 1181, 1182, 1183, 1184, 1185, 1186, 1188, 1189, | 3070 | 1182, 1183, 1184, 1185, 1186, 1188, 1189, 1190, |
3112 | 1190, 1191, 1192, 1193, 672, 1148, 10, 1148, | 3071 | 1191, 1192, 1193, 670, 1148, 7, 1148, 419, |
3113 | 422, 1148, 422, 1160, 1163, 1187, 1194, 1159, | 3072 | 1148, 419, 1160, 1163, 1187, 1194, 1159, 1142, |
3114 | 1142, 1142, 1195, 1143, 1196, 1198, 1197, 2, | 3073 | 1142, 1195, 1143, 1196, 1198, 1197, 4, 1147, |
3115 | 1, 1199, 1197, 1200, 1197, 5, 1, 1197, | 3074 | 1200, 1197, 1201, 1197, 2, 1147, 1197, 6, |
3116 | 6, 5, 9, 11, 11, 10, 1202, 1203, | 3075 | 8, 8, 7, 1202, 1203, 1204, 1197, 1205, |
3117 | 1204, 1197, 1205, 1206, 1197, 1207, 1197, 422, | 3076 | 1206, 1197, 1207, 1197, 419, 419, 1209, 1210, |
3118 | 422, 1209, 1210, 491, 472, 1211, 472, 1212, | 3077 | 489, 470, 1211, 470, 1212, 1213, 1214, 1215, |
3119 | 1213, 1214, 1215, 1216, 1217, 1218, 1219, 1220, | 3078 | 1216, 1217, 1218, 1219, 1220, 1221, 1222, 544, |
3120 | 1221, 1222, 546, 1223, 522, 1224, 1225, 1226, | 3079 | 1223, 520, 1224, 1225, 1226, 1227, 1228, 1229, |
3121 | 1227, 1228, 1229, 1230, 1231, 1232, 1233, 1234, | 3080 | 1230, 1231, 1232, 1233, 1234, 1235, 419, 419, |
3122 | 1235, 422, 422, 422, 427, 567, 1208, 1236, | 3081 | 419, 425, 565, 1208, 1236, 1197, 1237, 1197, |
3123 | 1197, 1237, 1197, 672, 1238, 422, 422, 422, | 3082 | 670, 1238, 419, 419, 419, 670, 1238, 670, |
3124 | 672, 1238, 672, 672, 422, 1238, 422, 1238, | 3083 | 670, 419, 1238, 419, 1238, 419, 1238, 419, |
3125 | 422, 1238, 422, 672, 672, 672, 672, 672, | 3084 | 670, 670, 670, 670, 670, 1238, 419, 670, |
3126 | 1238, 422, 672, 672, 672, 422, 672, 422, | 3085 | 670, 670, 419, 670, 419, 1238, 419, 670, |
3127 | 1238, 422, 672, 672, 672, 672, 422, 1238, | 3086 | 670, 670, 670, 419, 1238, 670, 419, 670, |
3128 | 672, 422, 672, 422, 672, 422, 672, 672, | 3087 | 419, 670, 419, 670, 670, 419, 670, 1238, |
3129 | 422, 672, 1238, 422, 672, 422, 672, 422, | 3088 | 419, 670, 419, 670, 419, 670, 1238, 670, |
3130 | 672, 1238, 672, 422, 1238, 672, 422, 672, | 3089 | 419, 1238, 670, 419, 670, 419, 1238, 670, |
3131 | 422, 1238, 672, 672, 672, 672, 672, 1238, | 3090 | 670, 670, 670, 670, 1238, 419, 419, 670, |
3132 | 422, 422, 672, 422, 672, 1238, 672, 422, | 3091 | 419, 670, 1238, 670, 419, 1238, 670, 670, |
3133 | 1238, 672, 672, 1238, 422, 422, 672, 422, | 3092 | 1238, 419, 419, 670, 419, 670, 419, 670, |
3134 | 672, 422, 672, 1238, 1239, 1240, 1241, 1242, | 3093 | 1238, 1239, 1240, 1241, 1242, 1243, 1244, 1245, |
3135 | 1243, 1244, 1245, 1246, 1247, 1248, 1249, 717, | 3094 | 1246, 1247, 1248, 1249, 715, 1250, 1251, 1252, |
3136 | 1250, 1251, 1252, 1253, 1254, 1255, 1256, 1257, | 3095 | 1253, 1254, 1255, 1256, 1257, 1258, 1259, 1260, |
3137 | 1258, 1259, 1260, 1261, 1260, 1262, 1263, 1264, | 3096 | 1261, 1260, 1262, 1263, 1264, 1265, 1266, 671, |
3138 | 1265, 1266, 673, 1238, 1267, 1268, 1269, 1270, | 3097 | 1238, 1267, 1268, 1269, 1270, 1271, 1272, 1273, |
3139 | 1271, 1272, 1273, 1274, 1275, 1276, 1277, 1278, | 3098 | 1274, 1275, 1276, 1277, 1278, 1279, 1280, 1281, |
3140 | 1279, 1280, 1281, 1282, 1283, 1284, 1285, 727, | 3099 | 1282, 1283, 1284, 1285, 725, 1286, 1287, 1288, |
3141 | 1286, 1287, 1288, 694, 1289, 1290, 1291, 1292, | 3100 | 692, 1289, 1290, 1291, 1292, 1293, 1294, 671, |
3142 | 1293, 1294, 673, 1295, 1296, 1297, 1298, 1299, | 3101 | 1295, 1296, 1297, 1298, 1299, 1300, 1301, 1302, |
3143 | 1300, 1301, 1302, 676, 1303, 673, 676, 1304, | 3102 | 674, 1303, 671, 674, 1304, 1305, 1306, 1307, |
3144 | 1305, 1306, 1307, 685, 1238, 1308, 1309, 1310, | 3103 | 683, 1238, 1308, 1309, 1310, 1311, 703, 1312, |
3145 | 1311, 705, 1312, 1313, 685, 1314, 1315, 1316, | 3104 | 1313, 683, 1314, 1315, 1316, 1317, 1318, 671, |
3146 | 1317, 1318, 673, 1238, 1319, 1278, 1320, 1321, | 3105 | 1238, 1319, 1278, 1320, 1321, 1322, 683, 1323, |
3147 | 1322, 685, 1323, 1324, 676, 673, 685, 427, | 3106 | 1324, 674, 671, 683, 425, 1238, 1288, 671, |
3148 | 1238, 1288, 673, 676, 685, 427, 685, 427, | 3107 | 674, 683, 425, 683, 425, 1325, 683, 1238, |
3149 | 1325, 685, 1238, 427, 676, 1326, 1327, 676, | 3108 | 425, 674, 1326, 1327, 674, 1328, 1329, 681, |
3150 | 1328, 1329, 683, 1330, 1331, 1332, 1333, 1334, | 3109 | 1330, 1331, 1332, 1333, 1334, 1284, 1335, 1336, |
3151 | 1284, 1335, 1336, 1337, 1338, 1339, 1340, 1341, | 3110 | 1337, 1338, 1339, 1340, 1341, 1342, 1343, 1344, |
3152 | 1342, 1343, 1344, 1345, 1346, 1303, 1347, 676, | 3111 | 1345, 1346, 1303, 1347, 674, 683, 425, 1238, |
3153 | 685, 427, 1238, 1348, 1349, 685, 673, 1238, | 3112 | 1348, 1349, 683, 671, 1238, 425, 671, 1238, |
3154 | 427, 673, 1238, 676, 1350, 733, 1351, 1352, | 3113 | 674, 1350, 731, 1351, 1352, 1353, 1354, 1355, |
3155 | 1353, 1354, 1355, 1356, 1357, 1358, 673, 1359, | 3114 | 1356, 1357, 1358, 671, 1359, 1360, 1361, 1362, |
3156 | 1360, 1361, 1362, 1363, 1364, 673, 685, 1238, | 3115 | 1363, 1364, 671, 683, 1238, 1366, 1367, 1368, |
3157 | 1366, 1367, 1368, 1369, 1370, 1371, 1372, 1373, | 3116 | 1369, 1370, 1371, 1372, 1373, 1374, 1375, 1376, |
3158 | 1374, 1375, 1376, 1372, 1378, 1379, 1380, 1381, | 3117 | 1372, 1378, 1379, 1380, 1381, 1365, 1377, 1365, |
3159 | 1365, 1377, 1365, 1238, 1365, 1238, 1382, 1382, | 3118 | 1238, 1365, 1238, 1382, 1382, 1383, 1384, 1385, |
3160 | 1383, 1384, 1385, 1386, 1387, 1388, 1389, 1390, | 3119 | 1386, 1387, 1388, 1389, 1390, 1387, 767, 1391, |
3161 | 1387, 771, 1391, 1391, 1391, 1392, 1393, 1386, | 3120 | 1391, 1391, 1392, 1391, 1391, 768, 769, 770, |
3162 | 1391, 772, 773, 1394, 1391, 771, 1395, 1395, | 3121 | 1391, 767, 1382, 1382, 1393, 1396, 1397, 1395, |
3163 | 1395, 1397, 1398, 1399, 1395, 1400, 1401, 1402, | 3122 | 1398, 1399, 1398, 1400, 1391, 1402, 1401, 1396, |
3164 | 1395, 1396, 1403, 1403, 1403, 1405, 1406, 1407, | 3123 | 1403, 1395, 1405, 1404, 1394, 1394, 1394, 768, |
3165 | 1403, 1408, 1409, 1410, 1403, 1404, 1391, 1391, | 3124 | 769, 770, 1394, 767, 767, 1406, 773, 1406, |
3166 | 1411, 1412, 1386, 1391, 772, 773, 1394, 1391, | 3125 | 1407, 1406, 775, 1408, 1409, 1410, 1411, 1412, |
3167 | 771, 1413, 1414, 1415, 771, 1416, 1417, 1418, | 3126 | 1413, 1414, 1411, 776, 775, 1408, 1415, 1415, |
3168 | 769, 769, 769, 769, 1420, 1421, 1422, 1396, | 3127 | 777, 779, 1416, 1415, 776, 1418, 1419, 1417, |
3169 | 769, 1423, 1424, 1425, 769, 1419, 770, 770, | 3128 | 1418, 1419, 1420, 1417, 775, 1408, 1421, 1415, |
3170 | 770, 1427, 1428, 1429, 1396, 770, 1430, 1431, | 3129 | 775, 1408, 1415, 1423, 1422, 1425, 1424, 776, |
3171 | 1432, 770, 1426, 769, 769, 769, 1434, 1435, | 3130 | 1426, 777, 1426, 779, 1426, 785, 1427, 1428, |
3172 | 1436, 1404, 769, 1437, 1438, 1439, 769, 1433, | 3131 | 1429, 1430, 1431, 1432, 1433, 1430, 786, 785, |
3173 | 1395, 1395, 771, 1440, 1441, 1399, 1395, 1400, | 3132 | 1427, 1434, 1434, 787, 789, 1435, 1434, 786, |
3174 | 1401, 1402, 1395, 1396, 1442, 1443, 1444, 771, | 3133 | 1437, 1438, 1436, 1437, 1438, 1439, 1436, 785, |
3175 | 1445, 1446, 1447, 770, 770, 770, 770, 1449, | 3134 | 1427, 1440, 1434, 785, 1427, 1434, 1442, 1441, |
3176 | 1450, 1451, 1404, 770, 1452, 1453, 1454, 770, | 3135 | 1444, 1443, 786, 1445, 787, 1445, 789, 1445, |
3177 | 1448, 1403, 1403, 771, 1455, 1456, 1407, 1403, | 3136 | 795, 1448, 1449, 1451, 1452, 1453, 1447, 1454, |
3178 | 1408, 1409, 1410, 1403, 1404, 1403, 1403, 1403, | 3137 | 1455, 1456, 1457, 1458, 1459, 1460, 1461, 1462, |
3179 | 1405, 1406, 1407, 771, 1408, 1409, 1410, 1403, | 3138 | 1463, 1464, 1465, 1466, 1467, 1468, 1469, 1470, |
3180 | 1404, 1403, 1403, 1403, 1405, 1406, 1407, 772, | 3139 | 1471, 1472, 1473, 1475, 1476, 1477, 1478, 1479, |
3181 | 1408, 1409, 1410, 1403, 1404, 1403, 1403, 1403, | 3140 | 1480, 795, 795, 1446, 1447, 1450, 1474, 1481, |
3182 | 1405, 1406, 1407, 773, 1408, 1409, 1410, 1403, | 3141 | 1446, 1046, 795, 795, 1483, 1484, 865, 846, |
3183 | 1404, 1395, 1395, 1395, 1397, 1398, 1399, 771, | 3142 | 1485, 846, 1486, 1487, 1488, 1489, 1490, 1491, |
3184 | 1400, 1401, 1402, 1395, 1396, 1395, 1395, 1395, | 3143 | 1492, 1493, 1494, 1495, 1496, 920, 1497, 896, |
3185 | 1397, 1398, 1399, 772, 1400, 1401, 1402, 1395, | 3144 | 1498, 1499, 1500, 1501, 1502, 1503, 1504, 1505, |
3186 | 1396, 1395, 1395, 1395, 1397, 1398, 1399, 773, | 3145 | 1506, 1507, 1508, 1509, 795, 795, 795, 801, |
3187 | 1400, 1401, 1402, 1395, 1396, 1458, 769, 1460, | 3146 | 941, 1482, 1046, 1510, 795, 795, 795, 1046, |
3188 | 1459, 1461, 770, 1463, 1462, 771, 1464, 775, | 3147 | 1510, 1046, 1046, 795, 1510, 795, 1510, 795, |
3189 | 1464, 1465, 1464, 777, 1466, 1467, 1468, 1469, | 3148 | 1510, 795, 1046, 1046, 1046, 1046, 1046, 1510, |
3190 | 1470, 1471, 1472, 1469, 781, 777, 1466, 1474, | 3149 | 795, 1046, 1046, 1046, 795, 1046, 795, 1510, |
3191 | 1475, 1473, 782, 783, 1476, 1473, 781, 1479, | 3150 | 795, 1046, 1046, 1046, 1046, 795, 1510, 1046, |
3192 | 1480, 1481, 1482, 1477, 1483, 1484, 1485, 1477, | 3151 | 795, 1046, 795, 1046, 795, 1046, 1046, 795, |
3193 | 1478, 1488, 1489, 1490, 1491, 1486, 1492, 1493, | 3152 | 1046, 1510, 795, 1046, 795, 1046, 795, 1046, |
3194 | 1494, 1486, 1487, 1496, 1495, 1498, 1497, 781, | 3153 | 1510, 1046, 795, 1510, 1046, 795, 1046, 795, |
3195 | 1499, 782, 1499, 783, 1499, 787, 1500, 1501, | 3154 | 1510, 1046, 1046, 1046, 1046, 1046, 1510, 795, |
3196 | 1502, 1503, 1504, 1505, 1506, 1503, 789, 787, | 3155 | 795, 1046, 795, 1046, 1510, 1046, 795, 1510, |
3197 | 1500, 1508, 1507, 790, 791, 1509, 1507, 789, | 3156 | 1046, 1046, 1510, 795, 795, 1046, 795, 1046, |
3198 | 1511, 1510, 1513, 1512, 789, 1514, 790, 1514, | 3157 | 795, 1046, 1510, 1511, 1512, 1513, 1514, 1515, |
3199 | 791, 1514, 795, 1517, 1518, 1520, 1521, 1522, | 3158 | 1516, 1517, 1518, 1519, 1520, 1521, 1091, 1522, |
3200 | 1516, 1523, 1524, 1525, 1526, 1527, 1528, 1529, | 3159 | 1523, 1524, 1525, 1526, 1527, 1528, 1529, 1530, |
3201 | 1530, 1531, 1532, 1533, 1534, 1535, 1536, 1537, | 3160 | 1531, 1532, 1533, 1532, 1534, 1535, 1536, 1537, |
3202 | 1538, 1539, 1540, 1541, 1542, 1544, 1545, 1546, | 3161 | 1538, 1047, 1510, 1539, 1540, 1541, 1542, 1543, |
3203 | 1547, 1548, 1549, 795, 795, 1515, 1516, 1519, | 3162 | 1544, 1545, 1546, 1547, 1548, 1549, 1550, 1551, |
3204 | 1543, 1550, 1515, 1046, 795, 795, 1552, 1553, | 3163 | 1552, 1553, 1554, 1555, 1556, 1557, 1101, 1558, |
3205 | 865, 846, 1554, 846, 1555, 1556, 1557, 1558, | 3164 | 1559, 1560, 1068, 1561, 1562, 1563, 1564, 1565, |
3206 | 1559, 1560, 1561, 1562, 1563, 1564, 1565, 920, | 3165 | 1566, 1047, 1567, 1568, 1569, 1570, 1571, 1572, |
3207 | 1566, 896, 1567, 1568, 1569, 1570, 1571, 1572, | 3166 | 1573, 1574, 1050, 1575, 1047, 1050, 1576, 1577, |
3208 | 1573, 1574, 1575, 1576, 1577, 1578, 795, 795, | 3167 | 1578, 1579, 1059, 1510, 1580, 1581, 1582, 1583, |
3209 | 795, 801, 941, 1551, 1046, 1579, 795, 795, | 3168 | 1079, 1584, 1585, 1059, 1586, 1587, 1588, 1589, |
3210 | 795, 1046, 1579, 1046, 1046, 795, 1579, 795, | 3169 | 1590, 1047, 1510, 1591, 1550, 1592, 1593, 1594, |
3211 | 1579, 795, 1579, 795, 1046, 1046, 1046, 1046, | 3170 | 1059, 1595, 1596, 1050, 1047, 1059, 801, 1510, |
3212 | 1046, 1579, 795, 1046, 1046, 1046, 795, 1046, | 3171 | 1560, 1047, 1050, 1059, 801, 1059, 801, 1597, |
3213 | 795, 1579, 795, 1046, 1046, 1046, 1046, 795, | 3172 | 1059, 1510, 801, 1050, 1598, 1599, 1050, 1600, |
3214 | 1579, 1046, 795, 1046, 795, 1046, 795, 1046, | 3173 | 1601, 1057, 1602, 1603, 1604, 1605, 1606, 1556, |
3215 | 1046, 795, 1046, 1579, 795, 1046, 795, 1046, | 3174 | 1607, 1608, 1609, 1610, 1611, 1612, 1613, 1614, |
3216 | 795, 1046, 1579, 1046, 795, 1579, 1046, 795, | 3175 | 1615, 1616, 1617, 1618, 1575, 1619, 1050, 1059, |
3217 | 1046, 795, 1579, 1046, 1046, 1046, 1046, 1046, | 3176 | 801, 1510, 1620, 1621, 1059, 1047, 1510, 801, |
3218 | 1579, 795, 795, 1046, 795, 1046, 1579, 1046, | 3177 | 1047, 1510, 1050, 1622, 1107, 1623, 1624, 1625, |
3219 | 795, 1579, 1046, 1046, 1579, 795, 795, 1046, | 3178 | 1626, 1627, 1628, 1629, 1630, 1047, 1631, 1632, |
3220 | 795, 1046, 795, 1046, 1579, 1580, 1581, 1582, | 3179 | 1633, 1634, 1635, 1636, 1047, 1059, 1510, 1638, |
3221 | 1583, 1584, 1585, 1586, 1587, 1588, 1589, 1590, | 3180 | 1639, 1640, 1641, 1642, 1643, 1644, 1645, 1646, |
3222 | 1091, 1591, 1592, 1593, 1594, 1595, 1596, 1597, | 3181 | 1647, 1648, 1644, 1650, 1651, 1652, 1653, 1637, |
3223 | 1598, 1599, 1600, 1601, 1602, 1601, 1603, 1604, | 3182 | 1649, 1637, 1510, 1637, 1510, |
3224 | 1605, 1606, 1607, 1047, 1579, 1608, 1609, 1610, | ||
3225 | 1611, 1612, 1613, 1614, 1615, 1616, 1617, 1618, | ||
3226 | 1619, 1620, 1621, 1622, 1623, 1624, 1625, 1626, | ||
3227 | 1101, 1627, 1628, 1629, 1068, 1630, 1631, 1632, | ||
3228 | 1633, 1634, 1635, 1047, 1636, 1637, 1638, 1639, | ||
3229 | 1640, 1641, 1642, 1643, 1050, 1644, 1047, 1050, | ||
3230 | 1645, 1646, 1647, 1648, 1059, 1579, 1649, 1650, | ||
3231 | 1651, 1652, 1079, 1653, 1654, 1059, 1655, 1656, | ||
3232 | 1657, 1658, 1659, 1047, 1579, 1660, 1619, 1661, | ||
3233 | 1662, 1663, 1059, 1664, 1665, 1050, 1047, 1059, | ||
3234 | 801, 1579, 1629, 1047, 1050, 1059, 801, 1059, | ||
3235 | 801, 1666, 1059, 1579, 801, 1050, 1667, 1668, | ||
3236 | 1050, 1669, 1670, 1057, 1671, 1672, 1673, 1674, | ||
3237 | 1675, 1625, 1676, 1677, 1678, 1679, 1680, 1681, | ||
3238 | 1682, 1683, 1684, 1685, 1686, 1687, 1644, 1688, | ||
3239 | 1050, 1059, 801, 1579, 1689, 1690, 1059, 1047, | ||
3240 | 1579, 801, 1047, 1579, 1050, 1691, 1107, 1692, | ||
3241 | 1693, 1694, 1695, 1696, 1697, 1698, 1699, 1047, | ||
3242 | 1700, 1701, 1702, 1703, 1704, 1705, 1047, 1059, | ||
3243 | 1579, 1707, 1708, 1709, 1710, 1711, 1712, 1713, | ||
3244 | 1714, 1715, 1716, 1717, 1713, 1719, 1720, 1721, | ||
3245 | 1722, 1706, 1718, 1706, 1579, 1706, 1579, | ||
3246 | } | 3183 | } |
3247 | 3184 | ||
3248 | var _hcltok_trans_targs []int16 = []int16{ | 3185 | var _hcltok_trans_targs []int16 = []int16{ |
3249 | 1464, 1, 1464, 1464, 1464, 3, 4, 1472, | 3186 | 1459, 1459, 2, 3, 1459, 1459, 4, 1467, |
3250 | 1464, 5, 1473, 6, 7, 9, 10, 287, | 3187 | 5, 6, 8, 9, 286, 12, 13, 14, |
3251 | 13, 14, 15, 16, 17, 288, 289, 20, | 3188 | 15, 16, 287, 288, 19, 289, 21, 22, |
3252 | 290, 22, 23, 291, 292, 293, 294, 295, | 3189 | 290, 291, 292, 293, 294, 295, 296, 297, |
3253 | 296, 297, 298, 299, 300, 329, 349, 354, | 3190 | 298, 299, 328, 348, 353, 127, 128, 129, |
3254 | 128, 129, 130, 357, 152, 372, 376, 1464, | 3191 | 356, 151, 371, 375, 1459, 10, 11, 17, |
3255 | 11, 12, 18, 19, 21, 24, 25, 26, | 3192 | 18, 20, 23, 24, 25, 26, 27, 28, |
3256 | 27, 28, 29, 30, 31, 32, 33, 65, | 3193 | 29, 30, 31, 32, 64, 105, 120, 131, |
3257 | 106, 121, 132, 155, 171, 284, 34, 35, | 3194 | 154, 170, 283, 33, 34, 35, 36, 37, |
3258 | 36, 37, 38, 39, 40, 41, 42, 43, | 3195 | 38, 39, 40, 41, 42, 43, 44, 45, |
3259 | 44, 45, 46, 47, 48, 49, 50, 51, | 3196 | 46, 47, 48, 49, 50, 51, 52, 53, |
3260 | 52, 53, 54, 55, 56, 57, 58, 59, | 3197 | 54, 55, 56, 57, 58, 59, 60, 61, |
3261 | 60, 61, 62, 63, 64, 66, 67, 68, | 3198 | 62, 63, 65, 66, 67, 68, 69, 70, |
3262 | 69, 70, 71, 72, 73, 74, 75, 76, | 3199 | 71, 72, 73, 74, 75, 76, 77, 78, |
3263 | 77, 78, 79, 80, 81, 82, 83, 84, | 3200 | 79, 80, 81, 82, 83, 84, 85, 86, |
3264 | 85, 86, 87, 88, 89, 90, 91, 92, | 3201 | 87, 88, 89, 90, 91, 92, 93, 94, |
3265 | 93, 94, 95, 96, 97, 98, 99, 100, | 3202 | 95, 96, 97, 98, 99, 100, 101, 102, |
3266 | 101, 102, 103, 104, 105, 107, 108, 109, | 3203 | 103, 104, 106, 107, 108, 109, 110, 111, |
3267 | 110, 111, 112, 113, 114, 115, 116, 117, | 3204 | 112, 113, 114, 115, 116, 117, 118, 119, |
3268 | 118, 119, 120, 122, 123, 124, 125, 126, | 3205 | 121, 122, 123, 124, 125, 126, 130, 132, |
3269 | 127, 131, 133, 134, 135, 136, 137, 138, | 3206 | 133, 134, 135, 136, 137, 138, 139, 140, |
3270 | 139, 140, 141, 142, 143, 144, 145, 146, | 3207 | 141, 142, 143, 144, 145, 146, 147, 148, |
3271 | 147, 148, 149, 150, 151, 153, 154, 156, | 3208 | 149, 150, 152, 153, 155, 156, 157, 158, |
3272 | 157, 158, 159, 160, 161, 162, 163, 164, | 3209 | 159, 160, 161, 162, 163, 164, 165, 166, |
3273 | 165, 166, 167, 168, 169, 170, 172, 204, | 3210 | 167, 168, 169, 171, 203, 227, 230, 231, |
3274 | 228, 231, 232, 234, 243, 244, 247, 251, | 3211 | 233, 242, 243, 246, 250, 268, 275, 277, |
3275 | 269, 276, 278, 280, 282, 173, 174, 175, | 3212 | 279, 281, 172, 173, 174, 175, 176, 177, |
3276 | 176, 177, 178, 179, 180, 181, 182, 183, | 3213 | 178, 179, 180, 181, 182, 183, 184, 185, |
3277 | 184, 185, 186, 187, 188, 189, 190, 191, | 3214 | 186, 187, 188, 189, 190, 191, 192, 193, |
3278 | 192, 193, 194, 195, 196, 197, 198, 199, | 3215 | 194, 195, 196, 197, 198, 199, 200, 201, |
3279 | 200, 201, 202, 203, 205, 206, 207, 208, | 3216 | 202, 204, 205, 206, 207, 208, 209, 210, |
3280 | 209, 210, 211, 212, 213, 214, 215, 216, | 3217 | 211, 212, 213, 214, 215, 216, 217, 218, |
3281 | 217, 218, 219, 220, 221, 222, 223, 224, | 3218 | 219, 220, 221, 222, 223, 224, 225, 226, |
3282 | 225, 226, 227, 229, 230, 233, 235, 236, | 3219 | 228, 229, 232, 234, 235, 236, 237, 238, |
3283 | 237, 238, 239, 240, 241, 242, 245, 246, | 3220 | 239, 240, 241, 244, 245, 247, 248, 249, |
3284 | 248, 249, 250, 252, 253, 254, 255, 256, | 3221 | 251, 252, 253, 254, 255, 256, 257, 258, |
3285 | 257, 258, 259, 260, 261, 262, 263, 264, | 3222 | 259, 260, 261, 262, 263, 264, 265, 266, |
3286 | 265, 266, 267, 268, 270, 271, 272, 273, | 3223 | 267, 269, 270, 271, 272, 273, 274, 276, |
3287 | 274, 275, 277, 279, 281, 283, 285, 286, | 3224 | 278, 280, 282, 284, 285, 300, 301, 302, |
3288 | 301, 302, 303, 304, 305, 306, 307, 308, | 3225 | 303, 304, 305, 306, 307, 308, 309, 310, |
3289 | 309, 310, 311, 312, 313, 314, 315, 316, | 3226 | 311, 312, 313, 314, 315, 316, 317, 318, |
3290 | 317, 318, 319, 320, 321, 322, 323, 324, | 3227 | 319, 320, 321, 322, 323, 324, 325, 326, |
3291 | 325, 326, 327, 328, 330, 331, 332, 333, | 3228 | 327, 329, 330, 331, 332, 333, 334, 335, |
3292 | 334, 335, 336, 337, 338, 339, 340, 341, | 3229 | 336, 337, 338, 339, 340, 341, 342, 343, |
3293 | 342, 343, 344, 345, 346, 347, 348, 350, | 3230 | 344, 345, 346, 347, 349, 350, 351, 352, |
3294 | 351, 352, 353, 355, 356, 358, 359, 360, | 3231 | 354, 355, 357, 358, 359, 360, 361, 362, |
3295 | 361, 362, 363, 364, 365, 366, 367, 368, | 3232 | 363, 364, 365, 366, 367, 368, 369, 370, |
3296 | 369, 370, 371, 373, 374, 375, 377, 383, | 3233 | 372, 373, 374, 376, 382, 404, 409, 411, |
3297 | 405, 410, 412, 414, 378, 379, 380, 381, | 3234 | 413, 377, 378, 379, 380, 381, 383, 384, |
3298 | 382, 384, 385, 386, 387, 388, 389, 390, | 3235 | 385, 386, 387, 388, 389, 390, 391, 392, |
3299 | 391, 392, 393, 394, 395, 396, 397, 398, | 3236 | 393, 394, 395, 396, 397, 398, 399, 400, |
3300 | 399, 400, 401, 402, 403, 404, 406, 407, | 3237 | 401, 402, 403, 405, 406, 407, 408, 410, |
3301 | 408, 409, 411, 413, 415, 1464, 1477, 438, | 3238 | 412, 414, 1459, 1471, 1459, 437, 438, 439, |
3302 | 439, 440, 441, 418, 442, 443, 444, 445, | 3239 | 440, 417, 441, 442, 443, 444, 445, 446, |
3303 | 446, 447, 448, 449, 450, 451, 452, 453, | 3240 | 447, 448, 449, 450, 451, 452, 453, 454, |
3304 | 454, 455, 456, 457, 458, 459, 460, 461, | 3241 | 455, 456, 457, 458, 459, 460, 461, 462, |
3305 | 462, 463, 464, 465, 466, 467, 468, 470, | 3242 | 463, 464, 465, 466, 467, 469, 470, 471, |
3306 | 471, 472, 473, 474, 475, 476, 477, 478, | 3243 | 472, 473, 474, 475, 476, 477, 478, 479, |
3307 | 479, 480, 481, 482, 483, 484, 485, 486, | 3244 | 480, 481, 482, 483, 484, 485, 419, 486, |
3308 | 420, 487, 488, 489, 490, 491, 492, 493, | 3245 | 487, 488, 489, 490, 491, 492, 493, 494, |
3309 | 494, 495, 496, 497, 498, 499, 500, 501, | 3246 | 495, 496, 497, 498, 499, 500, 501, 502, |
3310 | 502, 503, 504, 419, 505, 506, 507, 508, | 3247 | 503, 418, 504, 505, 506, 507, 508, 510, |
3311 | 509, 511, 512, 513, 514, 515, 516, 517, | 3248 | 511, 512, 513, 514, 515, 516, 517, 518, |
3312 | 518, 519, 520, 521, 522, 523, 524, 526, | 3249 | 519, 520, 521, 522, 523, 525, 526, 527, |
3313 | 527, 528, 529, 530, 531, 535, 537, 538, | 3250 | 528, 529, 530, 534, 536, 537, 538, 539, |
3314 | 539, 540, 435, 541, 542, 543, 544, 545, | 3251 | 434, 540, 541, 542, 543, 544, 545, 546, |
3315 | 546, 547, 548, 549, 550, 551, 552, 553, | 3252 | 547, 548, 549, 550, 551, 552, 553, 554, |
3316 | 554, 555, 557, 558, 560, 561, 562, 563, | 3253 | 556, 557, 559, 560, 561, 562, 563, 564, |
3317 | 564, 565, 433, 566, 567, 568, 569, 570, | 3254 | 432, 565, 566, 567, 568, 569, 570, 571, |
3318 | 571, 572, 573, 574, 576, 608, 632, 635, | 3255 | 572, 573, 575, 607, 631, 634, 635, 637, |
3319 | 636, 638, 647, 648, 651, 655, 673, 533, | 3256 | 646, 647, 650, 654, 672, 532, 679, 681, |
3320 | 680, 682, 684, 686, 577, 578, 579, 580, | 3257 | 683, 685, 576, 577, 578, 579, 580, 581, |
3321 | 581, 582, 583, 584, 585, 586, 587, 588, | 3258 | 582, 583, 584, 585, 586, 587, 588, 589, |
3322 | 589, 590, 591, 592, 593, 594, 595, 596, | 3259 | 590, 591, 592, 593, 594, 595, 596, 597, |
3323 | 597, 598, 599, 600, 601, 602, 603, 604, | 3260 | 598, 599, 600, 601, 602, 603, 604, 605, |
3324 | 605, 606, 607, 609, 610, 611, 612, 613, | 3261 | 606, 608, 609, 610, 611, 612, 613, 614, |
3325 | 614, 615, 616, 617, 618, 619, 620, 621, | 3262 | 615, 616, 617, 618, 619, 620, 621, 622, |
3326 | 622, 623, 624, 625, 626, 627, 628, 629, | 3263 | 623, 624, 625, 626, 627, 628, 629, 630, |
3327 | 630, 631, 633, 634, 637, 639, 640, 641, | 3264 | 632, 633, 636, 638, 639, 640, 641, 642, |
3328 | 642, 643, 644, 645, 646, 649, 650, 652, | 3265 | 643, 644, 645, 648, 649, 651, 652, 653, |
3329 | 653, 654, 656, 657, 658, 659, 660, 661, | 3266 | 655, 656, 657, 658, 659, 660, 661, 662, |
3330 | 662, 663, 664, 665, 666, 667, 668, 669, | 3267 | 663, 664, 665, 666, 667, 668, 669, 670, |
3331 | 670, 671, 672, 674, 675, 676, 677, 678, | 3268 | 671, 673, 674, 675, 676, 677, 678, 680, |
3332 | 679, 681, 683, 685, 687, 689, 690, 1464, | 3269 | 682, 684, 686, 688, 689, 1459, 1459, 690, |
3333 | 1464, 691, 828, 829, 760, 830, 831, 832, | 3270 | 827, 828, 759, 829, 830, 831, 832, 833, |
3334 | 833, 834, 835, 789, 836, 725, 837, 838, | 3271 | 834, 788, 835, 724, 836, 837, 838, 839, |
3335 | 839, 840, 841, 842, 843, 844, 745, 845, | 3272 | 840, 841, 842, 843, 744, 844, 845, 846, |
3336 | 846, 847, 848, 849, 850, 851, 852, 853, | 3273 | 847, 848, 849, 850, 851, 852, 853, 769, |
3337 | 854, 770, 855, 857, 858, 859, 860, 861, | 3274 | 854, 856, 857, 858, 859, 860, 861, 862, |
3338 | 862, 863, 864, 865, 866, 703, 867, 868, | 3275 | 863, 864, 865, 702, 866, 867, 868, 869, |
3339 | 869, 870, 871, 872, 873, 874, 875, 741, | 3276 | 870, 871, 872, 873, 874, 740, 875, 876, |
3340 | 876, 877, 878, 879, 880, 811, 882, 883, | 3277 | 877, 878, 879, 810, 881, 882, 885, 887, |
3341 | 886, 888, 889, 890, 891, 892, 893, 896, | 3278 | 888, 889, 890, 891, 892, 895, 896, 898, |
3342 | 897, 899, 900, 901, 903, 904, 905, 906, | 3279 | 899, 900, 902, 903, 904, 905, 906, 907, |
3343 | 907, 908, 909, 910, 911, 912, 913, 915, | 3280 | 908, 909, 910, 911, 912, 914, 915, 916, |
3344 | 916, 917, 918, 921, 923, 924, 926, 928, | 3281 | 917, 920, 922, 923, 925, 927, 1509, 1510, |
3345 | 1515, 1517, 1518, 1516, 931, 932, 1515, 934, | 3282 | 929, 930, 931, 1509, 1509, 932, 1523, 1523, |
3346 | 1541, 1541, 1541, 1543, 1544, 1542, 939, 940, | 3283 | 1524, 935, 1523, 936, 1525, 1526, 1529, 1530, |
3347 | 1545, 1546, 1550, 1550, 1550, 1551, 946, 947, | 3284 | 1534, 1534, 1535, 941, 1534, 942, 1536, 1537, |
3348 | 1552, 1553, 1557, 1558, 1557, 973, 974, 975, | 3285 | 1540, 1541, 1545, 1546, 1545, 968, 969, 970, |
3349 | 976, 953, 977, 978, 979, 980, 981, 982, | 3286 | 971, 948, 972, 973, 974, 975, 976, 977, |
3350 | 983, 984, 985, 986, 987, 988, 989, 990, | 3287 | 978, 979, 980, 981, 982, 983, 984, 985, |
3351 | 991, 992, 993, 994, 995, 996, 997, 998, | 3288 | 986, 987, 988, 989, 990, 991, 992, 993, |
3352 | 999, 1000, 1001, 1002, 1003, 1005, 1006, 1007, | 3289 | 994, 995, 996, 997, 998, 1000, 1001, 1002, |
3353 | 1008, 1009, 1010, 1011, 1012, 1013, 1014, 1015, | 3290 | 1003, 1004, 1005, 1006, 1007, 1008, 1009, 1010, |
3354 | 1016, 1017, 1018, 1019, 1020, 1021, 955, 1022, | 3291 | 1011, 1012, 1013, 1014, 1015, 1016, 950, 1017, |
3355 | 1023, 1024, 1025, 1026, 1027, 1028, 1029, 1030, | 3292 | 1018, 1019, 1020, 1021, 1022, 1023, 1024, 1025, |
3356 | 1031, 1032, 1033, 1034, 1035, 1036, 1037, 1038, | 3293 | 1026, 1027, 1028, 1029, 1030, 1031, 1032, 1033, |
3357 | 1039, 954, 1040, 1041, 1042, 1043, 1044, 1046, | 3294 | 1034, 949, 1035, 1036, 1037, 1038, 1039, 1041, |
3358 | 1047, 1048, 1049, 1050, 1051, 1052, 1053, 1054, | 3295 | 1042, 1043, 1044, 1045, 1046, 1047, 1048, 1049, |
3359 | 1055, 1056, 1057, 1058, 1059, 1061, 1062, 1063, | 3296 | 1050, 1051, 1052, 1053, 1054, 1056, 1057, 1058, |
3360 | 1064, 1065, 1066, 1070, 1072, 1073, 1074, 1075, | 3297 | 1059, 1060, 1061, 1065, 1067, 1068, 1069, 1070, |
3361 | 970, 1076, 1077, 1078, 1079, 1080, 1081, 1082, | 3298 | 965, 1071, 1072, 1073, 1074, 1075, 1076, 1077, |
3362 | 1083, 1084, 1085, 1086, 1087, 1088, 1089, 1090, | 3299 | 1078, 1079, 1080, 1081, 1082, 1083, 1084, 1085, |
3363 | 1092, 1093, 1095, 1096, 1097, 1098, 1099, 1100, | 3300 | 1087, 1088, 1090, 1091, 1092, 1093, 1094, 1095, |
3364 | 968, 1101, 1102, 1103, 1104, 1105, 1106, 1107, | 3301 | 963, 1096, 1097, 1098, 1099, 1100, 1101, 1102, |
3365 | 1108, 1109, 1111, 1143, 1167, 1170, 1171, 1173, | 3302 | 1103, 1104, 1106, 1138, 1162, 1165, 1166, 1168, |
3366 | 1182, 1183, 1186, 1190, 1208, 1068, 1215, 1217, | 3303 | 1177, 1178, 1181, 1185, 1203, 1063, 1210, 1212, |
3367 | 1219, 1221, 1112, 1113, 1114, 1115, 1116, 1117, | 3304 | 1214, 1216, 1107, 1108, 1109, 1110, 1111, 1112, |
3368 | 1118, 1119, 1120, 1121, 1122, 1123, 1124, 1125, | 3305 | 1113, 1114, 1115, 1116, 1117, 1118, 1119, 1120, |
3369 | 1126, 1127, 1128, 1129, 1130, 1131, 1132, 1133, | 3306 | 1121, 1122, 1123, 1124, 1125, 1126, 1127, 1128, |
3370 | 1134, 1135, 1136, 1137, 1138, 1139, 1140, 1141, | 3307 | 1129, 1130, 1131, 1132, 1133, 1134, 1135, 1136, |
3371 | 1142, 1144, 1145, 1146, 1147, 1148, 1149, 1150, | 3308 | 1137, 1139, 1140, 1141, 1142, 1143, 1144, 1145, |
3372 | 1151, 1152, 1153, 1154, 1155, 1156, 1157, 1158, | 3309 | 1146, 1147, 1148, 1149, 1150, 1151, 1152, 1153, |
3373 | 1159, 1160, 1161, 1162, 1163, 1164, 1165, 1166, | 3310 | 1154, 1155, 1156, 1157, 1158, 1159, 1160, 1161, |
3374 | 1168, 1169, 1172, 1174, 1175, 1176, 1177, 1178, | 3311 | 1163, 1164, 1167, 1169, 1170, 1171, 1172, 1173, |
3375 | 1179, 1180, 1181, 1184, 1185, 1187, 1188, 1189, | 3312 | 1174, 1175, 1176, 1179, 1180, 1182, 1183, 1184, |
3376 | 1191, 1192, 1193, 1194, 1195, 1196, 1197, 1198, | 3313 | 1186, 1187, 1188, 1189, 1190, 1191, 1192, 1193, |
3377 | 1199, 1200, 1201, 1202, 1203, 1204, 1205, 1206, | 3314 | 1194, 1195, 1196, 1197, 1198, 1199, 1200, 1201, |
3378 | 1207, 1209, 1210, 1211, 1212, 1213, 1214, 1216, | 3315 | 1202, 1204, 1205, 1206, 1207, 1208, 1209, 1211, |
3379 | 1218, 1220, 1222, 1224, 1225, 1557, 1557, 1226, | 3316 | 1213, 1215, 1217, 1219, 1220, 1545, 1545, 1221, |
3380 | 1363, 1364, 1295, 1365, 1366, 1367, 1368, 1369, | 3317 | 1358, 1359, 1290, 1360, 1361, 1362, 1363, 1364, |
3381 | 1370, 1324, 1371, 1260, 1372, 1373, 1374, 1375, | 3318 | 1365, 1319, 1366, 1255, 1367, 1368, 1369, 1370, |
3382 | 1376, 1377, 1378, 1379, 1280, 1380, 1381, 1382, | 3319 | 1371, 1372, 1373, 1374, 1275, 1375, 1376, 1377, |
3383 | 1383, 1384, 1385, 1386, 1387, 1388, 1389, 1305, | 3320 | 1378, 1379, 1380, 1381, 1382, 1383, 1384, 1300, |
3384 | 1390, 1392, 1393, 1394, 1395, 1396, 1397, 1398, | 3321 | 1385, 1387, 1388, 1389, 1390, 1391, 1392, 1393, |
3385 | 1399, 1400, 1401, 1238, 1402, 1403, 1404, 1405, | 3322 | 1394, 1395, 1396, 1233, 1397, 1398, 1399, 1400, |
3386 | 1406, 1407, 1408, 1409, 1410, 1276, 1411, 1412, | 3323 | 1401, 1402, 1403, 1404, 1405, 1271, 1406, 1407, |
3387 | 1413, 1414, 1415, 1346, 1417, 1418, 1421, 1423, | 3324 | 1408, 1409, 1410, 1341, 1412, 1413, 1416, 1418, |
3388 | 1424, 1425, 1426, 1427, 1428, 1431, 1432, 1434, | 3325 | 1419, 1420, 1421, 1422, 1423, 1426, 1427, 1429, |
3389 | 1435, 1436, 1438, 1439, 1440, 1441, 1442, 1443, | 3326 | 1430, 1431, 1433, 1434, 1435, 1436, 1437, 1438, |
3390 | 1444, 1445, 1446, 1447, 1448, 1450, 1451, 1452, | 3327 | 1439, 1440, 1441, 1442, 1443, 1445, 1446, 1447, |
3391 | 1453, 1456, 1458, 1459, 1461, 1463, 1465, 1464, | 3328 | 1448, 1451, 1453, 1454, 1456, 1458, 1460, 1459, |
3392 | 1466, 1467, 1464, 1468, 1464, 1469, 1470, 1471, | 3329 | 1461, 1462, 1459, 1463, 1459, 1464, 1465, 1466, |
3393 | 1474, 1475, 1476, 1464, 1478, 1464, 1479, 1464, | 3330 | 1468, 1469, 1470, 1459, 1472, 1459, 1473, 1459, |
3394 | 1480, 1481, 1482, 1483, 1484, 1485, 1486, 1487, | 3331 | 1474, 1475, 1476, 1477, 1478, 1479, 1480, 1481, |
3395 | 1488, 1489, 1490, 1491, 1492, 1493, 1494, 1495, | 3332 | 1482, 1483, 1484, 1485, 1486, 1487, 1488, 1489, |
3396 | 1496, 1497, 1498, 1499, 1500, 1501, 1502, 1503, | 3333 | 1490, 1491, 1492, 1493, 1494, 1495, 1496, 1497, |
3397 | 1504, 1505, 1506, 1507, 1508, 1509, 1510, 1511, | 3334 | 1498, 1499, 1500, 1501, 1502, 1503, 1504, 1505, |
3398 | 1512, 1513, 1514, 1464, 1464, 1464, 1464, 1464, | 3335 | 1506, 1507, 1508, 1459, 1459, 1459, 1459, 1459, |
3399 | 2, 1464, 1464, 8, 1464, 1464, 1464, 1464, | 3336 | 1459, 1, 1459, 7, 1459, 1459, 1459, 1459, |
3400 | 1464, 416, 417, 421, 422, 423, 424, 425, | 3337 | 1459, 415, 416, 420, 421, 422, 423, 424, |
3401 | 426, 427, 428, 429, 430, 431, 432, 434, | 3338 | 425, 426, 427, 428, 429, 430, 431, 433, |
3402 | 436, 437, 469, 510, 525, 532, 534, 536, | 3339 | 435, 436, 468, 509, 524, 531, 533, 535, |
3403 | 556, 559, 575, 688, 1464, 1464, 1464, 692, | 3340 | 555, 558, 574, 687, 1459, 1459, 1459, 691, |
3404 | 693, 694, 695, 696, 697, 698, 699, 700, | 3341 | 692, 693, 694, 695, 696, 697, 698, 699, |
3405 | 701, 702, 704, 705, 706, 707, 708, 709, | 3342 | 700, 701, 703, 704, 705, 706, 707, 708, |
3406 | 710, 711, 712, 713, 714, 715, 716, 717, | 3343 | 709, 710, 711, 712, 713, 714, 715, 716, |
3407 | 718, 719, 720, 721, 722, 723, 724, 726, | 3344 | 717, 718, 719, 720, 721, 722, 723, 725, |
3408 | 727, 728, 729, 730, 731, 732, 733, 734, | 3345 | 726, 727, 728, 729, 730, 731, 732, 733, |
3409 | 735, 736, 737, 738, 739, 740, 742, 743, | 3346 | 734, 735, 736, 737, 738, 739, 741, 742, |
3410 | 744, 746, 747, 748, 749, 750, 751, 752, | 3347 | 743, 745, 746, 747, 748, 749, 750, 751, |
3411 | 753, 754, 755, 756, 757, 758, 759, 761, | 3348 | 752, 753, 754, 755, 756, 757, 758, 760, |
3412 | 762, 763, 764, 765, 766, 767, 768, 769, | 3349 | 761, 762, 763, 764, 765, 766, 767, 768, |
3413 | 771, 772, 773, 774, 775, 776, 777, 778, | 3350 | 770, 771, 772, 773, 774, 775, 776, 777, |
3414 | 779, 780, 781, 782, 783, 784, 785, 786, | 3351 | 778, 779, 780, 781, 782, 783, 784, 785, |
3415 | 787, 788, 790, 791, 792, 793, 794, 795, | 3352 | 786, 787, 789, 790, 791, 792, 793, 794, |
3416 | 796, 797, 798, 799, 800, 801, 802, 803, | 3353 | 795, 796, 797, 798, 799, 800, 801, 802, |
3417 | 804, 805, 806, 807, 808, 809, 810, 812, | 3354 | 803, 804, 805, 806, 807, 808, 809, 811, |
3418 | 813, 814, 815, 816, 817, 818, 819, 820, | 3355 | 812, 813, 814, 815, 816, 817, 818, 819, |
3419 | 821, 822, 823, 824, 825, 826, 827, 856, | 3356 | 820, 821, 822, 823, 824, 825, 826, 855, |
3420 | 881, 884, 885, 887, 894, 895, 898, 902, | 3357 | 880, 883, 884, 886, 893, 894, 897, 901, |
3421 | 914, 919, 920, 922, 925, 927, 1515, 1515, | 3358 | 913, 918, 919, 921, 924, 926, 1511, 1509, |
3422 | 1534, 1536, 1519, 1515, 1538, 1539, 1540, 1515, | 3359 | 1512, 1517, 1519, 1509, 1520, 1521, 1522, 1509, |
3423 | 929, 930, 933, 1515, 1516, 929, 930, 1519, | 3360 | 928, 1509, 1509, 1513, 1514, 1516, 1509, 1515, |
3424 | 931, 932, 933, 1515, 1516, 929, 930, 1519, | 3361 | 1509, 1509, 1509, 1518, 1509, 1509, 1509, 933, |
3425 | 931, 932, 933, 1520, 1525, 1521, 1522, 1524, | 3362 | 934, 938, 939, 1523, 1531, 1532, 1533, 1523, |
3426 | 1531, 1532, 1533, 1517, 1521, 1522, 1524, 1531, | 3363 | 937, 1523, 1523, 934, 1527, 1528, 1523, 1523, |
3427 | 1532, 1533, 1518, 1523, 1526, 1527, 1528, 1529, | 3364 | 1523, 1523, 1523, 940, 944, 945, 1534, 1542, |
3428 | 1530, 1517, 1521, 1522, 1524, 1531, 1532, 1533, | 3365 | 1543, 1544, 1534, 943, 1534, 1534, 940, 1538, |
3429 | 1520, 1525, 1523, 1526, 1527, 1528, 1529, 1530, | 3366 | 1539, 1534, 1534, 1534, 1534, 1534, 1545, 1547, |
3430 | 1518, 1523, 1526, 1527, 1528, 1529, 1530, 1520, | 3367 | 1548, 1549, 1550, 1551, 1552, 1553, 1554, 1555, |
3431 | 1525, 1515, 1535, 1515, 1515, 1537, 1515, 1515, | 3368 | 1556, 1557, 1558, 1559, 1560, 1561, 1562, 1563, |
3432 | 1515, 935, 936, 942, 943, 1541, 1547, 1548, | 3369 | 1564, 1565, 1566, 1567, 1568, 1569, 1570, 1571, |
3433 | 1549, 1541, 937, 938, 941, 1541, 1542, 1541, | 3370 | 1572, 1573, 1574, 1575, 1576, 1577, 1578, 1579, |
3434 | 936, 937, 938, 939, 940, 941, 1541, 1542, | 3371 | 1580, 1581, 1545, 946, 947, 951, 952, 953, |
3435 | 1541, 936, 937, 938, 939, 940, 941, 1541, | 3372 | 954, 955, 956, 957, 958, 959, 960, 961, |
3436 | 1541, 1541, 1541, 1541, 944, 949, 950, 1550, | 3373 | 962, 964, 966, 967, 999, 1040, 1055, 1062, |
3437 | 1554, 1555, 1556, 1550, 945, 948, 1550, 1550, | 3374 | 1064, 1066, 1086, 1089, 1105, 1218, 1545, 1222, |
3438 | 1550, 1550, 1550, 1557, 1559, 1560, 1561, 1562, | 3375 | 1223, 1224, 1225, 1226, 1227, 1228, 1229, 1230, |
3439 | 1563, 1564, 1565, 1566, 1567, 1568, 1569, 1570, | 3376 | 1231, 1232, 1234, 1235, 1236, 1237, 1238, 1239, |
3440 | 1571, 1572, 1573, 1574, 1575, 1576, 1577, 1578, | ||
3441 | 1579, 1580, 1581, 1582, 1583, 1584, 1585, 1586, | ||
3442 | 1587, 1588, 1589, 1590, 1591, 1592, 1593, 1557, | ||
3443 | 951, 952, 956, 957, 958, 959, 960, 961, | ||
3444 | 962, 963, 964, 965, 966, 967, 969, 971, | ||
3445 | 972, 1004, 1045, 1060, 1067, 1069, 1071, 1091, | ||
3446 | 1094, 1110, 1223, 1557, 1227, 1228, 1229, 1230, | ||
3447 | 1231, 1232, 1233, 1234, 1235, 1236, 1237, 1239, | ||
3448 | 1240, 1241, 1242, 1243, 1244, 1245, 1246, 1247, | 3377 | 1240, 1241, 1242, 1243, 1244, 1245, 1246, 1247, |
3449 | 1248, 1249, 1250, 1251, 1252, 1253, 1254, 1255, | 3378 | 1248, 1249, 1250, 1251, 1252, 1253, 1254, 1256, |
3450 | 1256, 1257, 1258, 1259, 1261, 1262, 1263, 1264, | 3379 | 1257, 1258, 1259, 1260, 1261, 1262, 1263, 1264, |
3451 | 1265, 1266, 1267, 1268, 1269, 1270, 1271, 1272, | 3380 | 1265, 1266, 1267, 1268, 1269, 1270, 1272, 1273, |
3452 | 1273, 1274, 1275, 1277, 1278, 1279, 1281, 1282, | 3381 | 1274, 1276, 1277, 1278, 1279, 1280, 1281, 1282, |
3453 | 1283, 1284, 1285, 1286, 1287, 1288, 1289, 1290, | 3382 | 1283, 1284, 1285, 1286, 1287, 1288, 1289, 1291, |
3454 | 1291, 1292, 1293, 1294, 1296, 1297, 1298, 1299, | 3383 | 1292, 1293, 1294, 1295, 1296, 1297, 1298, 1299, |
3455 | 1300, 1301, 1302, 1303, 1304, 1306, 1307, 1308, | 3384 | 1301, 1302, 1303, 1304, 1305, 1306, 1307, 1308, |
3456 | 1309, 1310, 1311, 1312, 1313, 1314, 1315, 1316, | 3385 | 1309, 1310, 1311, 1312, 1313, 1314, 1315, 1316, |
3457 | 1317, 1318, 1319, 1320, 1321, 1322, 1323, 1325, | 3386 | 1317, 1318, 1320, 1321, 1322, 1323, 1324, 1325, |
3458 | 1326, 1327, 1328, 1329, 1330, 1331, 1332, 1333, | 3387 | 1326, 1327, 1328, 1329, 1330, 1331, 1332, 1333, |
3459 | 1334, 1335, 1336, 1337, 1338, 1339, 1340, 1341, | 3388 | 1334, 1335, 1336, 1337, 1338, 1339, 1340, 1342, |
3460 | 1342, 1343, 1344, 1345, 1347, 1348, 1349, 1350, | 3389 | 1343, 1344, 1345, 1346, 1347, 1348, 1349, 1350, |
3461 | 1351, 1352, 1353, 1354, 1355, 1356, 1357, 1358, | 3390 | 1351, 1352, 1353, 1354, 1355, 1356, 1357, 1386, |
3462 | 1359, 1360, 1361, 1362, 1391, 1416, 1419, 1420, | 3391 | 1411, 1414, 1415, 1417, 1424, 1425, 1428, 1432, |
3463 | 1422, 1429, 1430, 1433, 1437, 1449, 1454, 1455, | 3392 | 1444, 1449, 1450, 1452, 1455, 1457, |
3464 | 1457, 1460, 1462, | ||
3465 | } | 3393 | } |
3466 | 3394 | ||
3467 | var _hcltok_trans_actions []byte = []byte{ | 3395 | var _hcltok_trans_actions []byte = []byte{ |
3468 | 151, 0, 93, 147, 109, 0, 0, 201, | 3396 | 145, 107, 0, 0, 91, 141, 0, 7, |
3469 | 143, 0, 13, 0, 0, 0, 0, 0, | ||
3470 | 0, 0, 0, 0, 0, 0, 0, 0, | 3397 | 0, 0, 0, 0, 0, 0, 0, 0, |
3471 | 0, 0, 0, 0, 0, 0, 0, 0, | 3398 | 0, 0, 0, 0, 0, 0, 0, 0, |
3472 | 0, 0, 0, 0, 0, 0, 0, 0, | 3399 | 0, 0, 0, 0, 0, 0, 0, 0, |
3473 | 0, 0, 0, 0, 0, 0, 0, 123, | ||
3474 | 0, 0, 0, 0, 0, 0, 0, 0, | 3400 | 0, 0, 0, 0, 0, 0, 0, 0, |
3401 | 0, 0, 0, 0, 121, 0, 0, 0, | ||
3475 | 0, 0, 0, 0, 0, 0, 0, 0, | 3402 | 0, 0, 0, 0, 0, 0, 0, 0, |
3476 | 0, 0, 0, 0, 0, 0, 0, 0, | 3403 | 0, 0, 0, 0, 0, 0, 0, 0, |
3477 | 0, 0, 0, 0, 0, 0, 0, 0, | 3404 | 0, 0, 0, 0, 0, 0, 0, 0, |
@@ -3517,8 +3444,8 @@ var _hcltok_trans_actions []byte = []byte{ | |||
3517 | 0, 0, 0, 0, 0, 0, 0, 0, | 3444 | 0, 0, 0, 0, 0, 0, 0, 0, |
3518 | 0, 0, 0, 0, 0, 0, 0, 0, | 3445 | 0, 0, 0, 0, 0, 0, 0, 0, |
3519 | 0, 0, 0, 0, 0, 0, 0, 0, | 3446 | 0, 0, 0, 0, 0, 0, 0, 0, |
3520 | 0, 0, 0, 0, 0, 145, 198, 0, | ||
3521 | 0, 0, 0, 0, 0, 0, 0, 0, | 3447 | 0, 0, 0, 0, 0, 0, 0, 0, |
3448 | 0, 0, 143, 193, 149, 0, 0, 0, | ||
3522 | 0, 0, 0, 0, 0, 0, 0, 0, | 3449 | 0, 0, 0, 0, 0, 0, 0, 0, |
3523 | 0, 0, 0, 0, 0, 0, 0, 0, | 3450 | 0, 0, 0, 0, 0, 0, 0, 0, |
3524 | 0, 0, 0, 0, 0, 0, 0, 0, | 3451 | 0, 0, 0, 0, 0, 0, 0, 0, |
@@ -3548,9 +3475,8 @@ var _hcltok_trans_actions []byte = []byte{ | |||
3548 | 0, 0, 0, 0, 0, 0, 0, 0, | 3475 | 0, 0, 0, 0, 0, 0, 0, 0, |
3549 | 0, 0, 0, 0, 0, 0, 0, 0, | 3476 | 0, 0, 0, 0, 0, 0, 0, 0, |
3550 | 0, 0, 0, 0, 0, 0, 0, 0, | 3477 | 0, 0, 0, 0, 0, 0, 0, 0, |
3551 | 0, 0, 0, 0, 0, 0, 0, 149, | ||
3552 | 127, 0, 0, 0, 0, 0, 0, 0, | ||
3553 | 0, 0, 0, 0, 0, 0, 0, 0, | 3478 | 0, 0, 0, 0, 0, 0, 0, 0, |
3479 | 0, 0, 0, 0, 0, 147, 125, 0, | ||
3554 | 0, 0, 0, 0, 0, 0, 0, 0, | 3480 | 0, 0, 0, 0, 0, 0, 0, 0, |
3555 | 0, 0, 0, 0, 0, 0, 0, 0, | 3481 | 0, 0, 0, 0, 0, 0, 0, 0, |
3556 | 0, 0, 0, 0, 0, 0, 0, 0, | 3482 | 0, 0, 0, 0, 0, 0, 0, 0, |
@@ -3561,11 +3487,12 @@ var _hcltok_trans_actions []byte = []byte{ | |||
3561 | 0, 0, 0, 0, 0, 0, 0, 0, | 3487 | 0, 0, 0, 0, 0, 0, 0, 0, |
3562 | 0, 0, 0, 0, 0, 0, 0, 0, | 3488 | 0, 0, 0, 0, 0, 0, 0, 0, |
3563 | 0, 0, 0, 0, 0, 0, 0, 0, | 3489 | 0, 0, 0, 0, 0, 0, 0, 0, |
3564 | 35, 13, 13, 13, 0, 0, 37, 0, | ||
3565 | 57, 43, 55, 180, 180, 180, 0, 0, | ||
3566 | 0, 0, 77, 63, 75, 186, 0, 0, | ||
3567 | 0, 0, 87, 192, 91, 0, 0, 0, | ||
3568 | 0, 0, 0, 0, 0, 0, 0, 0, | 3490 | 0, 0, 0, 0, 0, 0, 0, 0, |
3491 | 0, 0, 0, 0, 0, 0, 31, 169, | ||
3492 | 0, 0, 0, 35, 33, 0, 55, 41, | ||
3493 | 175, 0, 53, 0, 175, 175, 0, 0, | ||
3494 | 75, 61, 181, 0, 73, 0, 181, 181, | ||
3495 | 0, 0, 85, 187, 89, 0, 0, 0, | ||
3569 | 0, 0, 0, 0, 0, 0, 0, 0, | 3496 | 0, 0, 0, 0, 0, 0, 0, 0, |
3570 | 0, 0, 0, 0, 0, 0, 0, 0, | 3497 | 0, 0, 0, 0, 0, 0, 0, 0, |
3571 | 0, 0, 0, 0, 0, 0, 0, 0, | 3498 | 0, 0, 0, 0, 0, 0, 0, 0, |
@@ -3595,8 +3522,8 @@ var _hcltok_trans_actions []byte = []byte{ | |||
3595 | 0, 0, 0, 0, 0, 0, 0, 0, | 3522 | 0, 0, 0, 0, 0, 0, 0, 0, |
3596 | 0, 0, 0, 0, 0, 0, 0, 0, | 3523 | 0, 0, 0, 0, 0, 0, 0, 0, |
3597 | 0, 0, 0, 0, 0, 0, 0, 0, | 3524 | 0, 0, 0, 0, 0, 0, 0, 0, |
3598 | 0, 0, 0, 0, 0, 89, 81, 0, | ||
3599 | 0, 0, 0, 0, 0, 0, 0, 0, | 3525 | 0, 0, 0, 0, 0, 0, 0, 0, |
3526 | 0, 0, 0, 0, 0, 87, 79, 0, | ||
3600 | 0, 0, 0, 0, 0, 0, 0, 0, | 3527 | 0, 0, 0, 0, 0, 0, 0, 0, |
3601 | 0, 0, 0, 0, 0, 0, 0, 0, | 3528 | 0, 0, 0, 0, 0, 0, 0, 0, |
3602 | 0, 0, 0, 0, 0, 0, 0, 0, | 3529 | 0, 0, 0, 0, 0, 0, 0, 0, |
@@ -3607,20 +3534,20 @@ var _hcltok_trans_actions []byte = []byte{ | |||
3607 | 0, 0, 0, 0, 0, 0, 0, 0, | 3534 | 0, 0, 0, 0, 0, 0, 0, 0, |
3608 | 0, 0, 0, 0, 0, 0, 0, 0, | 3535 | 0, 0, 0, 0, 0, 0, 0, 0, |
3609 | 0, 0, 0, 0, 0, 0, 0, 0, | 3536 | 0, 0, 0, 0, 0, 0, 0, 0, |
3610 | 0, 0, 0, 0, 0, 0, 0, 95, | ||
3611 | 0, 0, 121, 210, 113, 0, 13, 204, | ||
3612 | 13, 0, 0, 115, 0, 117, 0, 125, | ||
3613 | 0, 0, 0, 0, 0, 0, 0, 0, | 3537 | 0, 0, 0, 0, 0, 0, 0, 0, |
3538 | 0, 0, 0, 0, 0, 0, 0, 93, | ||
3539 | 0, 0, 119, 0, 111, 0, 7, 7, | ||
3540 | 7, 0, 0, 113, 0, 115, 0, 123, | ||
3614 | 0, 0, 0, 0, 0, 0, 0, 0, | 3541 | 0, 0, 0, 0, 0, 0, 0, 0, |
3615 | 0, 0, 0, 0, 0, 0, 13, 13, | ||
3616 | 13, 207, 207, 207, 207, 207, 207, 13, | ||
3617 | 13, 207, 13, 129, 141, 137, 99, 105, | ||
3618 | 0, 135, 131, 0, 103, 97, 111, 101, | ||
3619 | 133, 0, 0, 0, 0, 0, 0, 0, | ||
3620 | 0, 0, 0, 0, 0, 0, 0, 0, | 3542 | 0, 0, 0, 0, 0, 0, 0, 0, |
3543 | 0, 0, 0, 0, 0, 0, 7, 7, | ||
3544 | 7, 196, 196, 196, 196, 196, 196, 7, | ||
3545 | 7, 196, 7, 127, 139, 135, 97, 133, | ||
3546 | 103, 0, 129, 0, 101, 95, 109, 99, | ||
3547 | 131, 0, 0, 0, 0, 0, 0, 0, | ||
3621 | 0, 0, 0, 0, 0, 0, 0, 0, | 3548 | 0, 0, 0, 0, 0, 0, 0, 0, |
3622 | 0, 0, 0, 0, 107, 119, 139, 0, | ||
3623 | 0, 0, 0, 0, 0, 0, 0, 0, | 3549 | 0, 0, 0, 0, 0, 0, 0, 0, |
3550 | 0, 0, 0, 0, 105, 117, 137, 0, | ||
3624 | 0, 0, 0, 0, 0, 0, 0, 0, | 3551 | 0, 0, 0, 0, 0, 0, 0, 0, |
3625 | 0, 0, 0, 0, 0, 0, 0, 0, | 3552 | 0, 0, 0, 0, 0, 0, 0, 0, |
3626 | 0, 0, 0, 0, 0, 0, 0, 0, | 3553 | 0, 0, 0, 0, 0, 0, 0, 0, |
@@ -3637,32 +3564,24 @@ var _hcltok_trans_actions []byte = []byte{ | |||
3637 | 0, 0, 0, 0, 0, 0, 0, 0, | 3564 | 0, 0, 0, 0, 0, 0, 0, 0, |
3638 | 0, 0, 0, 0, 0, 0, 0, 0, | 3565 | 0, 0, 0, 0, 0, 0, 0, 0, |
3639 | 0, 0, 0, 0, 0, 0, 0, 0, | 3566 | 0, 0, 0, 0, 0, 0, 0, 0, |
3640 | 0, 0, 0, 0, 0, 0, 21, 19, | ||
3641 | 0, 0, 13, 23, 0, 13, 13, 29, | ||
3642 | 0, 0, 0, 153, 174, 1, 1, 174, | ||
3643 | 1, 1, 1, 156, 177, 3, 3, 177, | ||
3644 | 3, 3, 3, 0, 0, 0, 0, 13, | ||
3645 | 13, 13, 13, 174, 1, 1, 174, 174, | ||
3646 | 174, 174, 174, 1, 1, 174, 174, 174, | ||
3647 | 174, 177, 3, 3, 177, 177, 177, 177, | ||
3648 | 1, 1, 0, 0, 13, 13, 13, 13, | ||
3649 | 177, 3, 3, 177, 177, 177, 177, 3, | ||
3650 | 3, 31, 0, 25, 15, 0, 27, 17, | ||
3651 | 33, 0, 0, 0, 0, 45, 0, 183, | ||
3652 | 183, 51, 0, 0, 0, 162, 213, 159, | ||
3653 | 5, 5, 5, 5, 5, 5, 168, 217, | ||
3654 | 165, 7, 7, 7, 7, 7, 7, 47, | ||
3655 | 39, 49, 41, 53, 0, 0, 0, 65, | ||
3656 | 0, 189, 189, 71, 0, 0, 67, 59, | ||
3657 | 69, 61, 73, 79, 0, 0, 0, 0, | ||
3658 | 0, 0, 0, 0, 0, 0, 0, 0, | 3567 | 0, 0, 0, 0, 0, 0, 0, 0, |
3568 | 0, 0, 0, 0, 0, 0, 0, 13, | ||
3569 | 0, 0, 172, 17, 0, 7, 7, 23, | ||
3570 | 0, 25, 27, 0, 0, 0, 151, 0, | ||
3571 | 15, 19, 9, 0, 21, 11, 29, 0, | ||
3572 | 0, 0, 0, 43, 0, 178, 178, 49, | ||
3573 | 0, 157, 154, 1, 175, 175, 45, 37, | ||
3574 | 47, 39, 51, 0, 0, 0, 63, 0, | ||
3575 | 184, 184, 69, 0, 163, 160, 1, 181, | ||
3576 | 181, 65, 57, 67, 59, 71, 77, 0, | ||
3659 | 0, 0, 0, 0, 0, 0, 0, 0, | 3577 | 0, 0, 0, 0, 0, 0, 0, 0, |
3660 | 0, 0, 13, 13, 13, 195, 195, 195, | ||
3661 | 195, 195, 195, 13, 13, 195, 13, 83, | ||
3662 | 0, 0, 0, 0, 0, 0, 0, 0, | 3578 | 0, 0, 0, 0, 0, 0, 0, 0, |
3579 | 0, 0, 0, 0, 0, 7, 7, 7, | ||
3580 | 190, 190, 190, 190, 190, 190, 7, 7, | ||
3581 | 190, 7, 81, 0, 0, 0, 0, 0, | ||
3663 | 0, 0, 0, 0, 0, 0, 0, 0, | 3582 | 0, 0, 0, 0, 0, 0, 0, 0, |
3664 | 0, 0, 0, 0, 0, 0, 0, 0, | 3583 | 0, 0, 0, 0, 0, 0, 0, 0, |
3665 | 0, 0, 0, 85, 0, 0, 0, 0, | 3584 | 0, 0, 0, 0, 0, 0, 83, 0, |
3666 | 0, 0, 0, 0, 0, 0, 0, 0, | 3585 | 0, 0, 0, 0, 0, 0, 0, 0, |
3667 | 0, 0, 0, 0, 0, 0, 0, 0, | 3586 | 0, 0, 0, 0, 0, 0, 0, 0, |
3668 | 0, 0, 0, 0, 0, 0, 0, 0, | 3587 | 0, 0, 0, 0, 0, 0, 0, 0, |
@@ -3680,7 +3599,7 @@ var _hcltok_trans_actions []byte = []byte{ | |||
3680 | 0, 0, 0, 0, 0, 0, 0, 0, | 3599 | 0, 0, 0, 0, 0, 0, 0, 0, |
3681 | 0, 0, 0, 0, 0, 0, 0, 0, | 3600 | 0, 0, 0, 0, 0, 0, 0, 0, |
3682 | 0, 0, 0, 0, 0, 0, 0, 0, | 3601 | 0, 0, 0, 0, 0, 0, 0, 0, |
3683 | 0, 0, 0, | 3602 | 0, 0, 0, 0, 0, 0, |
3684 | } | 3603 | } |
3685 | 3604 | ||
3686 | var _hcltok_to_state_actions []byte = []byte{ | 3605 | var _hcltok_to_state_actions []byte = []byte{ |
@@ -3866,24 +3785,22 @@ var _hcltok_to_state_actions []byte = []byte{ | |||
3866 | 0, 0, 0, 0, 0, 0, 0, 0, | 3785 | 0, 0, 0, 0, 0, 0, 0, 0, |
3867 | 0, 0, 0, 0, 0, 0, 0, 0, | 3786 | 0, 0, 0, 0, 0, 0, 0, 0, |
3868 | 0, 0, 0, 0, 0, 0, 0, 0, | 3787 | 0, 0, 0, 0, 0, 0, 0, 0, |
3869 | 0, 0, 0, 0, 0, 0, 0, 0, | 3788 | 0, 0, 0, 3, 0, 0, 0, 0, |
3870 | 9, 0, 0, 0, 0, 0, 0, 0, | ||
3871 | 0, 0, 0, 0, 0, 0, 0, 0, | ||
3872 | 0, 0, 0, 0, 0, 0, 0, 0, | 3789 | 0, 0, 0, 0, 0, 0, 0, 0, |
3873 | 0, 0, 0, 0, 0, 0, 0, 0, | 3790 | 0, 0, 0, 0, 0, 0, 0, 0, |
3874 | 0, 0, 0, 0, 0, 0, 0, 0, | 3791 | 0, 0, 0, 0, 0, 0, 0, 0, |
3875 | 0, 0, 0, 0, 0, 0, 0, 0, | 3792 | 0, 0, 0, 0, 0, 0, 0, 0, |
3876 | 0, 0, 0, 9, 0, 0, 0, 0, | ||
3877 | 0, 0, 0, 0, 0, 0, 0, 0, | 3793 | 0, 0, 0, 0, 0, 0, 0, 0, |
3794 | 0, 0, 0, 0, 0, 3, 0, 0, | ||
3878 | 0, 0, 0, 0, 0, 0, 0, 0, | 3795 | 0, 0, 0, 0, 0, 0, 0, 0, |
3879 | 0, 0, 0, 0, 0, 171, 0, 0, | 3796 | 0, 0, 0, 166, 0, 0, 0, 0, |
3880 | 0, 0, 0, 0, 0, 0, 171, 0, | 3797 | 0, 0, 0, 0, 0, 0, 166, 0, |
3881 | 0, 0, 0, 0, 0, 9, 0, 0, | ||
3882 | 0, 0, 0, 0, 0, 0, 0, 0, | 3798 | 0, 0, 0, 0, 0, 0, 0, 0, |
3799 | 0, 3, 0, 0, 0, 0, 0, 0, | ||
3883 | 0, 0, 0, 0, 0, 0, 0, 0, | 3800 | 0, 0, 0, 0, 0, 0, 0, 0, |
3884 | 0, 0, 0, 0, 0, 0, 0, 0, | 3801 | 0, 0, 0, 0, 0, 0, 0, 0, |
3885 | 0, 0, 0, 0, 0, 0, 0, 0, | 3802 | 0, 0, 0, 0, 0, 0, 0, 0, |
3886 | 0, 0, | 3803 | 0, 0, 0, 0, 0, 0, |
3887 | } | 3804 | } |
3888 | 3805 | ||
3889 | var _hcltok_from_state_actions []byte = []byte{ | 3806 | var _hcltok_from_state_actions []byte = []byte{ |
@@ -4069,147 +3986,144 @@ var _hcltok_from_state_actions []byte = []byte{ | |||
4069 | 0, 0, 0, 0, 0, 0, 0, 0, | 3986 | 0, 0, 0, 0, 0, 0, 0, 0, |
4070 | 0, 0, 0, 0, 0, 0, 0, 0, | 3987 | 0, 0, 0, 0, 0, 0, 0, 0, |
4071 | 0, 0, 0, 0, 0, 0, 0, 0, | 3988 | 0, 0, 0, 0, 0, 0, 0, 0, |
3989 | 0, 0, 0, 5, 0, 0, 0, 0, | ||
4072 | 0, 0, 0, 0, 0, 0, 0, 0, | 3990 | 0, 0, 0, 0, 0, 0, 0, 0, |
4073 | 11, 0, 0, 0, 0, 0, 0, 0, | ||
4074 | 0, 0, 0, 0, 0, 0, 0, 0, | 3991 | 0, 0, 0, 0, 0, 0, 0, 0, |
4075 | 0, 0, 0, 0, 0, 0, 0, 0, | 3992 | 0, 0, 0, 0, 0, 0, 0, 0, |
4076 | 0, 0, 0, 0, 0, 0, 0, 0, | 3993 | 0, 0, 0, 0, 0, 0, 0, 0, |
4077 | 0, 0, 0, 0, 0, 0, 0, 0, | 3994 | 0, 0, 0, 0, 0, 0, 0, 0, |
3995 | 0, 0, 0, 0, 0, 5, 0, 0, | ||
4078 | 0, 0, 0, 0, 0, 0, 0, 0, | 3996 | 0, 0, 0, 0, 0, 0, 0, 0, |
4079 | 0, 0, 0, 11, 0, 0, 0, 0, | 3997 | 0, 0, 0, 5, 0, 0, 0, 0, |
3998 | 0, 0, 0, 0, 0, 0, 5, 0, | ||
4080 | 0, 0, 0, 0, 0, 0, 0, 0, | 3999 | 0, 0, 0, 0, 0, 0, 0, 0, |
4000 | 0, 5, 0, 0, 0, 0, 0, 0, | ||
4081 | 0, 0, 0, 0, 0, 0, 0, 0, | 4001 | 0, 0, 0, 0, 0, 0, 0, 0, |
4082 | 0, 0, 0, 0, 0, 11, 0, 0, | ||
4083 | 0, 0, 0, 0, 0, 0, 11, 0, | ||
4084 | 0, 0, 0, 0, 0, 11, 0, 0, | ||
4085 | 0, 0, 0, 0, 0, 0, 0, 0, | 4002 | 0, 0, 0, 0, 0, 0, 0, 0, |
4086 | 0, 0, 0, 0, 0, 0, 0, 0, | 4003 | 0, 0, 0, 0, 0, 0, 0, 0, |
4087 | 0, 0, 0, 0, 0, 0, 0, 0, | 4004 | 0, 0, 0, 0, 0, 0, |
4088 | 0, 0, 0, 0, 0, 0, 0, 0, | ||
4089 | 0, 0, | ||
4090 | } | 4005 | } |
4091 | 4006 | ||
4092 | var _hcltok_eof_trans []int16 = []int16{ | 4007 | var _hcltok_eof_trans []int16 = []int16{ |
4093 | 0, 1, 4, 1, 1, 9, 9, 9, | 4008 | 0, 1, 1, 1, 6, 6, 6, 1, |
4094 | 4, 4, 4, 4, 4, 4, 4, 4, | 4009 | 1, 1, 1, 1, 1, 1, 1, 1, |
4095 | 4, 4, 4, 4, 4, 4, 4, 4, | 4010 | 1, 1, 1, 1, 1, 1, 1, 1, |
4096 | 4, 4, 4, 4, 4, 4, 4, 4, | 4011 | 1, 1, 1, 1, 1, 1, 1, 1, |
4097 | 4, 4, 4, 4, 4, 4, 4, 4, | 4012 | 1, 1, 1, 1, 1, 1, 1, 1, |
4098 | 4, 4, 4, 4, 4, 4, 4, 4, | 4013 | 1, 1, 1, 1, 1, 1, 1, 1, |
4099 | 4, 4, 4, 4, 4, 4, 4, 4, | 4014 | 1, 1, 1, 1, 1, 1, 1, 1, |
4100 | 4, 4, 4, 4, 4, 4, 4, 4, | 4015 | 1, 1, 1, 1, 1, 1, 1, 1, |
4101 | 4, 4, 4, 4, 4, 4, 4, 4, | 4016 | 1, 1, 1, 1, 1, 1, 1, 1, |
4102 | 4, 4, 4, 4, 4, 4, 4, 4, | 4017 | 1, 1, 1, 1, 1, 1, 1, 1, |
4103 | 4, 4, 4, 4, 4, 4, 4, 4, | 4018 | 1, 1, 1, 1, 1, 1, 1, 1, |
4104 | 4, 4, 4, 4, 4, 4, 4, 4, | 4019 | 1, 1, 1, 1, 1, 1, 1, 1, |
4105 | 4, 4, 4, 4, 4, 4, 4, 4, | 4020 | 1, 1, 1, 1, 1, 1, 1, 1, |
4106 | 4, 4, 4, 4, 4, 4, 4, 4, | 4021 | 1, 1, 1, 1, 1, 1, 1, 1, |
4107 | 4, 4, 4, 4, 4, 4, 4, 4, | 4022 | 1, 1, 1, 1, 1, 1, 1, 1, |
4108 | 4, 4, 4, 4, 4, 4, 4, 4, | 4023 | 1, 1, 1, 1, 1, 1, 1, 1, |
4109 | 4, 4, 4, 4, 4, 4, 4, 4, | 4024 | 1, 1, 1, 1, 1, 1, 1, 1, |
4110 | 4, 4, 4, 4, 4, 4, 4, 4, | 4025 | 1, 1, 1, 1, 1, 1, 1, 1, |
4111 | 4, 4, 4, 4, 4, 4, 4, 4, | 4026 | 1, 1, 1, 1, 1, 1, 1, 1, |
4112 | 4, 4, 4, 4, 4, 4, 4, 4, | 4027 | 1, 1, 1, 1, 1, 1, 1, 1, |
4113 | 4, 4, 4, 4, 4, 4, 4, 4, | 4028 | 1, 1, 1, 1, 1, 1, 1, 1, |
4114 | 4, 4, 4, 4, 4, 4, 4, 4, | 4029 | 1, 1, 1, 1, 1, 1, 1, 1, |
4115 | 4, 4, 4, 4, 4, 4, 4, 4, | 4030 | 1, 1, 1, 1, 1, 1, 1, 1, |
4116 | 4, 4, 4, 4, 4, 4, 4, 4, | 4031 | 1, 1, 1, 1, 1, 1, 1, 1, |
4117 | 4, 4, 4, 4, 4, 4, 4, 4, | 4032 | 1, 1, 1, 1, 1, 1, 1, 1, |
4118 | 4, 4, 4, 4, 4, 4, 4, 4, | 4033 | 1, 1, 1, 1, 1, 1, 1, 1, |
4119 | 4, 4, 4, 4, 4, 4, 4, 4, | 4034 | 1, 1, 1, 1, 1, 1, 1, 1, |
4120 | 4, 4, 4, 4, 4, 4, 4, 4, | 4035 | 1, 1, 1, 1, 1, 1, 1, 1, |
4121 | 4, 4, 4, 4, 4, 4, 4, 4, | 4036 | 1, 1, 1, 1, 1, 1, 1, 1, |
4122 | 4, 4, 4, 4, 4, 4, 4, 4, | 4037 | 1, 1, 1, 1, 1, 1, 1, 1, |
4123 | 4, 4, 4, 4, 4, 4, 4, 4, | 4038 | 1, 1, 1, 1, 1, 1, 1, 1, |
4124 | 4, 4, 4, 4, 4, 4, 4, 4, | 4039 | 1, 1, 1, 1, 1, 1, 1, 1, |
4125 | 4, 4, 4, 4, 4, 4, 4, 4, | 4040 | 1, 1, 1, 1, 1, 1, 1, 1, |
4126 | 4, 4, 4, 4, 4, 4, 4, 4, | 4041 | 1, 1, 1, 1, 1, 1, 1, 1, |
4127 | 4, 4, 4, 4, 4, 4, 4, 4, | 4042 | 1, 1, 1, 1, 1, 1, 1, 1, |
4128 | 4, 4, 4, 4, 4, 4, 4, 4, | 4043 | 1, 1, 1, 1, 1, 1, 1, 1, |
4129 | 4, 4, 4, 4, 4, 4, 4, 4, | 4044 | 1, 1, 1, 1, 1, 1, 1, 1, |
4130 | 4, 4, 4, 4, 4, 4, 4, 4, | 4045 | 1, 1, 1, 1, 1, 1, 1, 1, |
4131 | 4, 4, 4, 4, 4, 4, 4, 4, | 4046 | 1, 1, 1, 1, 1, 1, 1, 1, |
4132 | 4, 4, 4, 4, 4, 4, 4, 4, | 4047 | 1, 1, 1, 1, 1, 1, 1, 1, |
4133 | 4, 4, 4, 4, 4, 4, 4, 4, | 4048 | 1, 1, 1, 1, 1, 1, 1, 1, |
4134 | 4, 4, 4, 4, 4, 4, 4, 4, | 4049 | 1, 1, 1, 1, 1, 1, 1, 1, |
4135 | 4, 4, 4, 4, 4, 4, 4, 4, | 4050 | 1, 1, 1, 1, 1, 1, 1, 1, |
4136 | 4, 4, 4, 4, 4, 4, 4, 4, | 4051 | 1, 1, 1, 1, 1, 1, 1, 1, |
4137 | 4, 4, 4, 4, 4, 4, 4, 4, | 4052 | 1, 1, 1, 1, 1, 1, 1, 1, |
4138 | 4, 4, 4, 4, 4, 4, 4, 4, | 4053 | 1, 1, 1, 1, 1, 1, 1, 1, |
4139 | 4, 4, 4, 4, 4, 4, 4, 4, | 4054 | 1, 1, 1, 1, 1, 1, 1, 1, |
4140 | 4, 4, 4, 4, 4, 4, 4, 4, | 4055 | 1, 1, 1, 1, 1, 1, 1, 1, |
4141 | 4, 4, 4, 4, 4, 4, 4, 4, | 4056 | 1, 1, 1, 1, 1, 1, 1, 1, |
4142 | 4, 4, 4, 4, 4, 4, 4, 4, | 4057 | 1, 1, 1, 1, 1, 1, 1, 1, |
4143 | 4, 4, 4, 4, 4, 4, 4, 4, | 4058 | 1, 1, 1, 1, 1, 1, 1, 1, |
4144 | 4, 4, 4, 4, 4, 4, 4, 4, | 4059 | 1, 1, 1, 1, 1, 1, 1, 419, |
4145 | 422, 422, 1, 422, 422, 422, 422, 422, | 4060 | 419, 421, 419, 419, 419, 419, 419, 419, |
4146 | 422, 422, 422, 422, 422, 422, 422, 422, | 4061 | 419, 419, 419, 419, 419, 419, 419, 419, |
4147 | 422, 422, 422, 422, 422, 422, 422, 422, | 4062 | 419, 419, 419, 419, 419, 419, 419, 419, |
4148 | 422, 422, 422, 422, 422, 422, 422, 422, | 4063 | 419, 419, 419, 419, 419, 419, 419, 419, |
4149 | 422, 422, 422, 422, 422, 422, 422, 422, | 4064 | 419, 419, 419, 419, 419, 419, 419, 419, |
4150 | 422, 422, 422, 422, 422, 422, 422, 422, | 4065 | 419, 419, 419, 419, 419, 419, 419, 419, |
4151 | 422, 422, 422, 422, 422, 422, 422, 422, | 4066 | 419, 419, 419, 419, 419, 419, 419, 419, |
4152 | 422, 422, 422, 422, 422, 422, 422, 422, | 4067 | 419, 419, 419, 419, 419, 419, 419, 419, |
4153 | 422, 422, 422, 422, 422, 422, 422, 422, | 4068 | 419, 419, 419, 419, 419, 419, 419, 419, |
4154 | 422, 422, 422, 422, 422, 422, 422, 422, | 4069 | 419, 419, 419, 419, 419, 419, 419, 419, |
4155 | 422, 422, 422, 422, 422, 422, 422, 422, | 4070 | 419, 419, 419, 419, 419, 419, 419, 419, |
4156 | 422, 422, 422, 422, 422, 422, 422, 422, | 4071 | 419, 419, 419, 419, 419, 419, 419, 419, |
4157 | 422, 422, 422, 422, 422, 422, 422, 422, | 4072 | 419, 419, 419, 419, 419, 419, 419, 419, |
4158 | 422, 422, 422, 422, 422, 422, 422, 422, | 4073 | 419, 419, 419, 419, 419, 419, 419, 419, |
4159 | 422, 422, 422, 422, 422, 422, 422, 422, | 4074 | 419, 419, 419, 419, 419, 419, 419, 419, |
4160 | 422, 422, 422, 422, 422, 422, 422, 422, | 4075 | 419, 419, 419, 419, 419, 419, 419, 419, |
4161 | 422, 422, 422, 422, 422, 422, 422, 422, | 4076 | 419, 419, 419, 419, 419, 419, 419, 419, |
4162 | 422, 422, 422, 422, 422, 422, 422, 422, | 4077 | 419, 419, 419, 419, 419, 419, 419, 419, |
4163 | 422, 422, 422, 422, 422, 422, 422, 422, | 4078 | 419, 419, 419, 419, 419, 419, 419, 419, |
4164 | 422, 422, 422, 422, 422, 422, 422, 422, | 4079 | 419, 419, 419, 419, 419, 419, 419, 419, |
4165 | 422, 422, 422, 422, 422, 422, 422, 422, | 4080 | 419, 419, 419, 419, 419, 419, 419, 419, |
4166 | 422, 422, 422, 422, 422, 422, 422, 422, | 4081 | 419, 419, 419, 419, 419, 419, 419, 419, |
4167 | 422, 422, 422, 422, 422, 422, 422, 422, | 4082 | 419, 419, 419, 419, 419, 419, 419, 419, |
4168 | 422, 422, 422, 422, 422, 422, 422, 422, | 4083 | 419, 419, 419, 419, 419, 419, 419, 419, |
4169 | 422, 422, 422, 422, 422, 422, 422, 422, | 4084 | 419, 419, 419, 419, 419, 419, 419, 419, |
4170 | 422, 422, 422, 422, 422, 422, 422, 422, | 4085 | 419, 419, 419, 419, 419, 419, 419, 419, |
4171 | 422, 422, 422, 422, 422, 422, 422, 422, | 4086 | 419, 419, 419, 419, 419, 419, 419, 419, |
4172 | 422, 422, 422, 422, 422, 422, 422, 422, | 4087 | 419, 419, 419, 419, 419, 419, 419, 419, |
4173 | 422, 422, 422, 422, 422, 422, 422, 422, | 4088 | 419, 419, 419, 419, 419, 419, 419, 419, |
4174 | 422, 422, 422, 422, 422, 422, 422, 422, | 4089 | 419, 419, 419, 419, 419, 419, 419, 419, |
4175 | 422, 422, 422, 422, 422, 422, 422, 422, | 4090 | 419, 419, 419, 419, 419, 419, 419, 419, |
4176 | 422, 422, 422, 422, 422, 422, 422, 422, | 4091 | 419, 419, 419, 419, 419, 419, 419, 419, |
4177 | 422, 422, 422, 422, 422, 422, 422, 422, | 4092 | 419, 419, 419, 419, 419, 419, 419, 419, |
4178 | 422, 422, 422, 422, 422, 422, 422, 422, | 4093 | 419, 419, 419, 419, 419, 419, 419, 419, |
4179 | 422, 422, 422, 672, 672, 672, 672, 672, | 4094 | 419, 419, 670, 670, 670, 670, 670, 670, |
4180 | 672, 672, 672, 672, 672, 672, 672, 672, | 4095 | 670, 670, 670, 670, 670, 670, 670, 670, |
4181 | 672, 672, 672, 672, 672, 672, 672, 672, | 4096 | 670, 670, 670, 670, 670, 670, 670, 670, |
4182 | 672, 672, 672, 672, 672, 672, 672, 672, | 4097 | 670, 670, 670, 670, 670, 670, 670, 670, |
4183 | 672, 672, 672, 672, 672, 672, 672, 672, | 4098 | 670, 670, 670, 670, 670, 670, 670, 670, |
4184 | 672, 672, 672, 672, 672, 672, 672, 672, | 4099 | 670, 670, 670, 670, 670, 670, 670, 670, |
4185 | 672, 672, 672, 672, 672, 672, 672, 672, | 4100 | 670, 670, 670, 670, 670, 670, 670, 670, |
4186 | 672, 672, 672, 672, 672, 672, 672, 672, | 4101 | 670, 670, 670, 670, 670, 670, 670, 670, |
4187 | 672, 672, 672, 672, 672, 672, 672, 672, | 4102 | 670, 670, 670, 670, 670, 670, 670, 670, |
4188 | 672, 672, 672, 672, 672, 672, 672, 672, | 4103 | 670, 670, 670, 670, 670, 670, 670, 670, |
4189 | 672, 672, 672, 672, 672, 672, 672, 672, | 4104 | 670, 670, 670, 670, 670, 670, 670, 670, |
4190 | 672, 672, 672, 672, 672, 672, 672, 672, | 4105 | 670, 670, 670, 670, 670, 670, 670, 670, |
4191 | 672, 672, 672, 672, 672, 672, 672, 672, | 4106 | 670, 670, 670, 670, 670, 670, 670, 670, |
4192 | 672, 672, 672, 672, 672, 672, 672, 672, | 4107 | 670, 670, 670, 670, 670, 670, 670, 670, |
4193 | 672, 672, 672, 672, 672, 672, 672, 672, | 4108 | 670, 670, 670, 670, 670, 670, 670, 670, |
4194 | 672, 672, 672, 672, 672, 672, 672, 672, | 4109 | 670, 670, 670, 670, 670, 670, 670, 670, |
4195 | 672, 672, 672, 672, 672, 672, 672, 672, | 4110 | 670, 670, 670, 670, 670, 670, 670, 670, |
4196 | 672, 672, 672, 672, 672, 672, 672, 672, | 4111 | 670, 670, 670, 670, 670, 670, 670, 670, |
4197 | 672, 672, 672, 672, 672, 672, 672, 672, | 4112 | 670, 670, 670, 670, 670, 670, 670, 670, |
4198 | 672, 672, 672, 672, 672, 672, 672, 672, | 4113 | 670, 670, 670, 670, 670, 670, 670, 670, |
4199 | 672, 672, 672, 672, 672, 672, 672, 672, | 4114 | 670, 670, 670, 670, 670, 670, 670, 670, |
4200 | 672, 672, 672, 672, 672, 672, 672, 672, | 4115 | 670, 670, 670, 670, 670, 670, 670, 670, |
4201 | 672, 672, 672, 672, 672, 672, 672, 672, | 4116 | 670, 670, 670, 670, 670, 670, 670, 670, |
4202 | 672, 672, 672, 672, 672, 672, 672, 672, | 4117 | 670, 670, 670, 670, 670, 670, 670, 670, |
4203 | 672, 672, 672, 672, 672, 672, 672, 672, | 4118 | 670, 670, 670, 670, 670, 670, 670, 670, |
4204 | 672, 672, 672, 672, 672, 672, 672, 672, | 4119 | 670, 670, 670, 670, 670, 670, 670, 670, |
4205 | 672, 672, 672, 672, 672, 672, 672, 672, | 4120 | 670, 670, 670, 670, 670, 670, 670, 670, |
4206 | 672, 672, 672, 672, 672, 672, 672, 672, | 4121 | 670, 670, 670, 670, 670, 670, 670, 670, |
4207 | 672, 672, 672, 672, 672, 672, 672, 672, | 4122 | 670, 670, 670, 670, 670, 670, 670, 670, |
4208 | 672, 672, 672, 672, 672, 672, 672, 672, | 4123 | 670, 670, 670, 670, 670, 670, 670, 670, |
4209 | 672, 769, 769, 769, 769, 769, 775, 775, | 4124 | 767, 772, 772, 772, 773, 773, 775, 775, |
4210 | 777, 779, 779, 777, 777, 779, 0, 0, | 4125 | 775, 779, 0, 0, 785, 785, 785, 789, |
4211 | 787, 789, 787, 787, 789, 0, 0, 795, | 4126 | 0, 0, 795, 795, 797, 795, 795, 795, |
4212 | 795, 797, 795, 795, 795, 795, 795, 795, | ||
4213 | 795, 795, 795, 795, 795, 795, 795, 795, | 4127 | 795, 795, 795, 795, 795, 795, 795, 795, |
4214 | 795, 795, 795, 795, 795, 795, 795, 795, | 4128 | 795, 795, 795, 795, 795, 795, 795, 795, |
4215 | 795, 795, 795, 795, 795, 795, 795, 795, | 4129 | 795, 795, 795, 795, 795, 795, 795, 795, |
@@ -4243,7 +4157,7 @@ var _hcltok_eof_trans []int16 = []int16{ | |||
4243 | 795, 795, 795, 795, 795, 795, 795, 795, | 4157 | 795, 795, 795, 795, 795, 795, 795, 795, |
4244 | 795, 795, 795, 795, 795, 795, 795, 795, | 4158 | 795, 795, 795, 795, 795, 795, 795, 795, |
4245 | 795, 795, 795, 795, 795, 795, 795, 795, | 4159 | 795, 795, 795, 795, 795, 795, 795, 795, |
4246 | 795, 795, 1046, 1046, 1046, 1046, 1046, 1046, | 4160 | 795, 795, 795, 795, 795, 1046, 1046, 1046, |
4247 | 1046, 1046, 1046, 1046, 1046, 1046, 1046, 1046, | 4161 | 1046, 1046, 1046, 1046, 1046, 1046, 1046, 1046, |
4248 | 1046, 1046, 1046, 1046, 1046, 1046, 1046, 1046, | 4162 | 1046, 1046, 1046, 1046, 1046, 1046, 1046, 1046, |
4249 | 1046, 1046, 1046, 1046, 1046, 1046, 1046, 1046, | 4163 | 1046, 1046, 1046, 1046, 1046, 1046, 1046, 1046, |
@@ -4273,45 +4187,49 @@ var _hcltok_eof_trans []int16 = []int16{ | |||
4273 | 1046, 1046, 1046, 1046, 1046, 1046, 1046, 1046, | 4187 | 1046, 1046, 1046, 1046, 1046, 1046, 1046, 1046, |
4274 | 1046, 1046, 1046, 1046, 1046, 1046, 1046, 1046, | 4188 | 1046, 1046, 1046, 1046, 1046, 1046, 1046, 1046, |
4275 | 1046, 1046, 1046, 1046, 1046, 1046, 1046, 1046, | 4189 | 1046, 1046, 1046, 1046, 1046, 1046, 1046, 1046, |
4276 | 0, 1196, 1197, 1198, 1197, 1198, 1198, 1198, | 4190 | 1046, 1046, 1046, 0, 1196, 1197, 1198, 1200, |
4277 | 1202, 1203, 1198, 1198, 1198, 1209, 1198, 1198, | 4191 | 1198, 1198, 1198, 1203, 1198, 1198, 1198, 1209, |
4192 | 1198, 1198, 1239, 1239, 1239, 1239, 1239, 1239, | ||
4278 | 1239, 1239, 1239, 1239, 1239, 1239, 1239, 1239, | 4193 | 1239, 1239, 1239, 1239, 1239, 1239, 1239, 1239, |
4279 | 1239, 1239, 1239, 1239, 1239, 1239, 1239, 1239, | 4194 | 1239, 1239, 1239, 1239, 1239, 1239, 1239, 1239, |
4280 | 1239, 1239, 1239, 1239, 1239, 1239, 1239, 1239, | 4195 | 1239, 1239, 1239, 1239, 1239, 1239, 1239, 1239, |
4281 | 1239, 1239, 1239, 1239, 1239, 1239, 1239, 1239, | 4196 | 1239, 1239, 1239, 1239, 1239, 0, 1392, 1394, |
4282 | 1239, 1239, 1239, 0, 1392, 1396, 1404, 1392, | 4197 | 1395, 1399, 1399, 1392, 1402, 1395, 1405, 1395, |
4283 | 1392, 1396, 1396, 1404, 1396, 1392, 1404, 1404, | 4198 | 1407, 1407, 1407, 0, 1416, 1418, 1418, 1416, |
4284 | 1404, 1404, 1404, 1396, 1396, 1396, 1458, 1460, | 4199 | 1416, 1423, 1425, 1427, 1427, 1427, 0, 1435, |
4285 | 1458, 1463, 1465, 1465, 1465, 0, 1474, 1478, | 4200 | 1437, 1437, 1435, 1435, 1442, 1444, 1446, 1446, |
4286 | 1487, 1496, 1498, 1500, 1500, 1500, 0, 1508, | 4201 | 1446, 0, 1483, 1511, 1511, 1511, 1511, 1511, |
4287 | 1511, 1513, 1515, 1515, 1515, 0, 1552, 1580, | 4202 | 1511, 1511, 1511, 1511, 1511, 1511, 1511, 1511, |
4288 | 1580, 1580, 1580, 1580, 1580, 1580, 1580, 1580, | 4203 | 1511, 1511, 1511, 1511, 1511, 1511, 1511, 1511, |
4289 | 1580, 1580, 1580, 1580, 1580, 1580, 1580, 1580, | 4204 | 1511, 1511, 1511, 1511, 1511, 1511, 1511, 1511, |
4290 | 1580, 1580, 1580, 1580, 1580, 1580, 1580, 1580, | 4205 | 1511, 1511, 1511, 1511, 1511, 1511, |
4291 | 1580, 1580, 1580, 1580, 1580, 1580, 1580, 1580, | ||
4292 | 1580, 1580, | ||
4293 | } | 4206 | } |
4294 | 4207 | ||
4295 | const hcltok_start int = 1464 | 4208 | const hcltok_start int = 1459 |
4296 | const hcltok_first_final int = 1464 | 4209 | const hcltok_first_final int = 1459 |
4297 | const hcltok_error int = 0 | 4210 | const hcltok_error int = 0 |
4298 | 4211 | ||
4299 | const hcltok_en_stringTemplate int = 1515 | 4212 | const hcltok_en_stringTemplate int = 1509 |
4300 | const hcltok_en_heredocTemplate int = 1541 | 4213 | const hcltok_en_heredocTemplate int = 1523 |
4301 | const hcltok_en_bareTemplate int = 1550 | 4214 | const hcltok_en_bareTemplate int = 1534 |
4302 | const hcltok_en_identOnly int = 1557 | 4215 | const hcltok_en_identOnly int = 1545 |
4303 | const hcltok_en_main int = 1464 | 4216 | const hcltok_en_main int = 1459 |
4304 | 4217 | ||
4305 | // line 16 "scan_tokens.rl" | 4218 | //line scan_tokens.rl:16 |
4306 | 4219 | ||
4307 | func scanTokens(data []byte, filename string, start hcl.Pos, mode scanMode) []Token { | 4220 | func scanTokens(data []byte, filename string, start hcl.Pos, mode scanMode) []Token { |
4221 | stripData := stripUTF8BOM(data) | ||
4222 | start.Byte += len(data) - len(stripData) | ||
4223 | data = stripData | ||
4224 | |||
4308 | f := &tokenAccum{ | 4225 | f := &tokenAccum{ |
4309 | Filename: filename, | 4226 | Filename: filename, |
4310 | Bytes: data, | 4227 | Bytes: data, |
4311 | Pos: start, | 4228 | Pos: start, |
4229 | StartByte: start.Byte, | ||
4312 | } | 4230 | } |
4313 | 4231 | ||
4314 | // line 294 "scan_tokens.rl" | 4232 | //line scan_tokens.rl:305 |
4315 | 4233 | ||
4316 | // Ragel state | 4234 | // Ragel state |
4317 | p := 0 // "Pointer" into data | 4235 | p := 0 // "Pointer" into data |
@@ -4339,7 +4257,7 @@ func scanTokens(data []byte, filename string, start hcl.Pos, mode scanMode) []To | |||
4339 | var retBraces []int // stack of brace levels that cause us to use fret | 4257 | var retBraces []int // stack of brace levels that cause us to use fret |
4340 | var heredocs []heredocInProgress // stack of heredocs we're currently processing | 4258 | var heredocs []heredocInProgress // stack of heredocs we're currently processing |
4341 | 4259 | ||
4342 | // line 329 "scan_tokens.rl" | 4260 | //line scan_tokens.rl:340 |
4343 | 4261 | ||
4344 | // Make Go compiler happy | 4262 | // Make Go compiler happy |
4345 | _ = ts | 4263 | _ = ts |
@@ -4359,7 +4277,7 @@ func scanTokens(data []byte, filename string, start hcl.Pos, mode scanMode) []To | |||
4359 | f.emitToken(TokenType(b[0]), ts, te) | 4277 | f.emitToken(TokenType(b[0]), ts, te) |
4360 | } | 4278 | } |
4361 | 4279 | ||
4362 | // line 4372 "scan_tokens.go" | 4280 | //line scan_tokens.go:4289 |
4363 | { | 4281 | { |
4364 | top = 0 | 4282 | top = 0 |
4365 | ts = 0 | 4283 | ts = 0 |
@@ -4367,7 +4285,7 @@ func scanTokens(data []byte, filename string, start hcl.Pos, mode scanMode) []To | |||
4367 | act = 0 | 4285 | act = 0 |
4368 | } | 4286 | } |
4369 | 4287 | ||
4370 | // line 4380 "scan_tokens.go" | 4288 | //line scan_tokens.go:4297 |
4371 | { | 4289 | { |
4372 | var _klen int | 4290 | var _klen int |
4373 | var _trans int | 4291 | var _trans int |
@@ -4387,12 +4305,11 @@ func scanTokens(data []byte, filename string, start hcl.Pos, mode scanMode) []To | |||
4387 | for ; _nacts > 0; _nacts-- { | 4305 | for ; _nacts > 0; _nacts-- { |
4388 | _acts++ | 4306 | _acts++ |
4389 | switch _hcltok_actions[_acts-1] { | 4307 | switch _hcltok_actions[_acts-1] { |
4390 | case 6: | 4308 | case 3: |
4391 | // line 1 "NONE" | 4309 | //line NONE:1 |
4392 | |||
4393 | ts = p | 4310 | ts = p |
4394 | 4311 | ||
4395 | // line 4404 "scan_tokens.go" | 4312 | //line scan_tokens.go:4320 |
4396 | } | 4313 | } |
4397 | } | 4314 | } |
4398 | 4315 | ||
@@ -4464,33 +4381,21 @@ func scanTokens(data []byte, filename string, start hcl.Pos, mode scanMode) []To | |||
4464 | _acts++ | 4381 | _acts++ |
4465 | switch _hcltok_actions[_acts-1] { | 4382 | switch _hcltok_actions[_acts-1] { |
4466 | case 0: | 4383 | case 0: |
4467 | // line 218 "scan_tokens.rl" | 4384 | //line scan_tokens.rl:224 |
4468 | |||
4469 | p-- | ||
4470 | |||
4471 | case 1: | ||
4472 | // line 219 "scan_tokens.rl" | ||
4473 | |||
4474 | p-- | ||
4475 | |||
4476 | case 2: | ||
4477 | // line 224 "scan_tokens.rl" | ||
4478 | |||
4479 | p-- | ||
4480 | |||
4481 | case 3: | ||
4482 | // line 225 "scan_tokens.rl" | ||
4483 | |||
4484 | p-- | 4385 | p-- |
4485 | 4386 | ||
4486 | case 7: | 4387 | case 4: |
4487 | // line 1 "NONE" | 4388 | //line NONE:1 |
4488 | |||
4489 | te = p + 1 | 4389 | te = p + 1 |
4490 | 4390 | ||
4491 | case 8: | 4391 | case 5: |
4492 | // line 155 "scan_tokens.rl" | 4392 | //line scan_tokens.rl:248 |
4493 | 4393 | act = 4 | |
4394 | case 6: | ||
4395 | //line scan_tokens.rl:250 | ||
4396 | act = 6 | ||
4397 | case 7: | ||
4398 | //line scan_tokens.rl:160 | ||
4494 | te = p + 1 | 4399 | te = p + 1 |
4495 | { | 4400 | { |
4496 | token(TokenTemplateInterp) | 4401 | token(TokenTemplateInterp) |
@@ -4503,13 +4408,12 @@ func scanTokens(data []byte, filename string, start hcl.Pos, mode scanMode) []To | |||
4503 | stack = append(stack, 0) | 4408 | stack = append(stack, 0) |
4504 | stack[top] = cs | 4409 | stack[top] = cs |
4505 | top++ | 4410 | top++ |
4506 | cs = 1464 | 4411 | cs = 1459 |
4507 | goto _again | 4412 | goto _again |
4508 | } | 4413 | } |
4509 | } | 4414 | } |
4510 | case 9: | 4415 | case 8: |
4511 | // line 165 "scan_tokens.rl" | 4416 | //line scan_tokens.rl:170 |
4512 | |||
4513 | te = p + 1 | 4417 | te = p + 1 |
4514 | { | 4418 | { |
4515 | token(TokenTemplateControl) | 4419 | token(TokenTemplateControl) |
@@ -4522,13 +4426,12 @@ func scanTokens(data []byte, filename string, start hcl.Pos, mode scanMode) []To | |||
4522 | stack = append(stack, 0) | 4426 | stack = append(stack, 0) |
4523 | stack[top] = cs | 4427 | stack[top] = cs |
4524 | top++ | 4428 | top++ |
4525 | cs = 1464 | 4429 | cs = 1459 |
4526 | goto _again | 4430 | goto _again |
4527 | } | 4431 | } |
4528 | } | 4432 | } |
4529 | case 10: | 4433 | case 9: |
4530 | // line 79 "scan_tokens.rl" | 4434 | //line scan_tokens.rl:84 |
4531 | |||
4532 | te = p + 1 | 4435 | te = p + 1 |
4533 | { | 4436 | { |
4534 | token(TokenCQuote) | 4437 | token(TokenCQuote) |
@@ -4540,23 +4443,20 @@ func scanTokens(data []byte, filename string, start hcl.Pos, mode scanMode) []To | |||
4540 | goto _again | 4443 | goto _again |
4541 | 4444 | ||
4542 | } | 4445 | } |
4543 | case 11: | 4446 | case 10: |
4544 | // line 239 "scan_tokens.rl" | 4447 | //line scan_tokens.rl:248 |
4545 | |||
4546 | te = p + 1 | 4448 | te = p + 1 |
4547 | { | 4449 | { |
4548 | token(TokenInvalid) | 4450 | token(TokenQuotedLit) |
4549 | } | 4451 | } |
4550 | case 12: | 4452 | case 11: |
4551 | // line 240 "scan_tokens.rl" | 4453 | //line scan_tokens.rl:251 |
4552 | |||
4553 | te = p + 1 | 4454 | te = p + 1 |
4554 | { | 4455 | { |
4555 | token(TokenBadUTF8) | 4456 | token(TokenBadUTF8) |
4556 | } | 4457 | } |
4557 | case 13: | 4458 | case 12: |
4558 | // line 155 "scan_tokens.rl" | 4459 | //line scan_tokens.rl:160 |
4559 | |||
4560 | te = p | 4460 | te = p |
4561 | p-- | 4461 | p-- |
4562 | { | 4462 | { |
@@ -4570,13 +4470,12 @@ func scanTokens(data []byte, filename string, start hcl.Pos, mode scanMode) []To | |||
4570 | stack = append(stack, 0) | 4470 | stack = append(stack, 0) |
4571 | stack[top] = cs | 4471 | stack[top] = cs |
4572 | top++ | 4472 | top++ |
4573 | cs = 1464 | 4473 | cs = 1459 |
4574 | goto _again | 4474 | goto _again |
4575 | } | 4475 | } |
4576 | } | 4476 | } |
4577 | case 14: | 4477 | case 13: |
4578 | // line 165 "scan_tokens.rl" | 4478 | //line scan_tokens.rl:170 |
4579 | |||
4580 | te = p | 4479 | te = p |
4581 | p-- | 4480 | p-- |
4582 | { | 4481 | { |
@@ -4590,59 +4489,73 @@ func scanTokens(data []byte, filename string, start hcl.Pos, mode scanMode) []To | |||
4590 | stack = append(stack, 0) | 4489 | stack = append(stack, 0) |
4591 | stack[top] = cs | 4490 | stack[top] = cs |
4592 | top++ | 4491 | top++ |
4593 | cs = 1464 | 4492 | cs = 1459 |
4594 | goto _again | 4493 | goto _again |
4595 | } | 4494 | } |
4596 | } | 4495 | } |
4597 | case 15: | 4496 | case 14: |
4598 | // line 238 "scan_tokens.rl" | 4497 | //line scan_tokens.rl:248 |
4599 | |||
4600 | te = p | 4498 | te = p |
4601 | p-- | 4499 | p-- |
4602 | { | 4500 | { |
4603 | token(TokenQuotedLit) | 4501 | token(TokenQuotedLit) |
4604 | } | 4502 | } |
4503 | case 15: | ||
4504 | //line scan_tokens.rl:249 | ||
4505 | te = p | ||
4506 | p-- | ||
4507 | { | ||
4508 | token(TokenQuotedNewline) | ||
4509 | } | ||
4605 | case 16: | 4510 | case 16: |
4606 | // line 239 "scan_tokens.rl" | 4511 | //line scan_tokens.rl:250 |
4607 | |||
4608 | te = p | 4512 | te = p |
4609 | p-- | 4513 | p-- |
4610 | { | 4514 | { |
4611 | token(TokenInvalid) | 4515 | token(TokenInvalid) |
4612 | } | 4516 | } |
4613 | case 17: | 4517 | case 17: |
4614 | // line 240 "scan_tokens.rl" | 4518 | //line scan_tokens.rl:251 |
4615 | |||
4616 | te = p | 4519 | te = p |
4617 | p-- | 4520 | p-- |
4618 | { | 4521 | { |
4619 | token(TokenBadUTF8) | 4522 | token(TokenBadUTF8) |
4620 | } | 4523 | } |
4621 | case 18: | 4524 | case 18: |
4622 | // line 238 "scan_tokens.rl" | 4525 | //line scan_tokens.rl:248 |
4623 | |||
4624 | p = (te) - 1 | 4526 | p = (te) - 1 |
4625 | { | 4527 | { |
4626 | token(TokenQuotedLit) | 4528 | token(TokenQuotedLit) |
4627 | } | 4529 | } |
4628 | case 19: | 4530 | case 19: |
4629 | // line 240 "scan_tokens.rl" | 4531 | //line scan_tokens.rl:251 |
4630 | |||
4631 | p = (te) - 1 | 4532 | p = (te) - 1 |
4632 | { | 4533 | { |
4633 | token(TokenBadUTF8) | 4534 | token(TokenBadUTF8) |
4634 | } | 4535 | } |
4635 | case 20: | 4536 | case 20: |
4636 | // line 143 "scan_tokens.rl" | 4537 | //line NONE:1 |
4538 | switch act { | ||
4539 | case 4: | ||
4540 | { | ||
4541 | p = (te) - 1 | ||
4542 | token(TokenQuotedLit) | ||
4543 | } | ||
4544 | case 6: | ||
4545 | { | ||
4546 | p = (te) - 1 | ||
4547 | token(TokenInvalid) | ||
4548 | } | ||
4549 | } | ||
4637 | 4550 | ||
4638 | act = 10 | ||
4639 | case 21: | 4551 | case 21: |
4640 | // line 248 "scan_tokens.rl" | 4552 | //line scan_tokens.rl:148 |
4641 | |||
4642 | act = 11 | 4553 | act = 11 |
4643 | case 22: | 4554 | case 22: |
4644 | // line 155 "scan_tokens.rl" | 4555 | //line scan_tokens.rl:259 |
4645 | 4556 | act = 12 | |
4557 | case 23: | ||
4558 | //line scan_tokens.rl:160 | ||
4646 | te = p + 1 | 4559 | te = p + 1 |
4647 | { | 4560 | { |
4648 | token(TokenTemplateInterp) | 4561 | token(TokenTemplateInterp) |
@@ -4655,13 +4568,12 @@ func scanTokens(data []byte, filename string, start hcl.Pos, mode scanMode) []To | |||
4655 | stack = append(stack, 0) | 4568 | stack = append(stack, 0) |
4656 | stack[top] = cs | 4569 | stack[top] = cs |
4657 | top++ | 4570 | top++ |
4658 | cs = 1464 | 4571 | cs = 1459 |
4659 | goto _again | 4572 | goto _again |
4660 | } | 4573 | } |
4661 | } | 4574 | } |
4662 | case 23: | 4575 | case 24: |
4663 | // line 165 "scan_tokens.rl" | 4576 | //line scan_tokens.rl:170 |
4664 | |||
4665 | te = p + 1 | 4577 | te = p + 1 |
4666 | { | 4578 | { |
4667 | token(TokenTemplateControl) | 4579 | token(TokenTemplateControl) |
@@ -4674,13 +4586,12 @@ func scanTokens(data []byte, filename string, start hcl.Pos, mode scanMode) []To | |||
4674 | stack = append(stack, 0) | 4586 | stack = append(stack, 0) |
4675 | stack[top] = cs | 4587 | stack[top] = cs |
4676 | top++ | 4588 | top++ |
4677 | cs = 1464 | 4589 | cs = 1459 |
4678 | goto _again | 4590 | goto _again |
4679 | } | 4591 | } |
4680 | } | 4592 | } |
4681 | case 24: | 4593 | case 25: |
4682 | // line 106 "scan_tokens.rl" | 4594 | //line scan_tokens.rl:111 |
4683 | |||
4684 | te = p + 1 | 4595 | te = p + 1 |
4685 | { | 4596 | { |
4686 | // This action is called specificially when a heredoc literal | 4597 | // This action is called specificially when a heredoc literal |
@@ -4724,16 +4635,14 @@ func scanTokens(data []byte, filename string, start hcl.Pos, mode scanMode) []To | |||
4724 | topdoc.StartOfLine = true | 4635 | topdoc.StartOfLine = true |
4725 | token(TokenStringLit) | 4636 | token(TokenStringLit) |
4726 | } | 4637 | } |
4727 | case 25: | 4638 | case 26: |
4728 | // line 248 "scan_tokens.rl" | 4639 | //line scan_tokens.rl:259 |
4729 | |||
4730 | te = p + 1 | 4640 | te = p + 1 |
4731 | { | 4641 | { |
4732 | token(TokenBadUTF8) | 4642 | token(TokenBadUTF8) |
4733 | } | 4643 | } |
4734 | case 26: | 4644 | case 27: |
4735 | // line 155 "scan_tokens.rl" | 4645 | //line scan_tokens.rl:160 |
4736 | |||
4737 | te = p | 4646 | te = p |
4738 | p-- | 4647 | p-- |
4739 | { | 4648 | { |
@@ -4747,13 +4656,12 @@ func scanTokens(data []byte, filename string, start hcl.Pos, mode scanMode) []To | |||
4747 | stack = append(stack, 0) | 4656 | stack = append(stack, 0) |
4748 | stack[top] = cs | 4657 | stack[top] = cs |
4749 | top++ | 4658 | top++ |
4750 | cs = 1464 | 4659 | cs = 1459 |
4751 | goto _again | 4660 | goto _again |
4752 | } | 4661 | } |
4753 | } | 4662 | } |
4754 | case 27: | 4663 | case 28: |
4755 | // line 165 "scan_tokens.rl" | 4664 | //line scan_tokens.rl:170 |
4756 | |||
4757 | te = p | 4665 | te = p |
4758 | p-- | 4666 | p-- |
4759 | { | 4667 | { |
@@ -4767,13 +4675,12 @@ func scanTokens(data []byte, filename string, start hcl.Pos, mode scanMode) []To | |||
4767 | stack = append(stack, 0) | 4675 | stack = append(stack, 0) |
4768 | stack[top] = cs | 4676 | stack[top] = cs |
4769 | top++ | 4677 | top++ |
4770 | cs = 1464 | 4678 | cs = 1459 |
4771 | goto _again | 4679 | goto _again |
4772 | } | 4680 | } |
4773 | } | 4681 | } |
4774 | case 28: | 4682 | case 29: |
4775 | // line 143 "scan_tokens.rl" | 4683 | //line scan_tokens.rl:148 |
4776 | |||
4777 | te = p | 4684 | te = p |
4778 | p-- | 4685 | p-- |
4779 | { | 4686 | { |
@@ -4783,17 +4690,15 @@ func scanTokens(data []byte, filename string, start hcl.Pos, mode scanMode) []To | |||
4783 | heredocs[len(heredocs)-1].StartOfLine = false | 4690 | heredocs[len(heredocs)-1].StartOfLine = false |
4784 | token(TokenStringLit) | 4691 | token(TokenStringLit) |
4785 | } | 4692 | } |
4786 | case 29: | 4693 | case 30: |
4787 | // line 248 "scan_tokens.rl" | 4694 | //line scan_tokens.rl:259 |
4788 | |||
4789 | te = p | 4695 | te = p |
4790 | p-- | 4696 | p-- |
4791 | { | 4697 | { |
4792 | token(TokenBadUTF8) | 4698 | token(TokenBadUTF8) |
4793 | } | 4699 | } |
4794 | case 30: | 4700 | case 31: |
4795 | // line 143 "scan_tokens.rl" | 4701 | //line scan_tokens.rl:148 |
4796 | |||
4797 | p = (te) - 1 | 4702 | p = (te) - 1 |
4798 | { | 4703 | { |
4799 | // This action is called when a heredoc literal _doesn't_ end | 4704 | // This action is called when a heredoc literal _doesn't_ end |
@@ -4802,16 +4707,15 @@ func scanTokens(data []byte, filename string, start hcl.Pos, mode scanMode) []To | |||
4802 | heredocs[len(heredocs)-1].StartOfLine = false | 4707 | heredocs[len(heredocs)-1].StartOfLine = false |
4803 | token(TokenStringLit) | 4708 | token(TokenStringLit) |
4804 | } | 4709 | } |
4805 | case 31: | 4710 | case 32: |
4806 | // line 1 "NONE" | 4711 | //line NONE:1 |
4807 | |||
4808 | switch act { | 4712 | switch act { |
4809 | case 0: | 4713 | case 0: |
4810 | { | 4714 | { |
4811 | cs = 0 | 4715 | cs = 0 |
4812 | goto _again | 4716 | goto _again |
4813 | } | 4717 | } |
4814 | case 10: | 4718 | case 11: |
4815 | { | 4719 | { |
4816 | p = (te) - 1 | 4720 | p = (te) - 1 |
4817 | 4721 | ||
@@ -4821,24 +4725,21 @@ func scanTokens(data []byte, filename string, start hcl.Pos, mode scanMode) []To | |||
4821 | heredocs[len(heredocs)-1].StartOfLine = false | 4725 | heredocs[len(heredocs)-1].StartOfLine = false |
4822 | token(TokenStringLit) | 4726 | token(TokenStringLit) |
4823 | } | 4727 | } |
4824 | case 11: | 4728 | case 12: |
4825 | { | 4729 | { |
4826 | p = (te) - 1 | 4730 | p = (te) - 1 |
4827 | token(TokenBadUTF8) | 4731 | token(TokenBadUTF8) |
4828 | } | 4732 | } |
4829 | } | 4733 | } |
4830 | 4734 | ||
4831 | case 32: | ||
4832 | // line 151 "scan_tokens.rl" | ||
4833 | |||
4834 | act = 14 | ||
4835 | case 33: | 4735 | case 33: |
4836 | // line 255 "scan_tokens.rl" | 4736 | //line scan_tokens.rl:156 |
4837 | |||
4838 | act = 15 | 4737 | act = 15 |
4839 | case 34: | 4738 | case 34: |
4840 | // line 155 "scan_tokens.rl" | 4739 | //line scan_tokens.rl:266 |
4841 | 4740 | act = 16 | |
4741 | case 35: | ||
4742 | //line scan_tokens.rl:160 | ||
4842 | te = p + 1 | 4743 | te = p + 1 |
4843 | { | 4744 | { |
4844 | token(TokenTemplateInterp) | 4745 | token(TokenTemplateInterp) |
@@ -4851,13 +4752,12 @@ func scanTokens(data []byte, filename string, start hcl.Pos, mode scanMode) []To | |||
4851 | stack = append(stack, 0) | 4752 | stack = append(stack, 0) |
4852 | stack[top] = cs | 4753 | stack[top] = cs |
4853 | top++ | 4754 | top++ |
4854 | cs = 1464 | 4755 | cs = 1459 |
4855 | goto _again | 4756 | goto _again |
4856 | } | 4757 | } |
4857 | } | 4758 | } |
4858 | case 35: | 4759 | case 36: |
4859 | // line 165 "scan_tokens.rl" | 4760 | //line scan_tokens.rl:170 |
4860 | |||
4861 | te = p + 1 | 4761 | te = p + 1 |
4862 | { | 4762 | { |
4863 | token(TokenTemplateControl) | 4763 | token(TokenTemplateControl) |
@@ -4870,27 +4770,24 @@ func scanTokens(data []byte, filename string, start hcl.Pos, mode scanMode) []To | |||
4870 | stack = append(stack, 0) | 4770 | stack = append(stack, 0) |
4871 | stack[top] = cs | 4771 | stack[top] = cs |
4872 | top++ | 4772 | top++ |
4873 | cs = 1464 | 4773 | cs = 1459 |
4874 | goto _again | 4774 | goto _again |
4875 | } | 4775 | } |
4876 | } | 4776 | } |
4877 | case 36: | 4777 | case 37: |
4878 | // line 151 "scan_tokens.rl" | 4778 | //line scan_tokens.rl:156 |
4879 | |||
4880 | te = p + 1 | 4779 | te = p + 1 |
4881 | { | 4780 | { |
4882 | token(TokenStringLit) | 4781 | token(TokenStringLit) |
4883 | } | 4782 | } |
4884 | case 37: | 4783 | case 38: |
4885 | // line 255 "scan_tokens.rl" | 4784 | //line scan_tokens.rl:266 |
4886 | |||
4887 | te = p + 1 | 4785 | te = p + 1 |
4888 | { | 4786 | { |
4889 | token(TokenBadUTF8) | 4787 | token(TokenBadUTF8) |
4890 | } | 4788 | } |
4891 | case 38: | 4789 | case 39: |
4892 | // line 155 "scan_tokens.rl" | 4790 | //line scan_tokens.rl:160 |
4893 | |||
4894 | te = p | 4791 | te = p |
4895 | p-- | 4792 | p-- |
4896 | { | 4793 | { |
@@ -4904,13 +4801,12 @@ func scanTokens(data []byte, filename string, start hcl.Pos, mode scanMode) []To | |||
4904 | stack = append(stack, 0) | 4801 | stack = append(stack, 0) |
4905 | stack[top] = cs | 4802 | stack[top] = cs |
4906 | top++ | 4803 | top++ |
4907 | cs = 1464 | 4804 | cs = 1459 |
4908 | goto _again | 4805 | goto _again |
4909 | } | 4806 | } |
4910 | } | 4807 | } |
4911 | case 39: | 4808 | case 40: |
4912 | // line 165 "scan_tokens.rl" | 4809 | //line scan_tokens.rl:170 |
4913 | |||
4914 | te = p | 4810 | te = p |
4915 | p-- | 4811 | p-- |
4916 | { | 4812 | { |
@@ -4924,231 +4820,191 @@ func scanTokens(data []byte, filename string, start hcl.Pos, mode scanMode) []To | |||
4924 | stack = append(stack, 0) | 4820 | stack = append(stack, 0) |
4925 | stack[top] = cs | 4821 | stack[top] = cs |
4926 | top++ | 4822 | top++ |
4927 | cs = 1464 | 4823 | cs = 1459 |
4928 | goto _again | 4824 | goto _again |
4929 | } | 4825 | } |
4930 | } | 4826 | } |
4931 | case 40: | 4827 | case 41: |
4932 | // line 151 "scan_tokens.rl" | 4828 | //line scan_tokens.rl:156 |
4933 | |||
4934 | te = p | 4829 | te = p |
4935 | p-- | 4830 | p-- |
4936 | { | 4831 | { |
4937 | token(TokenStringLit) | 4832 | token(TokenStringLit) |
4938 | } | 4833 | } |
4939 | case 41: | 4834 | case 42: |
4940 | // line 255 "scan_tokens.rl" | 4835 | //line scan_tokens.rl:266 |
4941 | |||
4942 | te = p | 4836 | te = p |
4943 | p-- | 4837 | p-- |
4944 | { | 4838 | { |
4945 | token(TokenBadUTF8) | 4839 | token(TokenBadUTF8) |
4946 | } | 4840 | } |
4947 | case 42: | 4841 | case 43: |
4948 | // line 151 "scan_tokens.rl" | 4842 | //line scan_tokens.rl:156 |
4949 | |||
4950 | p = (te) - 1 | 4843 | p = (te) - 1 |
4951 | { | 4844 | { |
4952 | token(TokenStringLit) | 4845 | token(TokenStringLit) |
4953 | } | 4846 | } |
4954 | case 43: | 4847 | case 44: |
4955 | // line 1 "NONE" | 4848 | //line NONE:1 |
4956 | |||
4957 | switch act { | 4849 | switch act { |
4958 | case 0: | 4850 | case 0: |
4959 | { | 4851 | { |
4960 | cs = 0 | 4852 | cs = 0 |
4961 | goto _again | 4853 | goto _again |
4962 | } | 4854 | } |
4963 | case 14: | 4855 | case 15: |
4964 | { | 4856 | { |
4965 | p = (te) - 1 | 4857 | p = (te) - 1 |
4966 | 4858 | ||
4967 | token(TokenStringLit) | 4859 | token(TokenStringLit) |
4968 | } | 4860 | } |
4969 | case 15: | 4861 | case 16: |
4970 | { | 4862 | { |
4971 | p = (te) - 1 | 4863 | p = (te) - 1 |
4972 | token(TokenBadUTF8) | 4864 | token(TokenBadUTF8) |
4973 | } | 4865 | } |
4974 | } | 4866 | } |
4975 | 4867 | ||
4976 | case 44: | ||
4977 | // line 259 "scan_tokens.rl" | ||
4978 | |||
4979 | act = 16 | ||
4980 | case 45: | 4868 | case 45: |
4981 | // line 260 "scan_tokens.rl" | 4869 | //line scan_tokens.rl:270 |
4982 | |||
4983 | act = 17 | 4870 | act = 17 |
4984 | case 46: | 4871 | case 46: |
4985 | // line 260 "scan_tokens.rl" | 4872 | //line scan_tokens.rl:271 |
4986 | 4873 | act = 18 | |
4874 | case 47: | ||
4875 | //line scan_tokens.rl:271 | ||
4987 | te = p + 1 | 4876 | te = p + 1 |
4988 | { | 4877 | { |
4989 | token(TokenBadUTF8) | 4878 | token(TokenBadUTF8) |
4990 | } | 4879 | } |
4991 | case 47: | 4880 | case 48: |
4992 | // line 261 "scan_tokens.rl" | 4881 | //line scan_tokens.rl:272 |
4993 | |||
4994 | te = p + 1 | 4882 | te = p + 1 |
4995 | { | 4883 | { |
4996 | token(TokenInvalid) | 4884 | token(TokenInvalid) |
4997 | } | 4885 | } |
4998 | case 48: | 4886 | case 49: |
4999 | // line 259 "scan_tokens.rl" | 4887 | //line scan_tokens.rl:270 |
5000 | |||
5001 | te = p | 4888 | te = p |
5002 | p-- | 4889 | p-- |
5003 | { | 4890 | { |
5004 | token(TokenIdent) | 4891 | token(TokenIdent) |
5005 | } | 4892 | } |
5006 | case 49: | 4893 | case 50: |
5007 | // line 260 "scan_tokens.rl" | 4894 | //line scan_tokens.rl:271 |
5008 | |||
5009 | te = p | 4895 | te = p |
5010 | p-- | 4896 | p-- |
5011 | { | 4897 | { |
5012 | token(TokenBadUTF8) | 4898 | token(TokenBadUTF8) |
5013 | } | 4899 | } |
5014 | case 50: | 4900 | case 51: |
5015 | // line 259 "scan_tokens.rl" | 4901 | //line scan_tokens.rl:270 |
5016 | |||
5017 | p = (te) - 1 | 4902 | p = (te) - 1 |
5018 | { | 4903 | { |
5019 | token(TokenIdent) | 4904 | token(TokenIdent) |
5020 | } | 4905 | } |
5021 | case 51: | 4906 | case 52: |
5022 | // line 260 "scan_tokens.rl" | 4907 | //line scan_tokens.rl:271 |
5023 | |||
5024 | p = (te) - 1 | 4908 | p = (te) - 1 |
5025 | { | 4909 | { |
5026 | token(TokenBadUTF8) | 4910 | token(TokenBadUTF8) |
5027 | } | 4911 | } |
5028 | case 52: | 4912 | case 53: |
5029 | // line 1 "NONE" | 4913 | //line NONE:1 |
5030 | |||
5031 | switch act { | 4914 | switch act { |
5032 | case 16: | 4915 | case 17: |
5033 | { | 4916 | { |
5034 | p = (te) - 1 | 4917 | p = (te) - 1 |
5035 | token(TokenIdent) | 4918 | token(TokenIdent) |
5036 | } | 4919 | } |
5037 | case 17: | 4920 | case 18: |
5038 | { | 4921 | { |
5039 | p = (te) - 1 | 4922 | p = (te) - 1 |
5040 | token(TokenBadUTF8) | 4923 | token(TokenBadUTF8) |
5041 | } | 4924 | } |
5042 | } | 4925 | } |
5043 | 4926 | ||
5044 | case 53: | ||
5045 | // line 267 "scan_tokens.rl" | ||
5046 | |||
5047 | act = 21 | ||
5048 | case 54: | 4927 | case 54: |
5049 | // line 269 "scan_tokens.rl" | 4928 | //line scan_tokens.rl:278 |
5050 | |||
5051 | act = 22 | 4929 | act = 22 |
5052 | case 55: | 4930 | case 55: |
5053 | // line 280 "scan_tokens.rl" | 4931 | //line scan_tokens.rl:301 |
5054 | |||
5055 | act = 32 | ||
5056 | case 56: | ||
5057 | // line 290 "scan_tokens.rl" | ||
5058 | |||
5059 | act = 38 | ||
5060 | case 57: | ||
5061 | // line 291 "scan_tokens.rl" | ||
5062 | |||
5063 | act = 39 | 4932 | act = 39 |
5064 | case 58: | 4933 | case 56: |
5065 | // line 269 "scan_tokens.rl" | 4934 | //line scan_tokens.rl:280 |
5066 | |||
5067 | te = p + 1 | 4935 | te = p + 1 |
5068 | { | 4936 | { |
5069 | token(TokenComment) | 4937 | token(TokenComment) |
5070 | } | 4938 | } |
5071 | case 59: | 4939 | case 57: |
5072 | // line 270 "scan_tokens.rl" | 4940 | //line scan_tokens.rl:281 |
5073 | |||
5074 | te = p + 1 | 4941 | te = p + 1 |
5075 | { | 4942 | { |
5076 | token(TokenNewline) | 4943 | token(TokenNewline) |
5077 | } | 4944 | } |
5078 | case 60: | 4945 | case 58: |
5079 | // line 272 "scan_tokens.rl" | 4946 | //line scan_tokens.rl:283 |
5080 | |||
5081 | te = p + 1 | 4947 | te = p + 1 |
5082 | { | 4948 | { |
5083 | token(TokenEqualOp) | 4949 | token(TokenEqualOp) |
5084 | } | 4950 | } |
5085 | case 61: | 4951 | case 59: |
5086 | // line 273 "scan_tokens.rl" | 4952 | //line scan_tokens.rl:284 |
5087 | |||
5088 | te = p + 1 | 4953 | te = p + 1 |
5089 | { | 4954 | { |
5090 | token(TokenNotEqual) | 4955 | token(TokenNotEqual) |
5091 | } | 4956 | } |
5092 | case 62: | 4957 | case 60: |
5093 | // line 274 "scan_tokens.rl" | 4958 | //line scan_tokens.rl:285 |
5094 | |||
5095 | te = p + 1 | 4959 | te = p + 1 |
5096 | { | 4960 | { |
5097 | token(TokenGreaterThanEq) | 4961 | token(TokenGreaterThanEq) |
5098 | } | 4962 | } |
5099 | case 63: | 4963 | case 61: |
5100 | // line 275 "scan_tokens.rl" | 4964 | //line scan_tokens.rl:286 |
5101 | |||
5102 | te = p + 1 | 4965 | te = p + 1 |
5103 | { | 4966 | { |
5104 | token(TokenLessThanEq) | 4967 | token(TokenLessThanEq) |
5105 | } | 4968 | } |
5106 | case 64: | 4969 | case 62: |
5107 | // line 276 "scan_tokens.rl" | 4970 | //line scan_tokens.rl:287 |
5108 | |||
5109 | te = p + 1 | 4971 | te = p + 1 |
5110 | { | 4972 | { |
5111 | token(TokenAnd) | 4973 | token(TokenAnd) |
5112 | } | 4974 | } |
5113 | case 65: | 4975 | case 63: |
5114 | // line 277 "scan_tokens.rl" | 4976 | //line scan_tokens.rl:288 |
5115 | |||
5116 | te = p + 1 | 4977 | te = p + 1 |
5117 | { | 4978 | { |
5118 | token(TokenOr) | 4979 | token(TokenOr) |
5119 | } | 4980 | } |
5120 | case 66: | 4981 | case 64: |
5121 | // line 278 "scan_tokens.rl" | 4982 | //line scan_tokens.rl:289 |
5122 | |||
5123 | te = p + 1 | 4983 | te = p + 1 |
5124 | { | 4984 | { |
5125 | token(TokenEllipsis) | 4985 | token(TokenEllipsis) |
5126 | } | 4986 | } |
5127 | case 67: | 4987 | case 65: |
5128 | // line 279 "scan_tokens.rl" | 4988 | //line scan_tokens.rl:290 |
5129 | |||
5130 | te = p + 1 | 4989 | te = p + 1 |
5131 | { | 4990 | { |
5132 | token(TokenFatArrow) | 4991 | token(TokenFatArrow) |
5133 | } | 4992 | } |
5134 | case 68: | 4993 | case 66: |
5135 | // line 280 "scan_tokens.rl" | 4994 | //line scan_tokens.rl:291 |
5136 | |||
5137 | te = p + 1 | 4995 | te = p + 1 |
5138 | { | 4996 | { |
5139 | selfToken() | 4997 | selfToken() |
5140 | } | 4998 | } |
5141 | case 69: | 4999 | case 67: |
5142 | // line 175 "scan_tokens.rl" | 5000 | //line scan_tokens.rl:180 |
5143 | |||
5144 | te = p + 1 | 5001 | te = p + 1 |
5145 | { | 5002 | { |
5146 | token(TokenOBrace) | 5003 | token(TokenOBrace) |
5147 | braces++ | 5004 | braces++ |
5148 | } | 5005 | } |
5149 | case 70: | 5006 | case 68: |
5150 | // line 180 "scan_tokens.rl" | 5007 | //line scan_tokens.rl:185 |
5151 | |||
5152 | te = p + 1 | 5008 | te = p + 1 |
5153 | { | 5009 | { |
5154 | if len(retBraces) > 0 && retBraces[len(retBraces)-1] == braces { | 5010 | if len(retBraces) > 0 && retBraces[len(retBraces)-1] == braces { |
@@ -5167,9 +5023,8 @@ func scanTokens(data []byte, filename string, start hcl.Pos, mode scanMode) []To | |||
5167 | braces-- | 5023 | braces-- |
5168 | } | 5024 | } |
5169 | } | 5025 | } |
5170 | case 71: | 5026 | case 69: |
5171 | // line 192 "scan_tokens.rl" | 5027 | //line scan_tokens.rl:197 |
5172 | |||
5173 | te = p + 1 | 5028 | te = p + 1 |
5174 | { | 5029 | { |
5175 | // Only consume from the retBraces stack and return if we are at | 5030 | // Only consume from the retBraces stack and return if we are at |
@@ -5197,9 +5052,8 @@ func scanTokens(data []byte, filename string, start hcl.Pos, mode scanMode) []To | |||
5197 | braces-- | 5052 | braces-- |
5198 | } | 5053 | } |
5199 | } | 5054 | } |
5200 | case 72: | 5055 | case 70: |
5201 | // line 74 "scan_tokens.rl" | 5056 | //line scan_tokens.rl:79 |
5202 | |||
5203 | te = p + 1 | 5057 | te = p + 1 |
5204 | { | 5058 | { |
5205 | token(TokenOQuote) | 5059 | token(TokenOQuote) |
@@ -5207,13 +5061,12 @@ func scanTokens(data []byte, filename string, start hcl.Pos, mode scanMode) []To | |||
5207 | stack = append(stack, 0) | 5061 | stack = append(stack, 0) |
5208 | stack[top] = cs | 5062 | stack[top] = cs |
5209 | top++ | 5063 | top++ |
5210 | cs = 1515 | 5064 | cs = 1509 |
5211 | goto _again | 5065 | goto _again |
5212 | } | 5066 | } |
5213 | } | 5067 | } |
5214 | case 73: | 5068 | case 71: |
5215 | // line 84 "scan_tokens.rl" | 5069 | //line scan_tokens.rl:89 |
5216 | |||
5217 | te = p + 1 | 5070 | te = p + 1 |
5218 | { | 5071 | { |
5219 | token(TokenOHeredoc) | 5072 | token(TokenOHeredoc) |
@@ -5238,138 +5091,109 @@ func scanTokens(data []byte, filename string, start hcl.Pos, mode scanMode) []To | |||
5238 | stack = append(stack, 0) | 5091 | stack = append(stack, 0) |
5239 | stack[top] = cs | 5092 | stack[top] = cs |
5240 | top++ | 5093 | top++ |
5241 | cs = 1541 | 5094 | cs = 1523 |
5242 | goto _again | 5095 | goto _again |
5243 | } | 5096 | } |
5244 | } | 5097 | } |
5245 | case 74: | 5098 | case 72: |
5246 | // line 290 "scan_tokens.rl" | 5099 | //line scan_tokens.rl:301 |
5247 | |||
5248 | te = p + 1 | 5100 | te = p + 1 |
5249 | { | 5101 | { |
5250 | token(TokenBadUTF8) | 5102 | token(TokenBadUTF8) |
5251 | } | 5103 | } |
5252 | case 75: | 5104 | case 73: |
5253 | // line 291 "scan_tokens.rl" | 5105 | //line scan_tokens.rl:302 |
5254 | |||
5255 | te = p + 1 | 5106 | te = p + 1 |
5256 | { | 5107 | { |
5257 | token(TokenInvalid) | 5108 | token(TokenInvalid) |
5258 | } | 5109 | } |
5259 | case 76: | 5110 | case 74: |
5260 | // line 265 "scan_tokens.rl" | 5111 | //line scan_tokens.rl:276 |
5261 | |||
5262 | te = p | 5112 | te = p |
5263 | p-- | 5113 | p-- |
5264 | 5114 | ||
5265 | case 77: | 5115 | case 75: |
5266 | // line 266 "scan_tokens.rl" | 5116 | //line scan_tokens.rl:277 |
5267 | |||
5268 | te = p | 5117 | te = p |
5269 | p-- | 5118 | p-- |
5270 | { | 5119 | { |
5271 | token(TokenNumberLit) | 5120 | token(TokenNumberLit) |
5272 | } | 5121 | } |
5273 | case 78: | 5122 | case 76: |
5274 | // line 267 "scan_tokens.rl" | 5123 | //line scan_tokens.rl:278 |
5275 | |||
5276 | te = p | 5124 | te = p |
5277 | p-- | 5125 | p-- |
5278 | { | 5126 | { |
5279 | token(TokenIdent) | 5127 | token(TokenIdent) |
5280 | } | 5128 | } |
5281 | case 79: | 5129 | case 77: |
5282 | // line 269 "scan_tokens.rl" | 5130 | //line scan_tokens.rl:280 |
5283 | |||
5284 | te = p | 5131 | te = p |
5285 | p-- | 5132 | p-- |
5286 | { | 5133 | { |
5287 | token(TokenComment) | 5134 | token(TokenComment) |
5288 | } | 5135 | } |
5289 | case 80: | 5136 | case 78: |
5290 | // line 280 "scan_tokens.rl" | 5137 | //line scan_tokens.rl:291 |
5291 | |||
5292 | te = p | 5138 | te = p |
5293 | p-- | 5139 | p-- |
5294 | { | 5140 | { |
5295 | selfToken() | 5141 | selfToken() |
5296 | } | 5142 | } |
5297 | case 81: | 5143 | case 79: |
5298 | // line 290 "scan_tokens.rl" | 5144 | //line scan_tokens.rl:301 |
5299 | |||
5300 | te = p | 5145 | te = p |
5301 | p-- | 5146 | p-- |
5302 | { | 5147 | { |
5303 | token(TokenBadUTF8) | 5148 | token(TokenBadUTF8) |
5304 | } | 5149 | } |
5305 | case 82: | 5150 | case 80: |
5306 | // line 291 "scan_tokens.rl" | 5151 | //line scan_tokens.rl:302 |
5307 | |||
5308 | te = p | 5152 | te = p |
5309 | p-- | 5153 | p-- |
5310 | { | 5154 | { |
5311 | token(TokenInvalid) | 5155 | token(TokenInvalid) |
5312 | } | 5156 | } |
5313 | case 83: | 5157 | case 81: |
5314 | // line 266 "scan_tokens.rl" | 5158 | //line scan_tokens.rl:277 |
5315 | |||
5316 | p = (te) - 1 | 5159 | p = (te) - 1 |
5317 | { | 5160 | { |
5318 | token(TokenNumberLit) | 5161 | token(TokenNumberLit) |
5319 | } | 5162 | } |
5320 | case 84: | 5163 | case 82: |
5321 | // line 267 "scan_tokens.rl" | 5164 | //line scan_tokens.rl:278 |
5322 | |||
5323 | p = (te) - 1 | 5165 | p = (te) - 1 |
5324 | { | 5166 | { |
5325 | token(TokenIdent) | 5167 | token(TokenIdent) |
5326 | } | 5168 | } |
5327 | case 85: | 5169 | case 83: |
5328 | // line 280 "scan_tokens.rl" | 5170 | //line scan_tokens.rl:291 |
5329 | |||
5330 | p = (te) - 1 | 5171 | p = (te) - 1 |
5331 | { | 5172 | { |
5332 | selfToken() | 5173 | selfToken() |
5333 | } | 5174 | } |
5334 | case 86: | 5175 | case 84: |
5335 | // line 290 "scan_tokens.rl" | 5176 | //line scan_tokens.rl:301 |
5336 | |||
5337 | p = (te) - 1 | 5177 | p = (te) - 1 |
5338 | { | 5178 | { |
5339 | token(TokenBadUTF8) | 5179 | token(TokenBadUTF8) |
5340 | } | 5180 | } |
5341 | case 87: | 5181 | case 85: |
5342 | // line 1 "NONE" | 5182 | //line NONE:1 |
5343 | |||
5344 | switch act { | 5183 | switch act { |
5345 | case 21: | ||
5346 | { | ||
5347 | p = (te) - 1 | ||
5348 | token(TokenIdent) | ||
5349 | } | ||
5350 | case 22: | 5184 | case 22: |
5351 | { | 5185 | { |
5352 | p = (te) - 1 | 5186 | p = (te) - 1 |
5353 | token(TokenComment) | 5187 | token(TokenIdent) |
5354 | } | ||
5355 | case 32: | ||
5356 | { | ||
5357 | p = (te) - 1 | ||
5358 | selfToken() | ||
5359 | } | ||
5360 | case 38: | ||
5361 | { | ||
5362 | p = (te) - 1 | ||
5363 | token(TokenBadUTF8) | ||
5364 | } | 5188 | } |
5365 | case 39: | 5189 | case 39: |
5366 | { | 5190 | { |
5367 | p = (te) - 1 | 5191 | p = (te) - 1 |
5368 | token(TokenInvalid) | 5192 | token(TokenBadUTF8) |
5369 | } | 5193 | } |
5370 | } | 5194 | } |
5371 | 5195 | ||
5372 | // line 5232 "scan_tokens.go" | 5196 | //line scan_tokens.go:5055 |
5373 | } | 5197 | } |
5374 | } | 5198 | } |
5375 | 5199 | ||
@@ -5380,17 +5204,15 @@ func scanTokens(data []byte, filename string, start hcl.Pos, mode scanMode) []To | |||
5380 | for ; _nacts > 0; _nacts-- { | 5204 | for ; _nacts > 0; _nacts-- { |
5381 | _acts++ | 5205 | _acts++ |
5382 | switch _hcltok_actions[_acts-1] { | 5206 | switch _hcltok_actions[_acts-1] { |
5383 | case 4: | 5207 | case 1: |
5384 | // line 1 "NONE" | 5208 | //line NONE:1 |
5385 | |||
5386 | ts = 0 | 5209 | ts = 0 |
5387 | 5210 | ||
5388 | case 5: | 5211 | case 2: |
5389 | // line 1 "NONE" | 5212 | //line NONE:1 |
5390 | |||
5391 | act = 0 | 5213 | act = 0 |
5392 | 5214 | ||
5393 | // line 5252 "scan_tokens.go" | 5215 | //line scan_tokens.go:5073 |
5394 | } | 5216 | } |
5395 | } | 5217 | } |
5396 | 5218 | ||
@@ -5416,7 +5238,7 @@ func scanTokens(data []byte, filename string, start hcl.Pos, mode scanMode) []To | |||
5416 | } | 5238 | } |
5417 | } | 5239 | } |
5418 | 5240 | ||
5419 | // line 352 "scan_tokens.rl" | 5241 | //line scan_tokens.rl:363 |
5420 | 5242 | ||
5421 | // If we fall out here without being in a final state then we've | 5243 | // If we fall out here without being in a final state then we've |
5422 | // encountered something that the scanner can't match, which we'll | 5244 | // encountered something that the scanner can't match, which we'll |
diff --git a/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/scan_tokens.rl b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/scan_tokens.rl index 83ef65b..4443dc4 100644 --- a/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/scan_tokens.rl +++ b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/scan_tokens.rl | |||
@@ -9,17 +9,22 @@ import ( | |||
9 | 9 | ||
10 | // This file is generated from scan_tokens.rl. DO NOT EDIT. | 10 | // This file is generated from scan_tokens.rl. DO NOT EDIT. |
11 | %%{ | 11 | %%{ |
12 | # (except you are actually in scan_tokens.rl here, so edit away!) | 12 | # (except when you are actually in scan_tokens.rl here, so edit away!) |
13 | 13 | ||
14 | machine hcltok; | 14 | machine hcltok; |
15 | write data; | 15 | write data; |
16 | }%% | 16 | }%% |
17 | 17 | ||
18 | func scanTokens(data []byte, filename string, start hcl.Pos, mode scanMode) []Token { | 18 | func scanTokens(data []byte, filename string, start hcl.Pos, mode scanMode) []Token { |
19 | stripData := stripUTF8BOM(data) | ||
20 | start.Byte += len(data) - len(stripData) | ||
21 | data = stripData | ||
22 | |||
19 | f := &tokenAccum{ | 23 | f := &tokenAccum{ |
20 | Filename: filename, | 24 | Filename: filename, |
21 | Bytes: data, | 25 | Bytes: data, |
22 | Pos: start, | 26 | Pos: start, |
27 | StartByte: start.Byte, | ||
23 | } | 28 | } |
24 | 29 | ||
25 | %%{ | 30 | %%{ |
@@ -39,7 +44,7 @@ func scanTokens(data []byte, filename string, start hcl.Pos, mode scanMode) []To | |||
39 | Ident = (ID_Start | '_') (ID_Continue | '-')*; | 44 | Ident = (ID_Start | '_') (ID_Continue | '-')*; |
40 | 45 | ||
41 | # Symbols that just represent themselves are handled as a single rule. | 46 | # Symbols that just represent themselves are handled as a single rule. |
42 | SelfToken = "[" | "]" | "(" | ")" | "." | "," | "*" | "/" | "%" | "+" | "-" | "=" | "<" | ">" | "!" | "?" | ":" | "\n" | "&" | "|" | "~" | "^" | ";" | "`"; | 47 | SelfToken = "[" | "]" | "(" | ")" | "." | "," | "*" | "/" | "%" | "+" | "-" | "=" | "<" | ">" | "!" | "?" | ":" | "\n" | "&" | "|" | "~" | "^" | ";" | "`" | "'"; |
43 | 48 | ||
44 | EqualOp = "=="; | 49 | EqualOp = "=="; |
45 | NotEqual = "!="; | 50 | NotEqual = "!="; |
@@ -58,9 +63,17 @@ func scanTokens(data []byte, filename string, start hcl.Pos, mode scanMode) []To | |||
58 | BeginHeredocTmpl = '<<' ('-')? Ident Newline; | 63 | BeginHeredocTmpl = '<<' ('-')? Ident Newline; |
59 | 64 | ||
60 | Comment = ( | 65 | Comment = ( |
61 | ("#" (any - EndOfLine)* EndOfLine) | | 66 | # The :>> operator in these is a "finish-guarded concatenation", |
62 | ("//" (any - EndOfLine)* EndOfLine) | | 67 | # which terminates the sequence on its left when it completes |
63 | ("/*" any* "*/") | 68 | # the sequence on its right. |
69 | # In the single-line comment cases this is allowing us to make | ||
70 | # the trailing EndOfLine optional while still having the overall | ||
71 | # pattern terminate. In the multi-line case it ensures that | ||
72 | # the first comment in the file ends at the first */, rather than | ||
73 | # gobbling up all of the "any*" until the _final_ */ in the file. | ||
74 | ("#" (any - EndOfLine)* :>> EndOfLine?) | | ||
75 | ("//" (any - EndOfLine)* :>> EndOfLine?) | | ||
76 | ("/*" any* :>> "*/") | ||
64 | ); | 77 | ); |
65 | 78 | ||
66 | # Note: hclwrite assumes that only ASCII spaces appear between tokens, | 79 | # Note: hclwrite assumes that only ASCII spaces appear between tokens, |
@@ -213,29 +226,35 @@ func scanTokens(data []byte, filename string, start hcl.Pos, mode scanMode) []To | |||
213 | TemplateInterp = "${" ("~")?; | 226 | TemplateInterp = "${" ("~")?; |
214 | TemplateControl = "%{" ("~")?; | 227 | TemplateControl = "%{" ("~")?; |
215 | EndStringTmpl = '"'; | 228 | EndStringTmpl = '"'; |
216 | StringLiteralChars = (AnyUTF8 - ("\r"|"\n")); | 229 | NewlineChars = ("\r"|"\n"); |
230 | NewlineCharsSeq = NewlineChars+; | ||
231 | StringLiteralChars = (AnyUTF8 - NewlineChars); | ||
232 | TemplateIgnoredNonBrace = (^'{' %{ fhold; }); | ||
233 | TemplateNotInterp = '$' (TemplateIgnoredNonBrace | TemplateInterp); | ||
234 | TemplateNotControl = '%' (TemplateIgnoredNonBrace | TemplateControl); | ||
235 | QuotedStringLiteralWithEsc = ('\\' StringLiteralChars) | (StringLiteralChars - ("$" | '%' | '"' | "\\")); | ||
217 | TemplateStringLiteral = ( | 236 | TemplateStringLiteral = ( |
218 | ('$' ^'{' %{ fhold; }) | | 237 | (TemplateNotInterp) | |
219 | ('%' ^'{' %{ fhold; }) | | 238 | (TemplateNotControl) | |
220 | ('\\' StringLiteralChars) | | 239 | (QuotedStringLiteralWithEsc)+ |
221 | (StringLiteralChars - ("$" | '%' | '"')) | 240 | ); |
222 | )+; | ||
223 | HeredocStringLiteral = ( | 241 | HeredocStringLiteral = ( |
224 | ('$' ^'{' %{ fhold; }) | | 242 | (TemplateNotInterp) | |
225 | ('%' ^'{' %{ fhold; }) | | 243 | (TemplateNotControl) | |
226 | (StringLiteralChars - ("$" | '%')) | 244 | (StringLiteralChars - ("$" | '%'))* |
227 | )*; | 245 | ); |
228 | BareStringLiteral = ( | 246 | BareStringLiteral = ( |
229 | ('$' ^'{') | | 247 | (TemplateNotInterp) | |
230 | ('%' ^'{') | | 248 | (TemplateNotControl) | |
231 | (StringLiteralChars - ("$" | '%')) | 249 | (StringLiteralChars - ("$" | '%'))* |
232 | )* Newline?; | 250 | ) Newline?; |
233 | 251 | ||
234 | stringTemplate := |* | 252 | stringTemplate := |* |
235 | TemplateInterp => beginTemplateInterp; | 253 | TemplateInterp => beginTemplateInterp; |
236 | TemplateControl => beginTemplateControl; | 254 | TemplateControl => beginTemplateControl; |
237 | EndStringTmpl => endStringTemplate; | 255 | EndStringTmpl => endStringTemplate; |
238 | TemplateStringLiteral => { token(TokenQuotedLit); }; | 256 | TemplateStringLiteral => { token(TokenQuotedLit); }; |
257 | NewlineCharsSeq => { token(TokenQuotedNewline); }; | ||
239 | AnyUTF8 => { token(TokenInvalid); }; | 258 | AnyUTF8 => { token(TokenInvalid); }; |
240 | BrokenUTF8 => { token(TokenBadUTF8); }; | 259 | BrokenUTF8 => { token(TokenBadUTF8); }; |
241 | *|; | 260 | *|; |
diff --git a/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/spec.md b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/spec.md index 49b9a3e..091c1c2 100644 --- a/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/spec.md +++ b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/spec.md | |||
@@ -4,18 +4,18 @@ This is the specification of the syntax and semantics of the native syntax | |||
4 | for HCL. HCL is a system for defining configuration languages for applications. | 4 | for HCL. HCL is a system for defining configuration languages for applications. |
5 | The HCL information model is designed to support multiple concrete syntaxes | 5 | The HCL information model is designed to support multiple concrete syntaxes |
6 | for configuration, but this native syntax is considered the primary format | 6 | for configuration, but this native syntax is considered the primary format |
7 | and is optimized for human authoring and maintenence, as opposed to machine | 7 | and is optimized for human authoring and maintenance, as opposed to machine |
8 | generation of configuration. | 8 | generation of configuration. |
9 | 9 | ||
10 | The language consists of three integrated sub-languages: | 10 | The language consists of three integrated sub-languages: |
11 | 11 | ||
12 | * The _structural_ language defines the overall heirarchical configuration | 12 | - The _structural_ language defines the overall hierarchical configuration |
13 | structure, and is a serialization of HCL bodies, blocks and attributes. | 13 | structure, and is a serialization of HCL bodies, blocks and attributes. |
14 | 14 | ||
15 | * The _expression_ language is used to express attribute values, either as | 15 | - The _expression_ language is used to express attribute values, either as |
16 | literals or as derivations of other values. | 16 | literals or as derivations of other values. |
17 | 17 | ||
18 | * The _template_ language is used to compose values together into strings, | 18 | - The _template_ language is used to compose values together into strings, |
19 | as one of several types of expression in the expression language. | 19 | as one of several types of expression in the expression language. |
20 | 20 | ||
21 | In normal use these three sub-languages are used together within configuration | 21 | In normal use these three sub-languages are used together within configuration |
@@ -30,19 +30,19 @@ Within this specification a semi-formal notation is used to illustrate the | |||
30 | details of syntax. This notation is intended for human consumption rather | 30 | details of syntax. This notation is intended for human consumption rather |
31 | than machine consumption, with the following conventions: | 31 | than machine consumption, with the following conventions: |
32 | 32 | ||
33 | * A naked name starting with an uppercase letter is a global production, | 33 | - A naked name starting with an uppercase letter is a global production, |
34 | common to all of the syntax specifications in this document. | 34 | common to all of the syntax specifications in this document. |
35 | * A naked name starting with a lowercase letter is a local production, | 35 | - A naked name starting with a lowercase letter is a local production, |
36 | meaningful only within the specification where it is defined. | 36 | meaningful only within the specification where it is defined. |
37 | * Double and single quotes (`"` and `'`) are used to mark literal character | 37 | - Double and single quotes (`"` and `'`) are used to mark literal character |
38 | sequences, which may be either punctuation markers or keywords. | 38 | sequences, which may be either punctuation markers or keywords. |
39 | * The default operator for combining items, which has no punctuation, | 39 | - The default operator for combining items, which has no punctuation, |
40 | is concatenation. | 40 | is concatenation. |
41 | * The symbol `|` indicates that any one of its left and right operands may | 41 | - The symbol `|` indicates that any one of its left and right operands may |
42 | be present. | 42 | be present. |
43 | * The `*` symbol indicates zero or more repetitions of the item to its left. | 43 | - The `*` symbol indicates zero or more repetitions of the item to its left. |
44 | * The `?` symbol indicates zero or one of the item to its left. | 44 | - The `?` symbol indicates zero or one of the item to its left. |
45 | * Parentheses (`(` and `)`) are used to group items together to apply | 45 | - Parentheses (`(` and `)`) are used to group items together to apply |
46 | the `|`, `*` and `?` operators to them collectively. | 46 | the `|`, `*` and `?` operators to them collectively. |
47 | 47 | ||
48 | The grammar notation does not fully describe the language. The prose may | 48 | The grammar notation does not fully describe the language. The prose may |
@@ -77,11 +77,11 @@ are not valid within HCL native syntax. | |||
77 | 77 | ||
78 | Comments serve as program documentation and come in two forms: | 78 | Comments serve as program documentation and come in two forms: |
79 | 79 | ||
80 | * _Line comments_ start with either the `//` or `#` sequences and end with | 80 | - _Line comments_ start with either the `//` or `#` sequences and end with |
81 | the next newline sequence. A line comments is considered equivalent to a | 81 | the next newline sequence. A line comments is considered equivalent to a |
82 | newline sequence. | 82 | newline sequence. |
83 | 83 | ||
84 | * _Inline comments_ start with the `/*` sequence and end with the `*/` | 84 | - _Inline comments_ start with the `/*` sequence and end with the `*/` |
85 | sequence, and may have any characters within except the ending sequence. | 85 | sequence, and may have any characters within except the ending sequence. |
86 | An inline comments is considered equivalent to a whitespace sequence. | 86 | An inline comments is considered equivalent to a whitespace sequence. |
87 | 87 | ||
@@ -91,7 +91,7 @@ template literals except inside an interpolation sequence or template directive. | |||
91 | ### Identifiers | 91 | ### Identifiers |
92 | 92 | ||
93 | Identifiers name entities such as blocks, attributes and expression variables. | 93 | Identifiers name entities such as blocks, attributes and expression variables. |
94 | Identifiers are interpreted as per [UAX #31][UAX31] Section 2. Specifically, | 94 | Identifiers are interpreted as per [UAX #31][uax31] Section 2. Specifically, |
95 | their syntax is defined in terms of the `ID_Start` and `ID_Continue` | 95 | their syntax is defined in terms of the `ID_Start` and `ID_Continue` |
96 | character properties as follows: | 96 | character properties as follows: |
97 | 97 | ||
@@ -109,7 +109,7 @@ that is not part of the unicode `ID_Continue` definition. This is to allow | |||
109 | attribute names and block type names to contain dashes, although underscores | 109 | attribute names and block type names to contain dashes, although underscores |
110 | as word separators are considered the idiomatic usage. | 110 | as word separators are considered the idiomatic usage. |
111 | 111 | ||
112 | [UAX31]: http://unicode.org/reports/tr31/ "Unicode Identifier and Pattern Syntax" | 112 | [uax31]: http://unicode.org/reports/tr31/ "Unicode Identifier and Pattern Syntax" |
113 | 113 | ||
114 | ### Keywords | 114 | ### Keywords |
115 | 115 | ||
@@ -150,18 +150,19 @@ expmark = ('e' | 'E') ("+" | "-")?; | |||
150 | The structural language consists of syntax representing the following | 150 | The structural language consists of syntax representing the following |
151 | constructs: | 151 | constructs: |
152 | 152 | ||
153 | * _Attributes_, which assign a value to a specified name. | 153 | - _Attributes_, which assign a value to a specified name. |
154 | * _Blocks_, which create a child body annotated by a type and optional labels. | 154 | - _Blocks_, which create a child body annotated by a type and optional labels. |
155 | * _Body Content_, which consists of a collection of attributes and blocks. | 155 | - _Body Content_, which consists of a collection of attributes and blocks. |
156 | 156 | ||
157 | These constructs correspond to the similarly-named concepts in the | 157 | These constructs correspond to the similarly-named concepts in the |
158 | language-agnostic HCL information model. | 158 | language-agnostic HCL information model. |
159 | 159 | ||
160 | ```ebnf | 160 | ```ebnf |
161 | ConfigFile = Body; | 161 | ConfigFile = Body; |
162 | Body = (Attribute | Block)*; | 162 | Body = (Attribute | Block | OneLineBlock)*; |
163 | Attribute = Identifier "=" Expression Newline; | 163 | Attribute = Identifier "=" Expression Newline; |
164 | Block = Identifier (StringLit|Identifier)* "{" Newline Body "}" Newline; | 164 | Block = Identifier (StringLit|Identifier)* "{" Newline Body "}" Newline; |
165 | OneLineBlock = Identifier (StringLit|Identifier)* "{" (Identifier "=" Expression)? "}" Newline; | ||
165 | ``` | 166 | ``` |
166 | 167 | ||
167 | ### Configuration Files | 168 | ### Configuration Files |
@@ -186,7 +187,7 @@ for later evaluation by the calling application. | |||
186 | ### Blocks | 187 | ### Blocks |
187 | 188 | ||
188 | A _block_ creates a child body that is annotated with a block _type_ and | 189 | A _block_ creates a child body that is annotated with a block _type_ and |
189 | zero or more block _labels_. Blocks create a structural heirachy which can be | 190 | zero or more block _labels_. Blocks create a structural hierachy which can be |
190 | interpreted by the calling application. | 191 | interpreted by the calling application. |
191 | 192 | ||
192 | Block labels can either be quoted literal strings or naked identifiers. | 193 | Block labels can either be quoted literal strings or naked identifiers. |
@@ -252,9 +253,9 @@ LiteralValue = ( | |||
252 | ); | 253 | ); |
253 | ``` | 254 | ``` |
254 | 255 | ||
255 | * Numeric literals represent values of type _number_. | 256 | - Numeric literals represent values of type _number_. |
256 | * The `true` and `false` keywords represent values of type _bool_. | 257 | - The `true` and `false` keywords represent values of type _bool_. |
257 | * The `null` keyword represents a null value of the dynamic pseudo-type. | 258 | - The `null` keyword represents a null value of the dynamic pseudo-type. |
258 | 259 | ||
259 | String literals are not directly available in the expression sub-language, but | 260 | String literals are not directly available in the expression sub-language, but |
260 | are available via the template sub-language, which can in turn be incorporated | 261 | are available via the template sub-language, which can in turn be incorporated |
@@ -285,8 +286,8 @@ When specifying an object element, an identifier is interpreted as a literal | |||
285 | attribute name as opposed to a variable reference. To populate an item key | 286 | attribute name as opposed to a variable reference. To populate an item key |
286 | from a variable, use parentheses to disambiguate: | 287 | from a variable, use parentheses to disambiguate: |
287 | 288 | ||
288 | * `{foo = "baz"}` is interpreted as an attribute literally named `foo`. | 289 | - `{foo = "baz"}` is interpreted as an attribute literally named `foo`. |
289 | * `{(foo) = "baz"}` is interpreted as an attribute whose name is taken | 290 | - `{(foo) = "baz"}` is interpreted as an attribute whose name is taken |
290 | from the variable named `foo`. | 291 | from the variable named `foo`. |
291 | 292 | ||
292 | Between the open and closing delimiters of these sequences, newline sequences | 293 | Between the open and closing delimiters of these sequences, newline sequences |
@@ -296,14 +297,14 @@ There is a syntax ambiguity between _for expressions_ and collection values | |||
296 | whose first element is a reference to a variable named `for`. The | 297 | whose first element is a reference to a variable named `for`. The |
297 | _for expression_ interpretation has priority, so to produce a tuple whose | 298 | _for expression_ interpretation has priority, so to produce a tuple whose |
298 | first element is the value of a variable named `for`, or an object with a | 299 | first element is the value of a variable named `for`, or an object with a |
299 | key named `for`, use paretheses to disambiguate: | 300 | key named `for`, use parentheses to disambiguate: |
300 | 301 | ||
301 | * `[for, foo, baz]` is a syntax error. | 302 | - `[for, foo, baz]` is a syntax error. |
302 | * `[(for), foo, baz]` is a tuple whose first element is the value of variable | 303 | - `[(for), foo, baz]` is a tuple whose first element is the value of variable |
303 | `for`. | 304 | `for`. |
304 | * `{for: 1, baz: 2}` is a syntax error. | 305 | - `{for: 1, baz: 2}` is a syntax error. |
305 | * `{(for): 1, baz: 2}` is an object with an attribute literally named `for`. | 306 | - `{(for): 1, baz: 2}` is an object with an attribute literally named `for`. |
306 | * `{baz: 2, for: 1}` is equivalent to the previous example, and resolves the | 307 | - `{baz: 2, for: 1}` is equivalent to the previous example, and resolves the |
307 | ambiguity by reordering. | 308 | ambiguity by reordering. |
308 | 309 | ||
309 | ### Template Expressions | 310 | ### Template Expressions |
@@ -311,9 +312,9 @@ key named `for`, use paretheses to disambiguate: | |||
311 | A _template expression_ embeds a program written in the template sub-language | 312 | A _template expression_ embeds a program written in the template sub-language |
312 | as an expression. Template expressions come in two forms: | 313 | as an expression. Template expressions come in two forms: |
313 | 314 | ||
314 | * A _quoted_ template expression is delimited by quote characters (`"`) and | 315 | - A _quoted_ template expression is delimited by quote characters (`"`) and |
315 | defines a template as a single-line expression with escape characters. | 316 | defines a template as a single-line expression with escape characters. |
316 | * A _heredoc_ template expression is introduced by a `<<` sequence and | 317 | - A _heredoc_ template expression is introduced by a `<<` sequence and |
317 | defines a template via a multi-line sequence terminated by a user-chosen | 318 | defines a template via a multi-line sequence terminated by a user-chosen |
318 | delimiter. | 319 | delimiter. |
319 | 320 | ||
@@ -321,7 +322,7 @@ In both cases the template interpolation and directive syntax is available for | |||
321 | use within the delimiters, and any text outside of these special sequences is | 322 | use within the delimiters, and any text outside of these special sequences is |
322 | interpreted as a literal string. | 323 | interpreted as a literal string. |
323 | 324 | ||
324 | In _quoted_ template expressions any literal string sequences within the | 325 | In _quoted_ template expressions any literal string sequences within the |
325 | template behave in a special way: literal newline sequences are not permitted | 326 | template behave in a special way: literal newline sequences are not permitted |
326 | and instead _escape sequences_ can be included, starting with the | 327 | and instead _escape sequences_ can be included, starting with the |
327 | backslash `\`: | 328 | backslash `\`: |
@@ -457,14 +458,14 @@ are provided, the first is the key and the second is the value. | |||
457 | Tuple, object, list, map, and set types are iterable. The type of collection | 458 | Tuple, object, list, map, and set types are iterable. The type of collection |
458 | used defines how the key and value variables are populated: | 459 | used defines how the key and value variables are populated: |
459 | 460 | ||
460 | * For tuple and list types, the _key_ is the zero-based index into the | 461 | - For tuple and list types, the _key_ is the zero-based index into the |
461 | sequence for each element, and the _value_ is the element value. The | 462 | sequence for each element, and the _value_ is the element value. The |
462 | elements are visited in index order. | 463 | elements are visited in index order. |
463 | * For object and map types, the _key_ is the string attribute name or element | 464 | - For object and map types, the _key_ is the string attribute name or element |
464 | key, and the _value_ is the attribute or element value. The elements are | 465 | key, and the _value_ is the attribute or element value. The elements are |
465 | visited in the order defined by a lexicographic sort of the attribute names | 466 | visited in the order defined by a lexicographic sort of the attribute names |
466 | or keys. | 467 | or keys. |
467 | * For set types, the _key_ and _value_ are both the element value. The elements | 468 | - For set types, the _key_ and _value_ are both the element value. The elements |
468 | are visited in an undefined but consistent order. | 469 | are visited in an undefined but consistent order. |
469 | 470 | ||
470 | The expression after the colon and (in the case of object `for`) the expression | 471 | The expression after the colon and (in the case of object `for`) the expression |
@@ -482,16 +483,16 @@ object. | |||
482 | In the case of object `for`, it is an error if two input elements produce | 483 | In the case of object `for`, it is an error if two input elements produce |
483 | the same result from the attribute name expression, since duplicate | 484 | the same result from the attribute name expression, since duplicate |
484 | attributes are not possible. If the ellipsis symbol (`...`) appears | 485 | attributes are not possible. If the ellipsis symbol (`...`) appears |
485 | immediately after the value experssion, this activates the grouping mode in | 486 | immediately after the value expression, this activates the grouping mode in |
486 | which each value in the resulting object is a _tuple_ of all of the values | 487 | which each value in the resulting object is a _tuple_ of all of the values |
487 | that were produced against each distinct key. | 488 | that were produced against each distinct key. |
488 | 489 | ||
489 | * `[for v in ["a", "b"]: v]` returns `["a", "b"]`. | 490 | - `[for v in ["a", "b"]: v]` returns `["a", "b"]`. |
490 | * `[for i, v in ["a", "b"]: i]` returns `[0, 1]`. | 491 | - `[for i, v in ["a", "b"]: i]` returns `[0, 1]`. |
491 | * `{for i, v in ["a", "b"]: v => i}` returns `{a = 0, b = 1}`. | 492 | - `{for i, v in ["a", "b"]: v => i}` returns `{a = 0, b = 1}`. |
492 | * `{for i, v in ["a", "a", "b"]: k => v}` produces an error, because attribute | 493 | - `{for i, v in ["a", "a", "b"]: k => v}` produces an error, because attribute |
493 | `a` is defined twice. | 494 | `a` is defined twice. |
494 | * `{for i, v in ["a", "a", "b"]: v => i...}` returns `{a = [0, 1], b = [2]}`. | 495 | - `{for i, v in ["a", "a", "b"]: v => i...}` returns `{a = [0, 1], b = [2]}`. |
495 | 496 | ||
496 | If the `if` keyword is used after the element expression(s), it applies an | 497 | If the `if` keyword is used after the element expression(s), it applies an |
497 | additional predicate that can be used to conditionally filter elements from | 498 | additional predicate that can be used to conditionally filter elements from |
@@ -501,7 +502,7 @@ element expression(s). It must evaluate to a boolean value; if `true`, the | |||
501 | element will be evaluated as normal, while if `false` the element will be | 502 | element will be evaluated as normal, while if `false` the element will be |
502 | skipped. | 503 | skipped. |
503 | 504 | ||
504 | * `[for i, v in ["a", "b", "c"]: v if i < 2]` returns `["a", "b"]`. | 505 | - `[for i, v in ["a", "b", "c"]: v if i < 2]` returns `["a", "b"]`. |
505 | 506 | ||
506 | If the collection value, element expression(s) or condition expression return | 507 | If the collection value, element expression(s) or condition expression return |
507 | unknown values that are otherwise type-valid, the result is a value of the | 508 | unknown values that are otherwise type-valid, the result is a value of the |
@@ -566,10 +567,10 @@ elements in a tuple, list, or set value. | |||
566 | 567 | ||
567 | There are two kinds of "splat" operator: | 568 | There are two kinds of "splat" operator: |
568 | 569 | ||
569 | * The _attribute-only_ splat operator supports only attribute lookups into | 570 | - The _attribute-only_ splat operator supports only attribute lookups into |
570 | the elements from a list, but supports an arbitrary number of them. | 571 | the elements from a list, but supports an arbitrary number of them. |
571 | 572 | ||
572 | * The _full_ splat operator additionally supports indexing into the elements | 573 | - The _full_ splat operator additionally supports indexing into the elements |
573 | from a list, and allows any combination of attribute access and index | 574 | from a list, and allows any combination of attribute access and index |
574 | operations. | 575 | operations. |
575 | 576 | ||
@@ -582,9 +583,9 @@ fullSplat = "[" "*" "]" (GetAttr | Index)*; | |||
582 | The splat operators can be thought of as shorthands for common operations that | 583 | The splat operators can be thought of as shorthands for common operations that |
583 | could otherwise be performed using _for expressions_: | 584 | could otherwise be performed using _for expressions_: |
584 | 585 | ||
585 | * `tuple.*.foo.bar[0]` is approximately equivalent to | 586 | - `tuple.*.foo.bar[0]` is approximately equivalent to |
586 | `[for v in tuple: v.foo.bar][0]`. | 587 | `[for v in tuple: v.foo.bar][0]`. |
587 | * `tuple[*].foo.bar[0]` is approximately equivalent to | 588 | - `tuple[*].foo.bar[0]` is approximately equivalent to |
588 | `[for v in tuple: v.foo.bar[0]]` | 589 | `[for v in tuple: v.foo.bar[0]]` |
589 | 590 | ||
590 | Note the difference in how the trailing index operator is interpreted in | 591 | Note the difference in how the trailing index operator is interpreted in |
@@ -596,13 +597,15 @@ _for expressions_ shown above: if a splat operator is applied to a value that | |||
596 | is _not_ of tuple, list, or set type, the value is coerced automatically into | 597 | is _not_ of tuple, list, or set type, the value is coerced automatically into |
597 | a single-value list of the value type: | 598 | a single-value list of the value type: |
598 | 599 | ||
599 | * `any_object.*.id` is equivalent to `[any_object.id]`, assuming that `any_object` | 600 | - `any_object.*.id` is equivalent to `[any_object.id]`, assuming that `any_object` |
600 | is a single object. | 601 | is a single object. |
601 | * `any_number.*` is equivalent to `[any_number]`, assuming that `any_number` | 602 | - `any_number.*` is equivalent to `[any_number]`, assuming that `any_number` |
602 | is a single number. | 603 | is a single number. |
603 | 604 | ||
604 | If the left operand of a splat operator is an unknown value of any type, the | 605 | If applied to a null value that is not tuple, list, or set, the result is always |
605 | result is a value of the dynamic pseudo-type. | 606 | an empty tuple, which allows conveniently converting a possibly-null scalar |
607 | value into a tuple of zero or one elements. It is illegal to apply a splat | ||
608 | operator to a null value of tuple, list, or set type. | ||
606 | 609 | ||
607 | ### Operations | 610 | ### Operations |
608 | 611 | ||
@@ -683,7 +686,7 @@ Arithmetic operations are considered to be performed in an arbitrary-precision | |||
683 | number space. | 686 | number space. |
684 | 687 | ||
685 | If either operand of an arithmetic operator is an unknown number or a value | 688 | If either operand of an arithmetic operator is an unknown number or a value |
686 | of the dynamic pseudo-type, the result is an unknown number. | 689 | of the dynamic pseudo-type, the result is an unknown number. |
687 | 690 | ||
688 | ### Logic Operators | 691 | ### Logic Operators |
689 | 692 | ||
@@ -708,7 +711,7 @@ the outcome of a boolean expression. | |||
708 | Conditional = Expression "?" Expression ":" Expression; | 711 | Conditional = Expression "?" Expression ":" Expression; |
709 | ``` | 712 | ``` |
710 | 713 | ||
711 | The first expression is the _predicate_, which is evaluated and must produce | 714 | The first expression is the _predicate_, which is evaluated and must produce |
712 | a boolean result. If the predicate value is `true`, the result of the second | 715 | a boolean result. If the predicate value is `true`, the result of the second |
713 | expression is the result of the conditional. If the predicate value is | 716 | expression is the result of the conditional. If the predicate value is |
714 | `false`, the result of the third expression is the result of the conditional. | 717 | `false`, the result of the third expression is the result of the conditional. |
@@ -769,15 +772,15 @@ sequence is escaped as `%%{`. | |||
769 | 772 | ||
770 | When the template sub-language is embedded in the expression language via | 773 | When the template sub-language is embedded in the expression language via |
771 | _template expressions_, additional constraints and transforms are applied to | 774 | _template expressions_, additional constraints and transforms are applied to |
772 | template literalsas described in the definition of template expressions. | 775 | template literals as described in the definition of template expressions. |
773 | 776 | ||
774 | The value of a template literal can be modified by _strip markers_ in any | 777 | The value of a template literal can be modified by _strip markers_ in any |
775 | interpolations or directives that are adjacent to it. A strip marker is | 778 | interpolations or directives that are adjacent to it. A strip marker is |
776 | a tilde (`~`) placed immediately after the opening `{` or before the closing | 779 | a tilde (`~`) placed immediately after the opening `{` or before the closing |
777 | `}` of a template sequence: | 780 | `}` of a template sequence: |
778 | 781 | ||
779 | * `hello ${~ "world" }` produces `"helloworld"`. | 782 | - `hello ${~ "world" }` produces `"helloworld"`. |
780 | * `%{ if true ~} hello %{~ endif }` produces `"hello"`. | 783 | - `%{ if true ~} hello %{~ endif }` produces `"hello"`. |
781 | 784 | ||
782 | When a strip marker is present, any spaces adjacent to it in the corresponding | 785 | When a strip marker is present, any spaces adjacent to it in the corresponding |
783 | string literal (if any) are removed before producing the final value. Space | 786 | string literal (if any) are removed before producing the final value. Space |
@@ -786,7 +789,7 @@ characters are interpreted as per Unicode's definition. | |||
786 | Stripping is done at syntax level rather than value level. Values returned | 789 | Stripping is done at syntax level rather than value level. Values returned |
787 | by interpolations or directives are not subject to stripping: | 790 | by interpolations or directives are not subject to stripping: |
788 | 791 | ||
789 | * `${"hello" ~}${" world"}` produces `"hello world"`, and not `"helloworld"`, | 792 | - `${"hello" ~}${" world"}` produces `"hello world"`, and not `"helloworld"`, |
790 | because the space is not in a template literal directly adjacent to the | 793 | because the space is not in a template literal directly adjacent to the |
791 | strip marker. | 794 | strip marker. |
792 | 795 | ||
@@ -824,9 +827,9 @@ TemplateIf = ( | |||
824 | The evaluation of the `if` directive is equivalent to the conditional | 827 | The evaluation of the `if` directive is equivalent to the conditional |
825 | expression, with the following exceptions: | 828 | expression, with the following exceptions: |
826 | 829 | ||
827 | * The two sub-templates always produce strings, and thus the result value is | 830 | - The two sub-templates always produce strings, and thus the result value is |
828 | also always a string. | 831 | also always a string. |
829 | * The `else` clause may be omitted, in which case the conditional's third | 832 | - The `else` clause may be omitted, in which case the conditional's third |
830 | expression result is implied to be the empty string. | 833 | expression result is implied to be the empty string. |
831 | 834 | ||
832 | ### Template For Directive | 835 | ### Template For Directive |
@@ -846,9 +849,9 @@ TemplateFor = ( | |||
846 | The evaluation of the `for` directive is equivalent to the _for expression_ | 849 | The evaluation of the `for` directive is equivalent to the _for expression_ |
847 | when producing a tuple, with the following exceptions: | 850 | when producing a tuple, with the following exceptions: |
848 | 851 | ||
849 | * The sub-template always produces a string. | 852 | - The sub-template always produces a string. |
850 | * There is no equivalent of the "if" clause on the for expression. | 853 | - There is no equivalent of the "if" clause on the for expression. |
851 | * The elements of the resulting tuple are all converted to strings and | 854 | - The elements of the resulting tuple are all converted to strings and |
852 | concatenated to produce a flat string result. | 855 | concatenated to produce a flat string result. |
853 | 856 | ||
854 | ### Template Interpolation Unwrapping | 857 | ### Template Interpolation Unwrapping |
@@ -864,13 +867,13 @@ template or expression syntax. Unwrapping allows arbitrary expressions to be | |||
864 | used to populate attributes when strings in such languages are interpreted | 867 | used to populate attributes when strings in such languages are interpreted |
865 | as templates. | 868 | as templates. |
866 | 869 | ||
867 | * `${true}` produces the boolean value `true` | 870 | - `${true}` produces the boolean value `true` |
868 | * `${"${true}"}` produces the boolean value `true`, because both the inner | 871 | - `${"${true}"}` produces the boolean value `true`, because both the inner |
869 | and outer interpolations are subject to unwrapping. | 872 | and outer interpolations are subject to unwrapping. |
870 | * `hello ${true}` produces the string `"hello true"` | 873 | - `hello ${true}` produces the string `"hello true"` |
871 | * `${""}${true}` produces the string `"true"` because there are two | 874 | - `${""}${true}` produces the string `"true"` because there are two |
872 | interpolation sequences, even though one produces an empty result. | 875 | interpolation sequences, even though one produces an empty result. |
873 | * `%{ for v in [true] }${v}%{ endif }` produces the string `true` because | 876 | - `%{ for v in [true] }${v}%{ endif }` produces the string `true` because |
874 | the presence of the `for` directive circumvents the unwrapping even though | 877 | the presence of the `for` directive circumvents the unwrapping even though |
875 | the final result is a single value. | 878 | the final result is a single value. |
876 | 879 | ||
@@ -903,7 +906,7 @@ key/value pairs given are returned as the static pairs, with no further | |||
903 | interpretation. | 906 | interpretation. |
904 | 907 | ||
905 | The usual requirement that an attribute name be interpretable as a string | 908 | The usual requirement that an attribute name be interpretable as a string |
906 | does not apply to this static analyis, allowing callers to provide map-like | 909 | does not apply to this static analysis, allowing callers to provide map-like |
907 | constructs with different key types by building on the map syntax. | 910 | constructs with different key types by building on the map syntax. |
908 | 911 | ||
909 | ### Static Call | 912 | ### Static Call |
diff --git a/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/structure.go b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/structure.go index d69f65b..476025d 100644 --- a/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/structure.go +++ b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/structure.go | |||
@@ -9,6 +9,10 @@ import ( | |||
9 | 9 | ||
10 | // AsHCLBlock returns the block data expressed as a *hcl.Block. | 10 | // AsHCLBlock returns the block data expressed as a *hcl.Block. |
11 | func (b *Block) AsHCLBlock() *hcl.Block { | 11 | func (b *Block) AsHCLBlock() *hcl.Block { |
12 | if b == nil { | ||
13 | return nil | ||
14 | } | ||
15 | |||
12 | lastHeaderRange := b.TypeRange | 16 | lastHeaderRange := b.TypeRange |
13 | if len(b.LabelRanges) > 0 { | 17 | if len(b.LabelRanges) > 0 { |
14 | lastHeaderRange = b.LabelRanges[len(b.LabelRanges)-1] | 18 | lastHeaderRange = b.LabelRanges[len(b.LabelRanges)-1] |
@@ -43,8 +47,8 @@ type Body struct { | |||
43 | var assertBodyImplBody hcl.Body = &Body{} | 47 | var assertBodyImplBody hcl.Body = &Body{} |
44 | 48 | ||
45 | func (b *Body) walkChildNodes(w internalWalkFunc) { | 49 | func (b *Body) walkChildNodes(w internalWalkFunc) { |
46 | b.Attributes = w(b.Attributes).(Attributes) | 50 | w(b.Attributes) |
47 | b.Blocks = w(b.Blocks).(Blocks) | 51 | w(b.Blocks) |
48 | } | 52 | } |
49 | 53 | ||
50 | func (b *Body) Range() hcl.Range { | 54 | func (b *Body) Range() hcl.Range { |
@@ -82,8 +86,8 @@ func (b *Body) Content(schema *hcl.BodySchema) (*hcl.BodyContent, hcl.Diagnostic | |||
82 | 86 | ||
83 | diags = append(diags, &hcl.Diagnostic{ | 87 | diags = append(diags, &hcl.Diagnostic{ |
84 | Severity: hcl.DiagError, | 88 | Severity: hcl.DiagError, |
85 | Summary: "Unsupported attribute", | 89 | Summary: "Unsupported argument", |
86 | Detail: fmt.Sprintf("An attribute named %q is not expected here.%s", name, suggestion), | 90 | Detail: fmt.Sprintf("An argument named %q is not expected here.%s", name, suggestion), |
87 | Subject: &attr.NameRange, | 91 | Subject: &attr.NameRange, |
88 | }) | 92 | }) |
89 | } | 93 | } |
@@ -103,7 +107,7 @@ func (b *Body) Content(schema *hcl.BodySchema) (*hcl.BodyContent, hcl.Diagnostic | |||
103 | // Is there an attribute of the same name? | 107 | // Is there an attribute of the same name? |
104 | for _, attrS := range schema.Attributes { | 108 | for _, attrS := range schema.Attributes { |
105 | if attrS.Name == blockTy { | 109 | if attrS.Name == blockTy { |
106 | suggestion = fmt.Sprintf(" Did you mean to define attribute %q?", blockTy) | 110 | suggestion = fmt.Sprintf(" Did you mean to define argument %q? If so, use the equals sign to assign it a value.", blockTy) |
107 | break | 111 | break |
108 | } | 112 | } |
109 | } | 113 | } |
@@ -147,8 +151,8 @@ func (b *Body) PartialContent(schema *hcl.BodySchema) (*hcl.BodyContent, hcl.Bod | |||
147 | if attrS.Required { | 151 | if attrS.Required { |
148 | diags = append(diags, &hcl.Diagnostic{ | 152 | diags = append(diags, &hcl.Diagnostic{ |
149 | Severity: hcl.DiagError, | 153 | Severity: hcl.DiagError, |
150 | Summary: "Missing required attribute", | 154 | Summary: "Missing required argument", |
151 | Detail: fmt.Sprintf("The attribute %q is required, but no definition was found.", attrS.Name), | 155 | Detail: fmt.Sprintf("The argument %q is required, but no definition was found.", attrS.Name), |
152 | Subject: b.MissingItemRange().Ptr(), | 156 | Subject: b.MissingItemRange().Ptr(), |
153 | }) | 157 | }) |
154 | } | 158 | } |
@@ -251,9 +255,9 @@ func (b *Body) JustAttributes() (hcl.Attributes, hcl.Diagnostics) { | |||
251 | example := b.Blocks[0] | 255 | example := b.Blocks[0] |
252 | diags = append(diags, &hcl.Diagnostic{ | 256 | diags = append(diags, &hcl.Diagnostic{ |
253 | Severity: hcl.DiagError, | 257 | Severity: hcl.DiagError, |
254 | Summary: fmt.Sprintf("Unexpected %s block", example.Type), | 258 | Summary: fmt.Sprintf("Unexpected %q block", example.Type), |
255 | Detail: "Blocks are not allowed here.", | 259 | Detail: "Blocks are not allowed here.", |
256 | Context: &example.TypeRange, | 260 | Subject: &example.TypeRange, |
257 | }) | 261 | }) |
258 | // we will continue processing anyway, and return the attributes | 262 | // we will continue processing anyway, and return the attributes |
259 | // we are able to find so that certain analyses can still be done | 263 | // we are able to find so that certain analyses can still be done |
@@ -275,15 +279,19 @@ func (b *Body) JustAttributes() (hcl.Attributes, hcl.Diagnostics) { | |||
275 | } | 279 | } |
276 | 280 | ||
277 | func (b *Body) MissingItemRange() hcl.Range { | 281 | func (b *Body) MissingItemRange() hcl.Range { |
278 | return b.EndRange | 282 | return hcl.Range{ |
283 | Filename: b.SrcRange.Filename, | ||
284 | Start: b.SrcRange.Start, | ||
285 | End: b.SrcRange.Start, | ||
286 | } | ||
279 | } | 287 | } |
280 | 288 | ||
281 | // Attributes is the collection of attribute definitions within a body. | 289 | // Attributes is the collection of attribute definitions within a body. |
282 | type Attributes map[string]*Attribute | 290 | type Attributes map[string]*Attribute |
283 | 291 | ||
284 | func (a Attributes) walkChildNodes(w internalWalkFunc) { | 292 | func (a Attributes) walkChildNodes(w internalWalkFunc) { |
285 | for k, attr := range a { | 293 | for _, attr := range a { |
286 | a[k] = w(attr).(*Attribute) | 294 | w(attr) |
287 | } | 295 | } |
288 | } | 296 | } |
289 | 297 | ||
@@ -317,7 +325,7 @@ type Attribute struct { | |||
317 | } | 325 | } |
318 | 326 | ||
319 | func (a *Attribute) walkChildNodes(w internalWalkFunc) { | 327 | func (a *Attribute) walkChildNodes(w internalWalkFunc) { |
320 | a.Expr = w(a.Expr).(Expression) | 328 | w(a.Expr) |
321 | } | 329 | } |
322 | 330 | ||
323 | func (a *Attribute) Range() hcl.Range { | 331 | func (a *Attribute) Range() hcl.Range { |
@@ -326,6 +334,9 @@ func (a *Attribute) Range() hcl.Range { | |||
326 | 334 | ||
327 | // AsHCLAttribute returns the block data expressed as a *hcl.Attribute. | 335 | // AsHCLAttribute returns the block data expressed as a *hcl.Attribute. |
328 | func (a *Attribute) AsHCLAttribute() *hcl.Attribute { | 336 | func (a *Attribute) AsHCLAttribute() *hcl.Attribute { |
337 | if a == nil { | ||
338 | return nil | ||
339 | } | ||
329 | return &hcl.Attribute{ | 340 | return &hcl.Attribute{ |
330 | Name: a.Name, | 341 | Name: a.Name, |
331 | Expr: a.Expr, | 342 | Expr: a.Expr, |
@@ -339,8 +350,8 @@ func (a *Attribute) AsHCLAttribute() *hcl.Attribute { | |||
339 | type Blocks []*Block | 350 | type Blocks []*Block |
340 | 351 | ||
341 | func (bs Blocks) walkChildNodes(w internalWalkFunc) { | 352 | func (bs Blocks) walkChildNodes(w internalWalkFunc) { |
342 | for i, block := range bs { | 353 | for _, block := range bs { |
343 | bs[i] = w(block).(*Block) | 354 | w(block) |
344 | } | 355 | } |
345 | } | 356 | } |
346 | 357 | ||
@@ -371,9 +382,13 @@ type Block struct { | |||
371 | } | 382 | } |
372 | 383 | ||
373 | func (b *Block) walkChildNodes(w internalWalkFunc) { | 384 | func (b *Block) walkChildNodes(w internalWalkFunc) { |
374 | b.Body = w(b.Body).(*Body) | 385 | w(b.Body) |
375 | } | 386 | } |
376 | 387 | ||
377 | func (b *Block) Range() hcl.Range { | 388 | func (b *Block) Range() hcl.Range { |
378 | return hcl.RangeBetween(b.TypeRange, b.CloseBraceRange) | 389 | return hcl.RangeBetween(b.TypeRange, b.CloseBraceRange) |
379 | } | 390 | } |
391 | |||
392 | func (b *Block) DefRange() hcl.Range { | ||
393 | return hcl.RangeBetween(b.TypeRange, b.OpenBraceRange) | ||
394 | } | ||
diff --git a/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/structure_at_pos.go b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/structure_at_pos.go new file mode 100644 index 0000000..d8f023b --- /dev/null +++ b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/structure_at_pos.go | |||
@@ -0,0 +1,118 @@ | |||
1 | package hclsyntax | ||
2 | |||
3 | import ( | ||
4 | "github.com/hashicorp/hcl2/hcl" | ||
5 | ) | ||
6 | |||
7 | // ----------------------------------------------------------------------------- | ||
8 | // The methods in this file are all optional extension methods that serve to | ||
9 | // implement the methods of the same name on *hcl.File when its root body | ||
10 | // is provided by this package. | ||
11 | // ----------------------------------------------------------------------------- | ||
12 | |||
13 | // BlocksAtPos implements the method of the same name for an *hcl.File that | ||
14 | // is backed by a *Body. | ||
15 | func (b *Body) BlocksAtPos(pos hcl.Pos) []*hcl.Block { | ||
16 | list, _ := b.blocksAtPos(pos, true) | ||
17 | return list | ||
18 | } | ||
19 | |||
20 | // InnermostBlockAtPos implements the method of the same name for an *hcl.File | ||
21 | // that is backed by a *Body. | ||
22 | func (b *Body) InnermostBlockAtPos(pos hcl.Pos) *hcl.Block { | ||
23 | _, innermost := b.blocksAtPos(pos, false) | ||
24 | return innermost.AsHCLBlock() | ||
25 | } | ||
26 | |||
27 | // OutermostBlockAtPos implements the method of the same name for an *hcl.File | ||
28 | // that is backed by a *Body. | ||
29 | func (b *Body) OutermostBlockAtPos(pos hcl.Pos) *hcl.Block { | ||
30 | return b.outermostBlockAtPos(pos).AsHCLBlock() | ||
31 | } | ||
32 | |||
33 | // blocksAtPos is the internal engine of both BlocksAtPos and | ||
34 | // InnermostBlockAtPos, which both need to do the same logic but return a | ||
35 | // differently-shaped result. | ||
36 | // | ||
37 | // list is nil if makeList is false, avoiding an allocation. Innermost is | ||
38 | // always set, and if the returned list is non-nil it will always match the | ||
39 | // final element from that list. | ||
40 | func (b *Body) blocksAtPos(pos hcl.Pos, makeList bool) (list []*hcl.Block, innermost *Block) { | ||
41 | current := b | ||
42 | |||
43 | Blocks: | ||
44 | for current != nil { | ||
45 | for _, block := range current.Blocks { | ||
46 | wholeRange := hcl.RangeBetween(block.TypeRange, block.CloseBraceRange) | ||
47 | if wholeRange.ContainsPos(pos) { | ||
48 | innermost = block | ||
49 | if makeList { | ||
50 | list = append(list, innermost.AsHCLBlock()) | ||
51 | } | ||
52 | current = block.Body | ||
53 | continue Blocks | ||
54 | } | ||
55 | } | ||
56 | |||
57 | // If we fall out here then none of the current body's nested blocks | ||
58 | // contain the position we are looking for, and so we're done. | ||
59 | break | ||
60 | } | ||
61 | |||
62 | return | ||
63 | } | ||
64 | |||
65 | // outermostBlockAtPos is the internal version of OutermostBlockAtPos that | ||
66 | // returns a hclsyntax.Block rather than an hcl.Block, allowing for further | ||
67 | // analysis if necessary. | ||
68 | func (b *Body) outermostBlockAtPos(pos hcl.Pos) *Block { | ||
69 | // This is similar to blocksAtPos, but simpler because we know it only | ||
70 | // ever needs to search the first level of nested blocks. | ||
71 | |||
72 | for _, block := range b.Blocks { | ||
73 | wholeRange := hcl.RangeBetween(block.TypeRange, block.CloseBraceRange) | ||
74 | if wholeRange.ContainsPos(pos) { | ||
75 | return block | ||
76 | } | ||
77 | } | ||
78 | |||
79 | return nil | ||
80 | } | ||
81 | |||
82 | // AttributeAtPos implements the method of the same name for an *hcl.File | ||
83 | // that is backed by a *Body. | ||
84 | func (b *Body) AttributeAtPos(pos hcl.Pos) *hcl.Attribute { | ||
85 | return b.attributeAtPos(pos).AsHCLAttribute() | ||
86 | } | ||
87 | |||
88 | // attributeAtPos is the internal version of AttributeAtPos that returns a | ||
89 | // hclsyntax.Block rather than an hcl.Block, allowing for further analysis if | ||
90 | // necessary. | ||
91 | func (b *Body) attributeAtPos(pos hcl.Pos) *Attribute { | ||
92 | searchBody := b | ||
93 | _, block := b.blocksAtPos(pos, false) | ||
94 | if block != nil { | ||
95 | searchBody = block.Body | ||
96 | } | ||
97 | |||
98 | for _, attr := range searchBody.Attributes { | ||
99 | if attr.SrcRange.ContainsPos(pos) { | ||
100 | return attr | ||
101 | } | ||
102 | } | ||
103 | |||
104 | return nil | ||
105 | } | ||
106 | |||
107 | // OutermostExprAtPos implements the method of the same name for an *hcl.File | ||
108 | // that is backed by a *Body. | ||
109 | func (b *Body) OutermostExprAtPos(pos hcl.Pos) hcl.Expression { | ||
110 | attr := b.attributeAtPos(pos) | ||
111 | if attr == nil { | ||
112 | return nil | ||
113 | } | ||
114 | if !attr.Expr.Range().ContainsPos(pos) { | ||
115 | return nil | ||
116 | } | ||
117 | return attr.Expr | ||
118 | } | ||
diff --git a/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/token.go b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/token.go index bcaa15f..3d898fd 100644 --- a/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/token.go +++ b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/token.go | |||
@@ -1,6 +1,7 @@ | |||
1 | package hclsyntax | 1 | package hclsyntax |
2 | 2 | ||
3 | import ( | 3 | import ( |
4 | "bytes" | ||
4 | "fmt" | 5 | "fmt" |
5 | 6 | ||
6 | "github.com/apparentlymart/go-textseg/textseg" | 7 | "github.com/apparentlymart/go-textseg/textseg" |
@@ -84,16 +85,18 @@ const ( | |||
84 | // things that might work in other languages they are familiar with, or | 85 | // things that might work in other languages they are familiar with, or |
85 | // simply make incorrect assumptions about the HCL language. | 86 | // simply make incorrect assumptions about the HCL language. |
86 | 87 | ||
87 | TokenBitwiseAnd TokenType = '&' | 88 | TokenBitwiseAnd TokenType = '&' |
88 | TokenBitwiseOr TokenType = '|' | 89 | TokenBitwiseOr TokenType = '|' |
89 | TokenBitwiseNot TokenType = '~' | 90 | TokenBitwiseNot TokenType = '~' |
90 | TokenBitwiseXor TokenType = '^' | 91 | TokenBitwiseXor TokenType = '^' |
91 | TokenStarStar TokenType = '➚' | 92 | TokenStarStar TokenType = '➚' |
92 | TokenBacktick TokenType = '`' | 93 | TokenApostrophe TokenType = '\'' |
93 | TokenSemicolon TokenType = ';' | 94 | TokenBacktick TokenType = '`' |
94 | TokenTabs TokenType = '␉' | 95 | TokenSemicolon TokenType = ';' |
95 | TokenInvalid TokenType = '�' | 96 | TokenTabs TokenType = '␉' |
96 | TokenBadUTF8 TokenType = '💩' | 97 | TokenInvalid TokenType = '�' |
98 | TokenBadUTF8 TokenType = '💩' | ||
99 | TokenQuotedNewline TokenType = '' | ||
97 | 100 | ||
98 | // TokenNil is a placeholder for when a token is required but none is | 101 | // TokenNil is a placeholder for when a token is required but none is |
99 | // available, e.g. when reporting errors. The scanner will never produce | 102 | // available, e.g. when reporting errors. The scanner will never produce |
@@ -114,10 +117,11 @@ const ( | |||
114 | ) | 117 | ) |
115 | 118 | ||
116 | type tokenAccum struct { | 119 | type tokenAccum struct { |
117 | Filename string | 120 | Filename string |
118 | Bytes []byte | 121 | Bytes []byte |
119 | Pos hcl.Pos | 122 | Pos hcl.Pos |
120 | Tokens []Token | 123 | Tokens []Token |
124 | StartByte int | ||
121 | } | 125 | } |
122 | 126 | ||
123 | func (f *tokenAccum) emitToken(ty TokenType, startOfs, endOfs int) { | 127 | func (f *tokenAccum) emitToken(ty TokenType, startOfs, endOfs int) { |
@@ -125,11 +129,11 @@ func (f *tokenAccum) emitToken(ty TokenType, startOfs, endOfs int) { | |||
125 | // the start pos to get our end pos. | 129 | // the start pos to get our end pos. |
126 | 130 | ||
127 | start := f.Pos | 131 | start := f.Pos |
128 | start.Column += startOfs - f.Pos.Byte // Safe because only ASCII spaces can be in the offset | 132 | start.Column += startOfs + f.StartByte - f.Pos.Byte // Safe because only ASCII spaces can be in the offset |
129 | start.Byte = startOfs | 133 | start.Byte = startOfs + f.StartByte |
130 | 134 | ||
131 | end := start | 135 | end := start |
132 | end.Byte = endOfs | 136 | end.Byte = endOfs + f.StartByte |
133 | b := f.Bytes[startOfs:endOfs] | 137 | b := f.Bytes[startOfs:endOfs] |
134 | for len(b) > 0 { | 138 | for len(b) > 0 { |
135 | advance, seq, _ := textseg.ScanGraphemeClusters(b, true) | 139 | advance, seq, _ := textseg.ScanGraphemeClusters(b, true) |
@@ -160,6 +164,13 @@ type heredocInProgress struct { | |||
160 | StartOfLine bool | 164 | StartOfLine bool |
161 | } | 165 | } |
162 | 166 | ||
167 | func tokenOpensFlushHeredoc(tok Token) bool { | ||
168 | if tok.Type != TokenOHeredoc { | ||
169 | return false | ||
170 | } | ||
171 | return bytes.HasPrefix(tok.Bytes, []byte{'<', '<', '-'}) | ||
172 | } | ||
173 | |||
163 | // checkInvalidTokens does a simple pass across the given tokens and generates | 174 | // checkInvalidTokens does a simple pass across the given tokens and generates |
164 | // diagnostics for tokens that should _never_ appear in HCL source. This | 175 | // diagnostics for tokens that should _never_ appear in HCL source. This |
165 | // is intended to avoid the need for the parser to have special support | 176 | // is intended to avoid the need for the parser to have special support |
@@ -174,11 +185,15 @@ func checkInvalidTokens(tokens Tokens) hcl.Diagnostics { | |||
174 | toldBitwise := 0 | 185 | toldBitwise := 0 |
175 | toldExponent := 0 | 186 | toldExponent := 0 |
176 | toldBacktick := 0 | 187 | toldBacktick := 0 |
188 | toldApostrophe := 0 | ||
177 | toldSemicolon := 0 | 189 | toldSemicolon := 0 |
178 | toldTabs := 0 | 190 | toldTabs := 0 |
179 | toldBadUTF8 := 0 | 191 | toldBadUTF8 := 0 |
180 | 192 | ||
181 | for _, tok := range tokens { | 193 | for _, tok := range tokens { |
194 | // copy token so it's safe to point to it | ||
195 | tok := tok | ||
196 | |||
182 | switch tok.Type { | 197 | switch tok.Type { |
183 | case TokenBitwiseAnd, TokenBitwiseOr, TokenBitwiseXor, TokenBitwiseNot: | 198 | case TokenBitwiseAnd, TokenBitwiseOr, TokenBitwiseXor, TokenBitwiseNot: |
184 | if toldBitwise < 4 { | 199 | if toldBitwise < 4 { |
@@ -214,22 +229,36 @@ func checkInvalidTokens(tokens Tokens) hcl.Diagnostics { | |||
214 | case TokenBacktick: | 229 | case TokenBacktick: |
215 | // Only report for alternating (even) backticks, so we won't report both start and ends of the same | 230 | // Only report for alternating (even) backticks, so we won't report both start and ends of the same |
216 | // backtick-quoted string. | 231 | // backtick-quoted string. |
217 | if toldExponent < 4 && (toldExponent%2) == 0 { | 232 | if (toldBacktick % 2) == 0 { |
218 | diags = append(diags, &hcl.Diagnostic{ | 233 | diags = append(diags, &hcl.Diagnostic{ |
219 | Severity: hcl.DiagError, | 234 | Severity: hcl.DiagError, |
220 | Summary: "Invalid character", | 235 | Summary: "Invalid character", |
221 | Detail: "The \"`\" character is not valid. To create a multi-line string, use the \"heredoc\" syntax, like \"<<EOT\".", | 236 | Detail: "The \"`\" character is not valid. To create a multi-line string, use the \"heredoc\" syntax, like \"<<EOT\".", |
222 | Subject: &tok.Range, | 237 | Subject: &tok.Range, |
223 | }) | 238 | }) |
224 | 239 | } | |
240 | if toldBacktick <= 2 { | ||
225 | toldBacktick++ | 241 | toldBacktick++ |
226 | } | 242 | } |
243 | case TokenApostrophe: | ||
244 | if (toldApostrophe % 2) == 0 { | ||
245 | newDiag := &hcl.Diagnostic{ | ||
246 | Severity: hcl.DiagError, | ||
247 | Summary: "Invalid character", | ||
248 | Detail: "Single quotes are not valid. Use double quotes (\") to enclose strings.", | ||
249 | Subject: &tok.Range, | ||
250 | } | ||
251 | diags = append(diags, newDiag) | ||
252 | } | ||
253 | if toldApostrophe <= 2 { | ||
254 | toldApostrophe++ | ||
255 | } | ||
227 | case TokenSemicolon: | 256 | case TokenSemicolon: |
228 | if toldSemicolon < 1 { | 257 | if toldSemicolon < 1 { |
229 | diags = append(diags, &hcl.Diagnostic{ | 258 | diags = append(diags, &hcl.Diagnostic{ |
230 | Severity: hcl.DiagError, | 259 | Severity: hcl.DiagError, |
231 | Summary: "Invalid character", | 260 | Summary: "Invalid character", |
232 | Detail: "The \";\" character is not valid. Use newlines to separate attributes and blocks, and commas to separate items in collection values.", | 261 | Detail: "The \";\" character is not valid. Use newlines to separate arguments and blocks, and commas to separate items in collection values.", |
233 | Subject: &tok.Range, | 262 | Subject: &tok.Range, |
234 | }) | 263 | }) |
235 | 264 | ||
@@ -257,6 +286,13 @@ func checkInvalidTokens(tokens Tokens) hcl.Diagnostics { | |||
257 | 286 | ||
258 | toldBadUTF8++ | 287 | toldBadUTF8++ |
259 | } | 288 | } |
289 | case TokenQuotedNewline: | ||
290 | diags = append(diags, &hcl.Diagnostic{ | ||
291 | Severity: hcl.DiagError, | ||
292 | Summary: "Invalid multi-line string", | ||
293 | Detail: "Quoted strings may not be split over multiple lines. To produce a multi-line string, either use the \\n escape to represent a newline character or use the \"heredoc\" multi-line template syntax.", | ||
294 | Subject: &tok.Range, | ||
295 | }) | ||
260 | case TokenInvalid: | 296 | case TokenInvalid: |
261 | diags = append(diags, &hcl.Diagnostic{ | 297 | diags = append(diags, &hcl.Diagnostic{ |
262 | Severity: hcl.DiagError, | 298 | Severity: hcl.DiagError, |
@@ -264,9 +300,21 @@ func checkInvalidTokens(tokens Tokens) hcl.Diagnostics { | |||
264 | Detail: "This character is not used within the language.", | 300 | Detail: "This character is not used within the language.", |
265 | Subject: &tok.Range, | 301 | Subject: &tok.Range, |
266 | }) | 302 | }) |
267 | |||
268 | toldTabs++ | ||
269 | } | 303 | } |
270 | } | 304 | } |
271 | return diags | 305 | return diags |
272 | } | 306 | } |
307 | |||
308 | var utf8BOM = []byte{0xef, 0xbb, 0xbf} | ||
309 | |||
310 | // stripUTF8BOM checks whether the given buffer begins with a UTF-8 byte order | ||
311 | // mark (0xEF 0xBB 0xBF) and, if so, returns a truncated slice with the same | ||
312 | // backing array but with the BOM skipped. | ||
313 | // | ||
314 | // If there is no BOM present, the given slice is returned verbatim. | ||
315 | func stripUTF8BOM(src []byte) []byte { | ||
316 | if bytes.HasPrefix(src, utf8BOM) { | ||
317 | return src[3:] | ||
318 | } | ||
319 | return src | ||
320 | } | ||
diff --git a/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/token_type_string.go b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/token_type_string.go index 93de7ee..c23c4f0 100644 --- a/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/token_type_string.go +++ b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/token_type_string.go | |||
@@ -4,7 +4,67 @@ package hclsyntax | |||
4 | 4 | ||
5 | import "strconv" | 5 | import "strconv" |
6 | 6 | ||
7 | const _TokenType_name = "TokenNilTokenNewlineTokenBangTokenPercentTokenBitwiseAndTokenOParenTokenCParenTokenStarTokenPlusTokenCommaTokenMinusTokenDotTokenSlashTokenColonTokenSemicolonTokenLessThanTokenEqualTokenGreaterThanTokenQuestionTokenCommentTokenOHeredocTokenIdentTokenNumberLitTokenQuotedLitTokenStringLitTokenOBrackTokenCBrackTokenBitwiseXorTokenBacktickTokenCHeredocTokenOBraceTokenBitwiseOrTokenCBraceTokenBitwiseNotTokenOQuoteTokenCQuoteTokenTemplateControlTokenEllipsisTokenFatArrowTokenTemplateSeqEndTokenAndTokenOrTokenTemplateInterpTokenEqualOpTokenNotEqualTokenLessThanEqTokenGreaterThanEqTokenEOFTokenTabsTokenStarStarTokenInvalidTokenBadUTF8" | 7 | func _() { |
8 | // An "invalid array index" compiler error signifies that the constant values have changed. | ||
9 | // Re-run the stringer command to generate them again. | ||
10 | var x [1]struct{} | ||
11 | _ = x[TokenOBrace-123] | ||
12 | _ = x[TokenCBrace-125] | ||
13 | _ = x[TokenOBrack-91] | ||
14 | _ = x[TokenCBrack-93] | ||
15 | _ = x[TokenOParen-40] | ||
16 | _ = x[TokenCParen-41] | ||
17 | _ = x[TokenOQuote-171] | ||
18 | _ = x[TokenCQuote-187] | ||
19 | _ = x[TokenOHeredoc-72] | ||
20 | _ = x[TokenCHeredoc-104] | ||
21 | _ = x[TokenStar-42] | ||
22 | _ = x[TokenSlash-47] | ||
23 | _ = x[TokenPlus-43] | ||
24 | _ = x[TokenMinus-45] | ||
25 | _ = x[TokenPercent-37] | ||
26 | _ = x[TokenEqual-61] | ||
27 | _ = x[TokenEqualOp-8788] | ||
28 | _ = x[TokenNotEqual-8800] | ||
29 | _ = x[TokenLessThan-60] | ||
30 | _ = x[TokenLessThanEq-8804] | ||
31 | _ = x[TokenGreaterThan-62] | ||
32 | _ = x[TokenGreaterThanEq-8805] | ||
33 | _ = x[TokenAnd-8743] | ||
34 | _ = x[TokenOr-8744] | ||
35 | _ = x[TokenBang-33] | ||
36 | _ = x[TokenDot-46] | ||
37 | _ = x[TokenComma-44] | ||
38 | _ = x[TokenEllipsis-8230] | ||
39 | _ = x[TokenFatArrow-8658] | ||
40 | _ = x[TokenQuestion-63] | ||
41 | _ = x[TokenColon-58] | ||
42 | _ = x[TokenTemplateInterp-8747] | ||
43 | _ = x[TokenTemplateControl-955] | ||
44 | _ = x[TokenTemplateSeqEnd-8718] | ||
45 | _ = x[TokenQuotedLit-81] | ||
46 | _ = x[TokenStringLit-83] | ||
47 | _ = x[TokenNumberLit-78] | ||
48 | _ = x[TokenIdent-73] | ||
49 | _ = x[TokenComment-67] | ||
50 | _ = x[TokenNewline-10] | ||
51 | _ = x[TokenEOF-9220] | ||
52 | _ = x[TokenBitwiseAnd-38] | ||
53 | _ = x[TokenBitwiseOr-124] | ||
54 | _ = x[TokenBitwiseNot-126] | ||
55 | _ = x[TokenBitwiseXor-94] | ||
56 | _ = x[TokenStarStar-10138] | ||
57 | _ = x[TokenApostrophe-39] | ||
58 | _ = x[TokenBacktick-96] | ||
59 | _ = x[TokenSemicolon-59] | ||
60 | _ = x[TokenTabs-9225] | ||
61 | _ = x[TokenInvalid-65533] | ||
62 | _ = x[TokenBadUTF8-128169] | ||
63 | _ = x[TokenQuotedNewline-9252] | ||
64 | _ = x[TokenNil-0] | ||
65 | } | ||
66 | |||
67 | const _TokenType_name = "TokenNilTokenNewlineTokenBangTokenPercentTokenBitwiseAndTokenApostropheTokenOParenTokenCParenTokenStarTokenPlusTokenCommaTokenMinusTokenDotTokenSlashTokenColonTokenSemicolonTokenLessThanTokenEqualTokenGreaterThanTokenQuestionTokenCommentTokenOHeredocTokenIdentTokenNumberLitTokenQuotedLitTokenStringLitTokenOBrackTokenCBrackTokenBitwiseXorTokenBacktickTokenCHeredocTokenOBraceTokenBitwiseOrTokenCBraceTokenBitwiseNotTokenOQuoteTokenCQuoteTokenTemplateControlTokenEllipsisTokenFatArrowTokenTemplateSeqEndTokenAndTokenOrTokenTemplateInterpTokenEqualOpTokenNotEqualTokenLessThanEqTokenGreaterThanEqTokenEOFTokenTabsTokenQuotedNewlineTokenStarStarTokenInvalidTokenBadUTF8" | ||
8 | 68 | ||
9 | var _TokenType_map = map[TokenType]string{ | 69 | var _TokenType_map = map[TokenType]string{ |
10 | 0: _TokenType_name[0:8], | 70 | 0: _TokenType_name[0:8], |
@@ -12,53 +72,55 @@ var _TokenType_map = map[TokenType]string{ | |||
12 | 33: _TokenType_name[20:29], | 72 | 33: _TokenType_name[20:29], |
13 | 37: _TokenType_name[29:41], | 73 | 37: _TokenType_name[29:41], |
14 | 38: _TokenType_name[41:56], | 74 | 38: _TokenType_name[41:56], |
15 | 40: _TokenType_name[56:67], | 75 | 39: _TokenType_name[56:71], |
16 | 41: _TokenType_name[67:78], | 76 | 40: _TokenType_name[71:82], |
17 | 42: _TokenType_name[78:87], | 77 | 41: _TokenType_name[82:93], |
18 | 43: _TokenType_name[87:96], | 78 | 42: _TokenType_name[93:102], |
19 | 44: _TokenType_name[96:106], | 79 | 43: _TokenType_name[102:111], |
20 | 45: _TokenType_name[106:116], | 80 | 44: _TokenType_name[111:121], |
21 | 46: _TokenType_name[116:124], | 81 | 45: _TokenType_name[121:131], |
22 | 47: _TokenType_name[124:134], | 82 | 46: _TokenType_name[131:139], |
23 | 58: _TokenType_name[134:144], | 83 | 47: _TokenType_name[139:149], |
24 | 59: _TokenType_name[144:158], | 84 | 58: _TokenType_name[149:159], |
25 | 60: _TokenType_name[158:171], | 85 | 59: _TokenType_name[159:173], |
26 | 61: _TokenType_name[171:181], | 86 | 60: _TokenType_name[173:186], |
27 | 62: _TokenType_name[181:197], | 87 | 61: _TokenType_name[186:196], |
28 | 63: _TokenType_name[197:210], | 88 | 62: _TokenType_name[196:212], |
29 | 67: _TokenType_name[210:222], | 89 | 63: _TokenType_name[212:225], |
30 | 72: _TokenType_name[222:235], | 90 | 67: _TokenType_name[225:237], |
31 | 73: _TokenType_name[235:245], | 91 | 72: _TokenType_name[237:250], |
32 | 78: _TokenType_name[245:259], | 92 | 73: _TokenType_name[250:260], |
33 | 81: _TokenType_name[259:273], | 93 | 78: _TokenType_name[260:274], |
34 | 83: _TokenType_name[273:287], | 94 | 81: _TokenType_name[274:288], |
35 | 91: _TokenType_name[287:298], | 95 | 83: _TokenType_name[288:302], |
36 | 93: _TokenType_name[298:309], | 96 | 91: _TokenType_name[302:313], |
37 | 94: _TokenType_name[309:324], | 97 | 93: _TokenType_name[313:324], |
38 | 96: _TokenType_name[324:337], | 98 | 94: _TokenType_name[324:339], |
39 | 104: _TokenType_name[337:350], | 99 | 96: _TokenType_name[339:352], |
40 | 123: _TokenType_name[350:361], | 100 | 104: _TokenType_name[352:365], |
41 | 124: _TokenType_name[361:375], | 101 | 123: _TokenType_name[365:376], |
42 | 125: _TokenType_name[375:386], | 102 | 124: _TokenType_name[376:390], |
43 | 126: _TokenType_name[386:401], | 103 | 125: _TokenType_name[390:401], |
44 | 171: _TokenType_name[401:412], | 104 | 126: _TokenType_name[401:416], |
45 | 187: _TokenType_name[412:423], | 105 | 171: _TokenType_name[416:427], |
46 | 955: _TokenType_name[423:443], | 106 | 187: _TokenType_name[427:438], |
47 | 8230: _TokenType_name[443:456], | 107 | 955: _TokenType_name[438:458], |
48 | 8658: _TokenType_name[456:469], | 108 | 8230: _TokenType_name[458:471], |
49 | 8718: _TokenType_name[469:488], | 109 | 8658: _TokenType_name[471:484], |
50 | 8743: _TokenType_name[488:496], | 110 | 8718: _TokenType_name[484:503], |
51 | 8744: _TokenType_name[496:503], | 111 | 8743: _TokenType_name[503:511], |
52 | 8747: _TokenType_name[503:522], | 112 | 8744: _TokenType_name[511:518], |
53 | 8788: _TokenType_name[522:534], | 113 | 8747: _TokenType_name[518:537], |
54 | 8800: _TokenType_name[534:547], | 114 | 8788: _TokenType_name[537:549], |
55 | 8804: _TokenType_name[547:562], | 115 | 8800: _TokenType_name[549:562], |
56 | 8805: _TokenType_name[562:580], | 116 | 8804: _TokenType_name[562:577], |
57 | 9220: _TokenType_name[580:588], | 117 | 8805: _TokenType_name[577:595], |
58 | 9225: _TokenType_name[588:597], | 118 | 9220: _TokenType_name[595:603], |
59 | 10138: _TokenType_name[597:610], | 119 | 9225: _TokenType_name[603:612], |
60 | 65533: _TokenType_name[610:622], | 120 | 9252: _TokenType_name[612:630], |
61 | 128169: _TokenType_name[622:634], | 121 | 10138: _TokenType_name[630:643], |
122 | 65533: _TokenType_name[643:655], | ||
123 | 128169: _TokenType_name[655:667], | ||
62 | } | 124 | } |
63 | 125 | ||
64 | func (i TokenType) String() string { | 126 | func (i TokenType) String() string { |
diff --git a/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/variables.go b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/variables.go index eeee1a5..91f417f 100644 --- a/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/variables.go +++ b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/variables.go | |||
@@ -72,15 +72,15 @@ func (w *variablesWalker) Exit(n Node) hcl.Diagnostics { | |||
72 | // that the child scope struct wraps. | 72 | // that the child scope struct wraps. |
73 | type ChildScope struct { | 73 | type ChildScope struct { |
74 | LocalNames map[string]struct{} | 74 | LocalNames map[string]struct{} |
75 | Expr *Expression // pointer because it can be replaced on walk | 75 | Expr Expression |
76 | } | 76 | } |
77 | 77 | ||
78 | func (e ChildScope) walkChildNodes(w internalWalkFunc) { | 78 | func (e ChildScope) walkChildNodes(w internalWalkFunc) { |
79 | *(e.Expr) = w(*(e.Expr)).(Expression) | 79 | w(e.Expr) |
80 | } | 80 | } |
81 | 81 | ||
82 | // Range returns the range of the expression that the ChildScope is | 82 | // Range returns the range of the expression that the ChildScope is |
83 | // encapsulating. It isn't really very useful to call Range on a ChildScope. | 83 | // encapsulating. It isn't really very useful to call Range on a ChildScope. |
84 | func (e ChildScope) Range() hcl.Range { | 84 | func (e ChildScope) Range() hcl.Range { |
85 | return (*e.Expr).Range() | 85 | return e.Expr.Range() |
86 | } | 86 | } |
diff --git a/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/walk.go b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/walk.go index 3405d26..90f81c9 100644 --- a/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/walk.go +++ b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/walk.go | |||
@@ -15,9 +15,8 @@ type VisitFunc func(node Node) hcl.Diagnostics | |||
15 | // and returned as a single set. | 15 | // and returned as a single set. |
16 | func VisitAll(node Node, f VisitFunc) hcl.Diagnostics { | 16 | func VisitAll(node Node, f VisitFunc) hcl.Diagnostics { |
17 | diags := f(node) | 17 | diags := f(node) |
18 | node.walkChildNodes(func(node Node) Node { | 18 | node.walkChildNodes(func(node Node) { |
19 | diags = append(diags, VisitAll(node, f)...) | 19 | diags = append(diags, VisitAll(node, f)...) |
20 | return node | ||
21 | }) | 20 | }) |
22 | return diags | 21 | return diags |
23 | } | 22 | } |
@@ -33,45 +32,10 @@ type Walker interface { | |||
33 | // Enter and Exit functions. | 32 | // Enter and Exit functions. |
34 | func Walk(node Node, w Walker) hcl.Diagnostics { | 33 | func Walk(node Node, w Walker) hcl.Diagnostics { |
35 | diags := w.Enter(node) | 34 | diags := w.Enter(node) |
36 | node.walkChildNodes(func(node Node) Node { | 35 | node.walkChildNodes(func(node Node) { |
37 | diags = append(diags, Walk(node, w)...) | 36 | diags = append(diags, Walk(node, w)...) |
38 | return node | ||
39 | }) | 37 | }) |
38 | moreDiags := w.Exit(node) | ||
39 | diags = append(diags, moreDiags...) | ||
40 | return diags | 40 | return diags |
41 | } | 41 | } |
42 | |||
43 | // Transformer is an interface used with Transform | ||
44 | type Transformer interface { | ||
45 | // Transform accepts a node and returns a replacement node along with | ||
46 | // a flag for whether to also visit child nodes. If the flag is false, | ||
47 | // none of the child nodes will be visited and the TransformExit method | ||
48 | // will not be called for the node. | ||
49 | // | ||
50 | // It is acceptable and appropriate for Transform to return the same node | ||
51 | // it was given, for situations where no transform is needed. | ||
52 | Transform(node Node) (Node, bool, hcl.Diagnostics) | ||
53 | |||
54 | // TransformExit signals the end of transformations of child nodes of the | ||
55 | // given node. If Transform returned a new node, the given node is the | ||
56 | // node that was returned, rather than the node that was originally | ||
57 | // encountered. | ||
58 | TransformExit(node Node) hcl.Diagnostics | ||
59 | } | ||
60 | |||
61 | // Transform allows for in-place transformations of an AST starting with a | ||
62 | // particular node. The provider Transformer implementation drives the | ||
63 | // transformation process. The return value is the node that replaced the | ||
64 | // given top-level node. | ||
65 | func Transform(node Node, t Transformer) (Node, hcl.Diagnostics) { | ||
66 | newNode, descend, diags := t.Transform(node) | ||
67 | if !descend { | ||
68 | return newNode, diags | ||
69 | } | ||
70 | node.walkChildNodes(func(node Node) Node { | ||
71 | newNode, newDiags := Transform(node, t) | ||
72 | diags = append(diags, newDiags...) | ||
73 | return newNode | ||
74 | }) | ||
75 | diags = append(diags, t.TransformExit(newNode)...) | ||
76 | return newNode, diags | ||
77 | } | ||
diff --git a/vendor/github.com/hashicorp/hcl2/hcl/json/parser.go b/vendor/github.com/hashicorp/hcl2/hcl/json/parser.go index 246fd1c..d368ea8 100644 --- a/vendor/github.com/hashicorp/hcl2/hcl/json/parser.go +++ b/vendor/github.com/hashicorp/hcl2/hcl/json/parser.go | |||
@@ -3,9 +3,9 @@ package json | |||
3 | import ( | 3 | import ( |
4 | "encoding/json" | 4 | "encoding/json" |
5 | "fmt" | 5 | "fmt" |
6 | "math/big" | ||
7 | 6 | ||
8 | "github.com/hashicorp/hcl2/hcl" | 7 | "github.com/hashicorp/hcl2/hcl" |
8 | "github.com/zclconf/go-cty/cty" | ||
9 | ) | 9 | ) |
10 | 10 | ||
11 | func parseFileContent(buf []byte, filename string) (node, hcl.Diagnostics) { | 11 | func parseFileContent(buf []byte, filename string) (node, hcl.Diagnostics) { |
@@ -55,7 +55,7 @@ func parseValue(p *peeker) (node, hcl.Diagnostics) { | |||
55 | return wrapInvalid(nil, hcl.Diagnostics{ | 55 | return wrapInvalid(nil, hcl.Diagnostics{ |
56 | { | 56 | { |
57 | Severity: hcl.DiagError, | 57 | Severity: hcl.DiagError, |
58 | Summary: "Missing attribute value", | 58 | Summary: "Missing JSON value", |
59 | Detail: "A JSON value must start with a brace, a bracket, a number, a string, or a keyword.", | 59 | Detail: "A JSON value must start with a brace, a bracket, a number, a string, or a keyword.", |
60 | Subject: &tok.Range, | 60 | Subject: &tok.Range, |
61 | }, | 61 | }, |
@@ -144,8 +144,8 @@ Token: | |||
144 | if !ok { | 144 | if !ok { |
145 | return nil, diags.Append(&hcl.Diagnostic{ | 145 | return nil, diags.Append(&hcl.Diagnostic{ |
146 | Severity: hcl.DiagError, | 146 | Severity: hcl.DiagError, |
147 | Summary: "Invalid object attribute name", | 147 | Summary: "Invalid object property name", |
148 | Detail: "A JSON object attribute name must be a string", | 148 | Detail: "A JSON object property name must be a string", |
149 | Subject: keyNode.StartRange().Ptr(), | 149 | Subject: keyNode.StartRange().Ptr(), |
150 | }) | 150 | }) |
151 | } | 151 | } |
@@ -171,7 +171,7 @@ Token: | |||
171 | // Possible confusion with native HCL syntax. | 171 | // Possible confusion with native HCL syntax. |
172 | return nil, diags.Append(&hcl.Diagnostic{ | 172 | return nil, diags.Append(&hcl.Diagnostic{ |
173 | Severity: hcl.DiagError, | 173 | Severity: hcl.DiagError, |
174 | Summary: "Missing attribute value colon", | 174 | Summary: "Missing property value colon", |
175 | Detail: "JSON uses a colon as its name/value delimiter, not an equals sign.", | 175 | Detail: "JSON uses a colon as its name/value delimiter, not an equals sign.", |
176 | Subject: &colon.Range, | 176 | Subject: &colon.Range, |
177 | }) | 177 | }) |
@@ -179,8 +179,8 @@ Token: | |||
179 | 179 | ||
180 | return nil, diags.Append(&hcl.Diagnostic{ | 180 | return nil, diags.Append(&hcl.Diagnostic{ |
181 | Severity: hcl.DiagError, | 181 | Severity: hcl.DiagError, |
182 | Summary: "Missing attribute value colon", | 182 | Summary: "Missing property value colon", |
183 | Detail: "A colon must appear between an object attribute's name and its value.", | 183 | Detail: "A colon must appear between an object property's name and its value.", |
184 | Subject: &colon.Range, | 184 | Subject: &colon.Range, |
185 | }) | 185 | }) |
186 | } | 186 | } |
@@ -205,7 +205,7 @@ Token: | |||
205 | return nil, diags.Append(&hcl.Diagnostic{ | 205 | return nil, diags.Append(&hcl.Diagnostic{ |
206 | Severity: hcl.DiagError, | 206 | Severity: hcl.DiagError, |
207 | Summary: "Trailing comma in object", | 207 | Summary: "Trailing comma in object", |
208 | Detail: "JSON does not permit a trailing comma after the final attribute in an object.", | 208 | Detail: "JSON does not permit a trailing comma after the final property in an object.", |
209 | Subject: &comma.Range, | 209 | Subject: &comma.Range, |
210 | }) | 210 | }) |
211 | } | 211 | } |
@@ -234,7 +234,7 @@ Token: | |||
234 | return nil, diags.Append(&hcl.Diagnostic{ | 234 | return nil, diags.Append(&hcl.Diagnostic{ |
235 | Severity: hcl.DiagError, | 235 | Severity: hcl.DiagError, |
236 | Summary: "Missing attribute seperator comma", | 236 | Summary: "Missing attribute seperator comma", |
237 | Detail: "A comma must appear between each attribute declaration in an object.", | 237 | Detail: "A comma must appear between each property definition in an object.", |
238 | Subject: p.Peek().Range.Ptr(), | 238 | Subject: p.Peek().Range.Ptr(), |
239 | }) | 239 | }) |
240 | } | 240 | } |
@@ -301,7 +301,7 @@ Token: | |||
301 | return nil, diags.Append(&hcl.Diagnostic{ | 301 | return nil, diags.Append(&hcl.Diagnostic{ |
302 | Severity: hcl.DiagError, | 302 | Severity: hcl.DiagError, |
303 | Summary: "Trailing comma in array", | 303 | Summary: "Trailing comma in array", |
304 | Detail: "JSON does not permit a trailing comma after the final attribute in an array.", | 304 | Detail: "JSON does not permit a trailing comma after the final value in an array.", |
305 | Subject: &comma.Range, | 305 | Subject: &comma.Range, |
306 | }) | 306 | }) |
307 | } | 307 | } |
@@ -370,10 +370,15 @@ func parseNumber(p *peeker) (node, hcl.Diagnostics) { | |||
370 | } | 370 | } |
371 | } | 371 | } |
372 | 372 | ||
373 | f, _, err := big.ParseFloat(string(num), 10, 512, big.ToNearestEven) | 373 | // We want to guarantee that we parse numbers the same way as cty (and thus |
374 | // native syntax HCL) would here, so we'll use the cty parser even though | ||
375 | // in most other cases we don't actually introduce cty concepts until | ||
376 | // decoding time. We'll unwrap the parsed float immediately afterwards, so | ||
377 | // the cty value is just a temporary helper. | ||
378 | nv, err := cty.ParseNumberVal(string(num)) | ||
374 | if err != nil { | 379 | if err != nil { |
375 | // Should never happen if above passed, since JSON numbers are a subset | 380 | // Should never happen if above passed, since JSON numbers are a subset |
376 | // of what big.Float can parse... | 381 | // of what cty can parse... |
377 | return nil, hcl.Diagnostics{ | 382 | return nil, hcl.Diagnostics{ |
378 | { | 383 | { |
379 | Severity: hcl.DiagError, | 384 | Severity: hcl.DiagError, |
@@ -385,7 +390,7 @@ func parseNumber(p *peeker) (node, hcl.Diagnostics) { | |||
385 | } | 390 | } |
386 | 391 | ||
387 | return &numberVal{ | 392 | return &numberVal{ |
388 | Value: f, | 393 | Value: nv.AsBigFloat(), |
389 | SrcRange: tok.Range, | 394 | SrcRange: tok.Range, |
390 | }, nil | 395 | }, nil |
391 | } | 396 | } |
diff --git a/vendor/github.com/hashicorp/hcl2/hcl/json/scanner.go b/vendor/github.com/hashicorp/hcl2/hcl/json/scanner.go index 0a8378b..da72884 100644 --- a/vendor/github.com/hashicorp/hcl2/hcl/json/scanner.go +++ b/vendor/github.com/hashicorp/hcl2/hcl/json/scanner.go | |||
@@ -153,7 +153,7 @@ func byteCanStartKeyword(b byte) bool { | |||
153 | // in the parser, where we can generate better diagnostics. | 153 | // in the parser, where we can generate better diagnostics. |
154 | // So e.g. we want to be able to say: | 154 | // So e.g. we want to be able to say: |
155 | // unrecognized keyword "True". Did you mean "true"? | 155 | // unrecognized keyword "True". Did you mean "true"? |
156 | case b >= 'a' || b <= 'z' || b >= 'A' || b <= 'Z': | 156 | case isAlphabetical(b): |
157 | return true | 157 | return true |
158 | default: | 158 | default: |
159 | return false | 159 | return false |
@@ -167,7 +167,7 @@ Byte: | |||
167 | for i = 0; i < len(buf); i++ { | 167 | for i = 0; i < len(buf); i++ { |
168 | b := buf[i] | 168 | b := buf[i] |
169 | switch { | 169 | switch { |
170 | case (b >= 'a' && b <= 'z') || (b >= 'A' && b <= 'Z') || b == '_': | 170 | case isAlphabetical(b) || b == '_': |
171 | p.Pos.Byte++ | 171 | p.Pos.Byte++ |
172 | p.Pos.Column++ | 172 | p.Pos.Column++ |
173 | default: | 173 | default: |
@@ -291,3 +291,7 @@ func posRange(start, end pos) hcl.Range { | |||
291 | func (t token) GoString() string { | 291 | func (t token) GoString() string { |
292 | return fmt.Sprintf("json.token{json.%s, []byte(%q), %#v}", t.Type, t.Bytes, t.Range) | 292 | return fmt.Sprintf("json.token{json.%s, []byte(%q), %#v}", t.Type, t.Bytes, t.Range) |
293 | } | 293 | } |
294 | |||
295 | func isAlphabetical(b byte) bool { | ||
296 | return (b >= 'a' && b <= 'z') || (b >= 'A' && b <= 'Z') | ||
297 | } | ||
diff --git a/vendor/github.com/hashicorp/hcl2/hcl/json/spec.md b/vendor/github.com/hashicorp/hcl2/hcl/json/spec.md index 9b33c7f..dac5729 100644 --- a/vendor/github.com/hashicorp/hcl2/hcl/json/spec.md +++ b/vendor/github.com/hashicorp/hcl2/hcl/json/spec.md | |||
@@ -5,7 +5,7 @@ for defining configuration languages for applications. The HCL information | |||
5 | model is designed to support multiple concrete syntaxes for configuration, | 5 | model is designed to support multiple concrete syntaxes for configuration, |
6 | and this JSON-based format complements [the native syntax](../hclsyntax/spec.md) | 6 | and this JSON-based format complements [the native syntax](../hclsyntax/spec.md) |
7 | by being easy to machine-generate, whereas the native syntax is oriented | 7 | by being easy to machine-generate, whereas the native syntax is oriented |
8 | towards human authoring and maintenence. | 8 | towards human authoring and maintenance |
9 | 9 | ||
10 | This syntax is defined in terms of JSON as defined in | 10 | This syntax is defined in terms of JSON as defined in |
11 | [RFC7159](https://tools.ietf.org/html/rfc7159). As such it inherits the JSON | 11 | [RFC7159](https://tools.ietf.org/html/rfc7159). As such it inherits the JSON |
@@ -18,11 +18,11 @@ _Parsing_ such JSON has some additional constraints not beyond what is normally | |||
18 | supported by JSON parsers, so a specialized parser may be required that | 18 | supported by JSON parsers, so a specialized parser may be required that |
19 | is able to: | 19 | is able to: |
20 | 20 | ||
21 | * Preserve the relative ordering of properties defined in an object. | 21 | - Preserve the relative ordering of properties defined in an object. |
22 | * Preserve multiple definitions of the same property name. | 22 | - Preserve multiple definitions of the same property name. |
23 | * Preserve numeric values to the precision required by the number type | 23 | - Preserve numeric values to the precision required by the number type |
24 | in [the HCL syntax-agnostic information model](../spec.md). | 24 | in [the HCL syntax-agnostic information model](../spec.md). |
25 | * Retain source location information for parsed tokens/constructs in order | 25 | - Retain source location information for parsed tokens/constructs in order |
26 | to produce good error messages. | 26 | to produce good error messages. |
27 | 27 | ||
28 | ## Structural Elements | 28 | ## Structural Elements |
@@ -118,6 +118,7 @@ type: | |||
118 | ] | 118 | ] |
119 | } | 119 | } |
120 | ``` | 120 | ``` |
121 | |||
121 | ```json | 122 | ```json |
122 | { | 123 | { |
123 | "foo": [] | 124 | "foo": [] |
@@ -147,7 +148,7 @@ the following examples: | |||
147 | "boz": { | 148 | "boz": { |
148 | "baz": { | 149 | "baz": { |
149 | "child_attr": "baz" | 150 | "child_attr": "baz" |
150 | }, | 151 | } |
151 | } | 152 | } |
152 | } | 153 | } |
153 | } | 154 | } |
@@ -189,7 +190,7 @@ the following examples: | |||
189 | "boz": { | 190 | "boz": { |
190 | "child_attr": "baz" | 191 | "child_attr": "baz" |
191 | } | 192 | } |
192 | }, | 193 | } |
193 | }, | 194 | }, |
194 | { | 195 | { |
195 | "bar": { | 196 | "bar": { |
@@ -280,9 +281,9 @@ When interpreted as an expression, a JSON array represents a value of a HCL | |||
280 | tuple type. | 281 | tuple type. |
281 | 282 | ||
282 | Each element of the JSON array represents an element of the HCL tuple type. | 283 | Each element of the JSON array represents an element of the HCL tuple type. |
283 | The tuple type is constructed by enumerationg the JSON array elements, creating | 284 | The tuple type is constructed by enumerating the JSON array elements, creating |
284 | for each an element whose type is the result of recursively applying the | 285 | for each an element whose type is the result of recursively applying the |
285 | expression mapping rules. Correspondance is preserved between the array element | 286 | expression mapping rules. Correspondence is preserved between the array element |
286 | indices and the tuple element indices. | 287 | indices and the tuple element indices. |
287 | 288 | ||
288 | An instance of the constructed tuple type is then created, whose values are | 289 | An instance of the constructed tuple type is then created, whose values are |
@@ -325,7 +326,7 @@ HCL null value of the dynamic pseudo-type. | |||
325 | 326 | ||
326 | ### Strings | 327 | ### Strings |
327 | 328 | ||
328 | When intepreted as an expression, a JSON string may be interpreted in one of | 329 | When interpreted as an expression, a JSON string may be interpreted in one of |
329 | two ways depending on the evaluation mode. | 330 | two ways depending on the evaluation mode. |
330 | 331 | ||
331 | If evaluating in literal-only mode (as defined by the syntax-agnostic | 332 | If evaluating in literal-only mode (as defined by the syntax-agnostic |
@@ -402,4 +403,3 @@ to that expression. | |||
402 | 403 | ||
403 | If the original expression is not a string or its contents cannot be parsed | 404 | If the original expression is not a string or its contents cannot be parsed |
404 | as a native syntax expression then static call analysis is not supported. | 405 | as a native syntax expression then static call analysis is not supported. |
405 | |||
diff --git a/vendor/github.com/hashicorp/hcl2/hcl/json/structure.go b/vendor/github.com/hashicorp/hcl2/hcl/json/structure.go index 28dcf52..bdc0e98 100644 --- a/vendor/github.com/hashicorp/hcl2/hcl/json/structure.go +++ b/vendor/github.com/hashicorp/hcl2/hcl/json/structure.go | |||
@@ -64,7 +64,7 @@ func (b *body) Content(schema *hcl.BodySchema) (*hcl.BodyContent, hcl.Diagnostic | |||
64 | diags = append(diags, &hcl.Diagnostic{ | 64 | diags = append(diags, &hcl.Diagnostic{ |
65 | Severity: hcl.DiagError, | 65 | Severity: hcl.DiagError, |
66 | Summary: "Extraneous JSON object property", | 66 | Summary: "Extraneous JSON object property", |
67 | Detail: fmt.Sprintf("No attribute or block type is named %q.%s", k, suggestion), | 67 | Detail: fmt.Sprintf("No argument or block type is named %q.%s", k, suggestion), |
68 | Subject: &attr.NameRange, | 68 | Subject: &attr.NameRange, |
69 | Context: attr.Range().Ptr(), | 69 | Context: attr.Range().Ptr(), |
70 | }) | 70 | }) |
@@ -114,8 +114,8 @@ func (b *body) PartialContent(schema *hcl.BodySchema) (*hcl.BodyContent, hcl.Bod | |||
114 | if existing, exists := content.Attributes[attrName]; exists { | 114 | if existing, exists := content.Attributes[attrName]; exists { |
115 | diags = append(diags, &hcl.Diagnostic{ | 115 | diags = append(diags, &hcl.Diagnostic{ |
116 | Severity: hcl.DiagError, | 116 | Severity: hcl.DiagError, |
117 | Summary: "Duplicate attribute definition", | 117 | Summary: "Duplicate argument", |
118 | Detail: fmt.Sprintf("The attribute %q was already defined at %s.", attrName, existing.Range), | 118 | Detail: fmt.Sprintf("The argument %q was already set at %s.", attrName, existing.Range), |
119 | Subject: &jsonAttr.NameRange, | 119 | Subject: &jsonAttr.NameRange, |
120 | Context: jsonAttr.Range().Ptr(), | 120 | Context: jsonAttr.Range().Ptr(), |
121 | }) | 121 | }) |
@@ -149,8 +149,8 @@ func (b *body) PartialContent(schema *hcl.BodySchema) (*hcl.BodyContent, hcl.Bod | |||
149 | if _, defined := content.Attributes[attrS.Name]; !defined { | 149 | if _, defined := content.Attributes[attrS.Name]; !defined { |
150 | diags = append(diags, &hcl.Diagnostic{ | 150 | diags = append(diags, &hcl.Diagnostic{ |
151 | Severity: hcl.DiagError, | 151 | Severity: hcl.DiagError, |
152 | Summary: "Missing required attribute", | 152 | Summary: "Missing required argument", |
153 | Detail: fmt.Sprintf("The attribute %q is required, but no definition was found.", attrS.Name), | 153 | Detail: fmt.Sprintf("The argument %q is required, but no definition was found.", attrS.Name), |
154 | Subject: b.MissingItemRange().Ptr(), | 154 | Subject: b.MissingItemRange().Ptr(), |
155 | }) | 155 | }) |
156 | } | 156 | } |
@@ -175,7 +175,7 @@ func (b *body) JustAttributes() (hcl.Attributes, hcl.Diagnostics) { | |||
175 | diags = append(diags, &hcl.Diagnostic{ | 175 | diags = append(diags, &hcl.Diagnostic{ |
176 | Severity: hcl.DiagError, | 176 | Severity: hcl.DiagError, |
177 | Summary: "Incorrect JSON value type", | 177 | Summary: "Incorrect JSON value type", |
178 | Detail: "A JSON object is required here, defining the attributes for this block.", | 178 | Detail: "A JSON object is required here, setting the arguments for this block.", |
179 | Subject: b.val.StartRange().Ptr(), | 179 | Subject: b.val.StartRange().Ptr(), |
180 | }) | 180 | }) |
181 | return attrs, diags | 181 | return attrs, diags |
@@ -197,7 +197,7 @@ func (b *body) JustAttributes() (hcl.Attributes, hcl.Diagnostics) { | |||
197 | diags = append(diags, &hcl.Diagnostic{ | 197 | diags = append(diags, &hcl.Diagnostic{ |
198 | Severity: hcl.DiagError, | 198 | Severity: hcl.DiagError, |
199 | Summary: "Duplicate attribute definition", | 199 | Summary: "Duplicate attribute definition", |
200 | Detail: fmt.Sprintf("The attribute %q was already defined at %s.", name, existing.Range), | 200 | Detail: fmt.Sprintf("The argument %q was already set at %s.", name, existing.Range), |
201 | Subject: &jsonAttr.NameRange, | 201 | Subject: &jsonAttr.NameRange, |
202 | }) | 202 | }) |
203 | continue | 203 | continue |
@@ -266,6 +266,9 @@ func (b *body) unpackBlock(v node, typeName string, typeRange *hcl.Range, labels | |||
266 | copy(labelR, labelRanges) | 266 | copy(labelR, labelRanges) |
267 | 267 | ||
268 | switch tv := v.(type) { | 268 | switch tv := v.(type) { |
269 | case *nullVal: | ||
270 | // There is no block content, e.g the value is null. | ||
271 | return | ||
269 | case *objectVal: | 272 | case *objectVal: |
270 | // Single instance of the block | 273 | // Single instance of the block |
271 | *blocks = append(*blocks, &hcl.Block{ | 274 | *blocks = append(*blocks, &hcl.Block{ |
@@ -324,6 +327,8 @@ func (b *body) collectDeepAttrs(v node, labelName *string) ([]*objectAttr, hcl.D | |||
324 | var attrs []*objectAttr | 327 | var attrs []*objectAttr |
325 | 328 | ||
326 | switch tv := v.(type) { | 329 | switch tv := v.(type) { |
330 | case *nullVal: | ||
331 | // If a value is null, then we don't return any attributes or return an error. | ||
327 | 332 | ||
328 | case *objectVal: | 333 | case *objectVal: |
329 | attrs = append(attrs, tv.Attrs...) | 334 | attrs = append(attrs, tv.Attrs...) |
@@ -345,7 +350,7 @@ func (b *body) collectDeepAttrs(v node, labelName *string) ([]*objectAttr, hcl.D | |||
345 | diags = append(diags, &hcl.Diagnostic{ | 350 | diags = append(diags, &hcl.Diagnostic{ |
346 | Severity: hcl.DiagError, | 351 | Severity: hcl.DiagError, |
347 | Summary: "Incorrect JSON value type", | 352 | Summary: "Incorrect JSON value type", |
348 | Detail: "A JSON object is required here, to define attributes and child blocks.", | 353 | Detail: "A JSON object is required here, to define arguments and child blocks.", |
349 | Subject: ev.StartRange().Ptr(), | 354 | Subject: ev.StartRange().Ptr(), |
350 | }) | 355 | }) |
351 | } | 356 | } |
@@ -364,7 +369,7 @@ func (b *body) collectDeepAttrs(v node, labelName *string) ([]*objectAttr, hcl.D | |||
364 | diags = append(diags, &hcl.Diagnostic{ | 369 | diags = append(diags, &hcl.Diagnostic{ |
365 | Severity: hcl.DiagError, | 370 | Severity: hcl.DiagError, |
366 | Summary: "Incorrect JSON value type", | 371 | Summary: "Incorrect JSON value type", |
367 | Detail: "Either a JSON object or JSON array of objects is required here, to define attributes and child blocks.", | 372 | Detail: "Either a JSON object or JSON array of objects is required here, to define arguments and child blocks.", |
368 | Subject: v.StartRange().Ptr(), | 373 | Subject: v.StartRange().Ptr(), |
369 | }) | 374 | }) |
370 | } | 375 | } |
@@ -424,7 +429,7 @@ func (e *expression) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) { | |||
424 | known := true | 429 | known := true |
425 | for _, jsonAttr := range v.Attrs { | 430 | for _, jsonAttr := range v.Attrs { |
426 | // In this one context we allow keys to contain interpolation | 431 | // In this one context we allow keys to contain interpolation |
427 | // experessions too, assuming we're evaluating in interpolation | 432 | // expressions too, assuming we're evaluating in interpolation |
428 | // mode. This achieves parity with the native syntax where | 433 | // mode. This achieves parity with the native syntax where |
429 | // object expressions can have dynamic keys, while block contents | 434 | // object expressions can have dynamic keys, while block contents |
430 | // may not. | 435 | // may not. |
@@ -432,7 +437,8 @@ func (e *expression) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) { | |||
432 | Value: jsonAttr.Name, | 437 | Value: jsonAttr.Name, |
433 | SrcRange: jsonAttr.NameRange, | 438 | SrcRange: jsonAttr.NameRange, |
434 | }}).Value(ctx) | 439 | }}).Value(ctx) |
435 | val, valDiags := (&expression{src: jsonAttr.Value}).Value(ctx) | 440 | valExpr := &expression{src: jsonAttr.Value} |
441 | val, valDiags := valExpr.Value(ctx) | ||
436 | diags = append(diags, nameDiags...) | 442 | diags = append(diags, nameDiags...) |
437 | diags = append(diags, valDiags...) | 443 | diags = append(diags, valDiags...) |
438 | 444 | ||
@@ -440,19 +446,23 @@ func (e *expression) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) { | |||
440 | name, err = convert.Convert(name, cty.String) | 446 | name, err = convert.Convert(name, cty.String) |
441 | if err != nil { | 447 | if err != nil { |
442 | diags = append(diags, &hcl.Diagnostic{ | 448 | diags = append(diags, &hcl.Diagnostic{ |
443 | Severity: hcl.DiagError, | 449 | Severity: hcl.DiagError, |
444 | Summary: "Invalid object key expression", | 450 | Summary: "Invalid object key expression", |
445 | Detail: fmt.Sprintf("Cannot use this expression as an object key: %s.", err), | 451 | Detail: fmt.Sprintf("Cannot use this expression as an object key: %s.", err), |
446 | Subject: &jsonAttr.NameRange, | 452 | Subject: &jsonAttr.NameRange, |
453 | Expression: valExpr, | ||
454 | EvalContext: ctx, | ||
447 | }) | 455 | }) |
448 | continue | 456 | continue |
449 | } | 457 | } |
450 | if name.IsNull() { | 458 | if name.IsNull() { |
451 | diags = append(diags, &hcl.Diagnostic{ | 459 | diags = append(diags, &hcl.Diagnostic{ |
452 | Severity: hcl.DiagError, | 460 | Severity: hcl.DiagError, |
453 | Summary: "Invalid object key expression", | 461 | Summary: "Invalid object key expression", |
454 | Detail: "Cannot use null value as an object key.", | 462 | Detail: "Cannot use null value as an object key.", |
455 | Subject: &jsonAttr.NameRange, | 463 | Subject: &jsonAttr.NameRange, |
464 | Expression: valExpr, | ||
465 | EvalContext: ctx, | ||
456 | }) | 466 | }) |
457 | continue | 467 | continue |
458 | } | 468 | } |
@@ -471,10 +481,12 @@ func (e *expression) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) { | |||
471 | nameStr := name.AsString() | 481 | nameStr := name.AsString() |
472 | if _, defined := attrs[nameStr]; defined { | 482 | if _, defined := attrs[nameStr]; defined { |
473 | diags = append(diags, &hcl.Diagnostic{ | 483 | diags = append(diags, &hcl.Diagnostic{ |
474 | Severity: hcl.DiagError, | 484 | Severity: hcl.DiagError, |
475 | Summary: "Duplicate object attribute", | 485 | Summary: "Duplicate object attribute", |
476 | Detail: fmt.Sprintf("An attribute named %q was already defined at %s.", nameStr, attrRanges[nameStr]), | 486 | Detail: fmt.Sprintf("An attribute named %q was already defined at %s.", nameStr, attrRanges[nameStr]), |
477 | Subject: &jsonAttr.NameRange, | 487 | Subject: &jsonAttr.NameRange, |
488 | Expression: e, | ||
489 | EvalContext: ctx, | ||
478 | }) | 490 | }) |
479 | continue | 491 | continue |
480 | } | 492 | } |
@@ -487,6 +499,8 @@ func (e *expression) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) { | |||
487 | return cty.DynamicVal, diags | 499 | return cty.DynamicVal, diags |
488 | } | 500 | } |
489 | return cty.ObjectVal(attrs), diags | 501 | return cty.ObjectVal(attrs), diags |
502 | case *nullVal: | ||
503 | return cty.NullVal(cty.DynamicPseudoType), nil | ||
490 | default: | 504 | default: |
491 | // Default to DynamicVal so that ASTs containing invalid nodes can | 505 | // Default to DynamicVal so that ASTs containing invalid nodes can |
492 | // still be partially-evaluated. | 506 | // still be partially-evaluated. |
@@ -526,6 +540,11 @@ func (e *expression) Variables() []hcl.Traversal { | |||
526 | } | 540 | } |
527 | case *objectVal: | 541 | case *objectVal: |
528 | for _, jsonAttr := range v.Attrs { | 542 | for _, jsonAttr := range v.Attrs { |
543 | keyExpr := &stringVal{ // we're going to treat key as an expression in this context | ||
544 | Value: jsonAttr.Name, | ||
545 | SrcRange: jsonAttr.NameRange, | ||
546 | } | ||
547 | vars = append(vars, (&expression{src: keyExpr}).Variables()...) | ||
529 | vars = append(vars, (&expression{src: jsonAttr.Value}).Variables()...) | 548 | vars = append(vars, (&expression{src: jsonAttr.Value}).Variables()...) |
530 | } | 549 | } |
531 | } | 550 | } |
diff --git a/vendor/github.com/hashicorp/hcl2/hcl/merged.go b/vendor/github.com/hashicorp/hcl2/hcl/merged.go index ca2b728..96e62a5 100644 --- a/vendor/github.com/hashicorp/hcl2/hcl/merged.go +++ b/vendor/github.com/hashicorp/hcl2/hcl/merged.go | |||
@@ -109,9 +109,9 @@ func (mb mergedBodies) JustAttributes() (Attributes, Diagnostics) { | |||
109 | if existing := attrs[name]; existing != nil { | 109 | if existing := attrs[name]; existing != nil { |
110 | diags = diags.Append(&Diagnostic{ | 110 | diags = diags.Append(&Diagnostic{ |
111 | Severity: DiagError, | 111 | Severity: DiagError, |
112 | Summary: "Duplicate attribute", | 112 | Summary: "Duplicate argument", |
113 | Detail: fmt.Sprintf( | 113 | Detail: fmt.Sprintf( |
114 | "Attribute %q was already assigned at %s", | 114 | "Argument %q was already set at %s", |
115 | name, existing.NameRange.String(), | 115 | name, existing.NameRange.String(), |
116 | ), | 116 | ), |
117 | Subject: &attr.NameRange, | 117 | Subject: &attr.NameRange, |
@@ -171,7 +171,7 @@ func (mb mergedBodies) mergedContent(schema *BodySchema, partial bool) (*BodyCon | |||
171 | } | 171 | } |
172 | 172 | ||
173 | if thisLeftovers != nil { | 173 | if thisLeftovers != nil { |
174 | mergedLeftovers = append(mergedLeftovers) | 174 | mergedLeftovers = append(mergedLeftovers, thisLeftovers) |
175 | } | 175 | } |
176 | if len(thisDiags) != 0 { | 176 | if len(thisDiags) != 0 { |
177 | diags = append(diags, thisDiags...) | 177 | diags = append(diags, thisDiags...) |
@@ -182,9 +182,9 @@ func (mb mergedBodies) mergedContent(schema *BodySchema, partial bool) (*BodyCon | |||
182 | if existing := content.Attributes[name]; existing != nil { | 182 | if existing := content.Attributes[name]; existing != nil { |
183 | diags = diags.Append(&Diagnostic{ | 183 | diags = diags.Append(&Diagnostic{ |
184 | Severity: DiagError, | 184 | Severity: DiagError, |
185 | Summary: "Duplicate attribute", | 185 | Summary: "Duplicate argument", |
186 | Detail: fmt.Sprintf( | 186 | Detail: fmt.Sprintf( |
187 | "Attribute %q was already assigned at %s", | 187 | "Argument %q was already set at %s", |
188 | name, existing.NameRange.String(), | 188 | name, existing.NameRange.String(), |
189 | ), | 189 | ), |
190 | Subject: &attr.NameRange, | 190 | Subject: &attr.NameRange, |
@@ -212,9 +212,9 @@ func (mb mergedBodies) mergedContent(schema *BodySchema, partial bool) (*BodyCon | |||
212 | // use of required attributes on merged bodies. | 212 | // use of required attributes on merged bodies. |
213 | diags = diags.Append(&Diagnostic{ | 213 | diags = diags.Append(&Diagnostic{ |
214 | Severity: DiagError, | 214 | Severity: DiagError, |
215 | Summary: "Missing required attribute", | 215 | Summary: "Missing required argument", |
216 | Detail: fmt.Sprintf( | 216 | Detail: fmt.Sprintf( |
217 | "The attribute %q is required, but was not assigned.", | 217 | "The argument %q is required, but was not set.", |
218 | attrS.Name, | 218 | attrS.Name, |
219 | ), | 219 | ), |
220 | }) | 220 | }) |
diff --git a/vendor/github.com/hashicorp/hcl2/hcl/ops.go b/vendor/github.com/hashicorp/hcl2/hcl/ops.go index f4e30b0..5d2910c 100644 --- a/vendor/github.com/hashicorp/hcl2/hcl/ops.go +++ b/vendor/github.com/hashicorp/hcl2/hcl/ops.go | |||
@@ -2,6 +2,7 @@ package hcl | |||
2 | 2 | ||
3 | import ( | 3 | import ( |
4 | "fmt" | 4 | "fmt" |
5 | "math/big" | ||
5 | 6 | ||
6 | "github.com/zclconf/go-cty/cty" | 7 | "github.com/zclconf/go-cty/cty" |
7 | "github.com/zclconf/go-cty/cty/convert" | 8 | "github.com/zclconf/go-cty/cty/convert" |
@@ -84,6 +85,27 @@ func Index(collection, key cty.Value, srcRange *Range) (cty.Value, Diagnostics) | |||
84 | } | 85 | } |
85 | } | 86 | } |
86 | if has.False() { | 87 | if has.False() { |
88 | // We have a more specialized error message for the situation of | ||
89 | // using a fractional number to index into a sequence, because | ||
90 | // that will tend to happen if the user is trying to use division | ||
91 | // to calculate an index and not realizing that HCL does float | ||
92 | // division rather than integer division. | ||
93 | if (ty.IsListType() || ty.IsTupleType()) && key.Type().Equals(cty.Number) { | ||
94 | if key.IsKnown() && !key.IsNull() { | ||
95 | bf := key.AsBigFloat() | ||
96 | if _, acc := bf.Int(nil); acc != big.Exact { | ||
97 | return cty.DynamicVal, Diagnostics{ | ||
98 | { | ||
99 | Severity: DiagError, | ||
100 | Summary: "Invalid index", | ||
101 | Detail: fmt.Sprintf("The given key does not identify an element in this collection value: indexing a sequence requires a whole number, but the given index (%g) has a fractional part.", bf), | ||
102 | Subject: srcRange, | ||
103 | }, | ||
104 | } | ||
105 | } | ||
106 | } | ||
107 | } | ||
108 | |||
87 | return cty.DynamicVal, Diagnostics{ | 109 | return cty.DynamicVal, Diagnostics{ |
88 | { | 110 | { |
89 | Severity: DiagError, | 111 | Severity: DiagError, |
@@ -145,3 +167,122 @@ func Index(collection, key cty.Value, srcRange *Range) (cty.Value, Diagnostics) | |||
145 | } | 167 | } |
146 | 168 | ||
147 | } | 169 | } |
170 | |||
171 | // GetAttr is a helper function that performs the same operation as the | ||
172 | // attribute access in the HCL expression language. That is, the result is the | ||
173 | // same as it would be for obj.attr in a configuration expression. | ||
174 | // | ||
175 | // This is exported so that applications can access attributes in a manner | ||
176 | // consistent with how the language does it, including handling of null and | ||
177 | // unknown values, etc. | ||
178 | // | ||
179 | // Diagnostics are produced if the given combination of values is not valid. | ||
180 | // Therefore a pointer to a source range must be provided to use in diagnostics, | ||
181 | // though nil can be provided if the calling application is going to | ||
182 | // ignore the subject of the returned diagnostics anyway. | ||
183 | func GetAttr(obj cty.Value, attrName string, srcRange *Range) (cty.Value, Diagnostics) { | ||
184 | if obj.IsNull() { | ||
185 | return cty.DynamicVal, Diagnostics{ | ||
186 | { | ||
187 | Severity: DiagError, | ||
188 | Summary: "Attempt to get attribute from null value", | ||
189 | Detail: "This value is null, so it does not have any attributes.", | ||
190 | Subject: srcRange, | ||
191 | }, | ||
192 | } | ||
193 | } | ||
194 | |||
195 | ty := obj.Type() | ||
196 | switch { | ||
197 | case ty.IsObjectType(): | ||
198 | if !ty.HasAttribute(attrName) { | ||
199 | return cty.DynamicVal, Diagnostics{ | ||
200 | { | ||
201 | Severity: DiagError, | ||
202 | Summary: "Unsupported attribute", | ||
203 | Detail: fmt.Sprintf("This object does not have an attribute named %q.", attrName), | ||
204 | Subject: srcRange, | ||
205 | }, | ||
206 | } | ||
207 | } | ||
208 | |||
209 | if !obj.IsKnown() { | ||
210 | return cty.UnknownVal(ty.AttributeType(attrName)), nil | ||
211 | } | ||
212 | |||
213 | return obj.GetAttr(attrName), nil | ||
214 | case ty.IsMapType(): | ||
215 | if !obj.IsKnown() { | ||
216 | return cty.UnknownVal(ty.ElementType()), nil | ||
217 | } | ||
218 | |||
219 | idx := cty.StringVal(attrName) | ||
220 | if obj.HasIndex(idx).False() { | ||
221 | return cty.DynamicVal, Diagnostics{ | ||
222 | { | ||
223 | Severity: DiagError, | ||
224 | Summary: "Missing map element", | ||
225 | Detail: fmt.Sprintf("This map does not have an element with the key %q.", attrName), | ||
226 | Subject: srcRange, | ||
227 | }, | ||
228 | } | ||
229 | } | ||
230 | |||
231 | return obj.Index(idx), nil | ||
232 | case ty == cty.DynamicPseudoType: | ||
233 | return cty.DynamicVal, nil | ||
234 | default: | ||
235 | return cty.DynamicVal, Diagnostics{ | ||
236 | { | ||
237 | Severity: DiagError, | ||
238 | Summary: "Unsupported attribute", | ||
239 | Detail: "This value does not have any attributes.", | ||
240 | Subject: srcRange, | ||
241 | }, | ||
242 | } | ||
243 | } | ||
244 | |||
245 | } | ||
246 | |||
247 | // ApplyPath is a helper function that applies a cty.Path to a value using the | ||
248 | // indexing and attribute access operations from HCL. | ||
249 | // | ||
250 | // This is similar to calling the path's own Apply method, but ApplyPath uses | ||
251 | // the more relaxed typing rules that apply to these operations in HCL, rather | ||
252 | // than cty's relatively-strict rules. ApplyPath is implemented in terms of | ||
253 | // Index and GetAttr, and so it has the same behavior for individual steps | ||
254 | // but will stop and return any errors returned by intermediate steps. | ||
255 | // | ||
256 | // Diagnostics are produced if the given path cannot be applied to the given | ||
257 | // value. Therefore a pointer to a source range must be provided to use in | ||
258 | // diagnostics, though nil can be provided if the calling application is going | ||
259 | // to ignore the subject of the returned diagnostics anyway. | ||
260 | func ApplyPath(val cty.Value, path cty.Path, srcRange *Range) (cty.Value, Diagnostics) { | ||
261 | var diags Diagnostics | ||
262 | |||
263 | for _, step := range path { | ||
264 | var stepDiags Diagnostics | ||
265 | switch ts := step.(type) { | ||
266 | case cty.IndexStep: | ||
267 | val, stepDiags = Index(val, ts.Key, srcRange) | ||
268 | case cty.GetAttrStep: | ||
269 | val, stepDiags = GetAttr(val, ts.Name, srcRange) | ||
270 | default: | ||
271 | // Should never happen because the above are all of the step types. | ||
272 | diags = diags.Append(&Diagnostic{ | ||
273 | Severity: DiagError, | ||
274 | Summary: "Invalid path step", | ||
275 | Detail: fmt.Sprintf("Go type %T is not a valid path step. This is a bug in this program.", step), | ||
276 | Subject: srcRange, | ||
277 | }) | ||
278 | return cty.DynamicVal, diags | ||
279 | } | ||
280 | |||
281 | diags = append(diags, stepDiags...) | ||
282 | if stepDiags.HasErrors() { | ||
283 | return cty.DynamicVal, diags | ||
284 | } | ||
285 | } | ||
286 | |||
287 | return val, diags | ||
288 | } | ||
diff --git a/vendor/github.com/hashicorp/hcl2/hcl/pos.go b/vendor/github.com/hashicorp/hcl2/hcl/pos.go index 1a4b329..06db8bf 100644 --- a/vendor/github.com/hashicorp/hcl2/hcl/pos.go +++ b/vendor/github.com/hashicorp/hcl2/hcl/pos.go | |||
@@ -31,6 +31,9 @@ type Pos struct { | |||
31 | Byte int | 31 | Byte int |
32 | } | 32 | } |
33 | 33 | ||
34 | // InitialPos is a suitable position to use to mark the start of a file. | ||
35 | var InitialPos = Pos{Byte: 0, Line: 1, Column: 1} | ||
36 | |||
34 | // Range represents a span of characters between two positions in a source | 37 | // Range represents a span of characters between two positions in a source |
35 | // file. | 38 | // file. |
36 | // | 39 | // |
@@ -94,6 +97,16 @@ func RangeOver(a, b Range) Range { | |||
94 | } | 97 | } |
95 | } | 98 | } |
96 | 99 | ||
100 | // ContainsPos returns true if and only if the given position is contained within | ||
101 | // the receiving range. | ||
102 | // | ||
103 | // In the unlikely case that the line/column information disagree with the byte | ||
104 | // offset information in the given position or receiving range, the byte | ||
105 | // offsets are given priority. | ||
106 | func (r Range) ContainsPos(pos Pos) bool { | ||
107 | return r.ContainsOffset(pos.Byte) | ||
108 | } | ||
109 | |||
97 | // ContainsOffset returns true if and only if the given byte offset is within | 110 | // ContainsOffset returns true if and only if the given byte offset is within |
98 | // the receiving Range. | 111 | // the receiving Range. |
99 | func (r Range) ContainsOffset(offset int) bool { | 112 | func (r Range) ContainsOffset(offset int) bool { |
diff --git a/vendor/github.com/hashicorp/hcl2/hcl/pos_scanner.go b/vendor/github.com/hashicorp/hcl2/hcl/pos_scanner.go index 7c8f2df..17c0d7c 100644 --- a/vendor/github.com/hashicorp/hcl2/hcl/pos_scanner.go +++ b/vendor/github.com/hashicorp/hcl2/hcl/pos_scanner.go | |||
@@ -29,8 +29,8 @@ type RangeScanner struct { | |||
29 | err error // error from last scan, if any | 29 | err error // error from last scan, if any |
30 | } | 30 | } |
31 | 31 | ||
32 | // Create a new RangeScanner for the given buffer, producing ranges for the | 32 | // NewRangeScanner creates a new RangeScanner for the given buffer, producing |
33 | // given filename. | 33 | // ranges for the given filename. |
34 | // | 34 | // |
35 | // Since ranges have grapheme-cluster granularity rather than byte granularity, | 35 | // Since ranges have grapheme-cluster granularity rather than byte granularity, |
36 | // the scanner will produce incorrect results if the given SplitFunc creates | 36 | // the scanner will produce incorrect results if the given SplitFunc creates |
@@ -39,15 +39,19 @@ type RangeScanner struct { | |||
39 | // around individual UTF-8 sequences, which will split any multi-sequence | 39 | // around individual UTF-8 sequences, which will split any multi-sequence |
40 | // grapheme clusters. | 40 | // grapheme clusters. |
41 | func NewRangeScanner(b []byte, filename string, cb bufio.SplitFunc) *RangeScanner { | 41 | func NewRangeScanner(b []byte, filename string, cb bufio.SplitFunc) *RangeScanner { |
42 | return NewRangeScannerFragment(b, filename, InitialPos, cb) | ||
43 | } | ||
44 | |||
45 | // NewRangeScannerFragment is like NewRangeScanner but the ranges it produces | ||
46 | // will be offset by the given starting position, which is appropriate for | ||
47 | // sub-slices of a file, whereas NewRangeScanner assumes it is scanning an | ||
48 | // entire file. | ||
49 | func NewRangeScannerFragment(b []byte, filename string, start Pos, cb bufio.SplitFunc) *RangeScanner { | ||
42 | return &RangeScanner{ | 50 | return &RangeScanner{ |
43 | filename: filename, | 51 | filename: filename, |
44 | b: b, | 52 | b: b, |
45 | cb: cb, | 53 | cb: cb, |
46 | pos: Pos{ | 54 | pos: start, |
47 | Byte: 0, | ||
48 | Line: 1, | ||
49 | Column: 1, | ||
50 | }, | ||
51 | } | 55 | } |
52 | } | 56 | } |
53 | 57 | ||
diff --git a/vendor/github.com/hashicorp/hcl2/hcl/spec.md b/vendor/github.com/hashicorp/hcl2/hcl/spec.md index 58257bf..8bbaff8 100644 --- a/vendor/github.com/hashicorp/hcl2/hcl/spec.md +++ b/vendor/github.com/hashicorp/hcl2/hcl/spec.md | |||
@@ -29,7 +29,7 @@ which are discussed in detail in a later section. | |||
29 | A _block_ is a nested structure that has a _type name_, zero or more string | 29 | A _block_ is a nested structure that has a _type name_, zero or more string |
30 | _labels_ (e.g. identifiers), and a nested body. | 30 | _labels_ (e.g. identifiers), and a nested body. |
31 | 31 | ||
32 | Together the structural elements create a heirarchical data structure, with | 32 | Together the structural elements create a hierarchical data structure, with |
33 | attributes intended to represent the direct properties of a particular object | 33 | attributes intended to represent the direct properties of a particular object |
34 | in the calling application, and blocks intended to represent child objects | 34 | in the calling application, and blocks intended to represent child objects |
35 | of a particular object. | 35 | of a particular object. |
@@ -57,10 +57,10 @@ access to the specific attributes and blocks requested. | |||
57 | A _body schema_ consists of a list of _attribute schemata_ and | 57 | A _body schema_ consists of a list of _attribute schemata_ and |
58 | _block header schemata_: | 58 | _block header schemata_: |
59 | 59 | ||
60 | * An _attribute schema_ provides the name of an attribute and whether its | 60 | - An _attribute schema_ provides the name of an attribute and whether its |
61 | presence is required. | 61 | presence is required. |
62 | 62 | ||
63 | * A _block header schema_ provides a block type name and the semantic names | 63 | - A _block header schema_ provides a block type name and the semantic names |
64 | assigned to each of the labels of that block type, if any. | 64 | assigned to each of the labels of that block type, if any. |
65 | 65 | ||
66 | Within a schema, it is an error to request the same attribute name twice or | 66 | Within a schema, it is an error to request the same attribute name twice or |
@@ -72,11 +72,11 @@ a block whose type name is identical to the attribute name. | |||
72 | The result of applying a body schema to a body is _body content_, which | 72 | The result of applying a body schema to a body is _body content_, which |
73 | consists of an _attribute map_ and a _block sequence_: | 73 | consists of an _attribute map_ and a _block sequence_: |
74 | 74 | ||
75 | * The _attribute map_ is a map data structure whose keys are attribute names | 75 | - The _attribute map_ is a map data structure whose keys are attribute names |
76 | and whose values are _expressions_ that represent the corresponding attribute | 76 | and whose values are _expressions_ that represent the corresponding attribute |
77 | values. | 77 | values. |
78 | 78 | ||
79 | * The _block sequence_ is an ordered sequence of blocks, with each specifying | 79 | - The _block sequence_ is an ordered sequence of blocks, with each specifying |
80 | a block _type name_, the sequence of _labels_ specified for the block, | 80 | a block _type name_, the sequence of _labels_ specified for the block, |
81 | and the body object (not body _content_) representing the block's own body. | 81 | and the body object (not body _content_) representing the block's own body. |
82 | 82 | ||
@@ -132,13 +132,13 @@ the schema has been processed. | |||
132 | 132 | ||
133 | Specifically: | 133 | Specifically: |
134 | 134 | ||
135 | * Any attribute whose name is specified in the schema is returned in body | 135 | - Any attribute whose name is specified in the schema is returned in body |
136 | content and elided from the new body. | 136 | content and elided from the new body. |
137 | 137 | ||
138 | * Any block whose type is specified in the schema is returned in body content | 138 | - Any block whose type is specified in the schema is returned in body content |
139 | and elided from the new body. | 139 | and elided from the new body. |
140 | 140 | ||
141 | * Any attribute or block _not_ meeting the above conditions is placed into | 141 | - Any attribute or block _not_ meeting the above conditions is placed into |
142 | the new body, unmodified. | 142 | the new body, unmodified. |
143 | 143 | ||
144 | The new body can then be recursively processed using any of the body | 144 | The new body can then be recursively processed using any of the body |
@@ -168,20 +168,20 @@ In order to obtain a concrete value, each expression must be _evaluated_. | |||
168 | Evaluation is performed in terms of an evaluation context, which | 168 | Evaluation is performed in terms of an evaluation context, which |
169 | consists of the following: | 169 | consists of the following: |
170 | 170 | ||
171 | * An _evaluation mode_, which is defined below. | 171 | - An _evaluation mode_, which is defined below. |
172 | * A _variable scope_, which provides a set of named variables for use in | 172 | - A _variable scope_, which provides a set of named variables for use in |
173 | expressions. | 173 | expressions. |
174 | * A _function table_, which provides a set of named functions for use in | 174 | - A _function table_, which provides a set of named functions for use in |
175 | expressions. | 175 | expressions. |
176 | 176 | ||
177 | The _evaluation mode_ allows for two different interpretations of an | 177 | The _evaluation mode_ allows for two different interpretations of an |
178 | expression: | 178 | expression: |
179 | 179 | ||
180 | * In _literal-only mode_, variables and functions are not available and it | 180 | - In _literal-only mode_, variables and functions are not available and it |
181 | is assumed that the calling application's intent is to treat the attribute | 181 | is assumed that the calling application's intent is to treat the attribute |
182 | value as a literal. | 182 | value as a literal. |
183 | 183 | ||
184 | * In _full expression mode_, variables and functions are defined and it is | 184 | - In _full expression mode_, variables and functions are defined and it is |
185 | assumed that the calling application wishes to provide a full expression | 185 | assumed that the calling application wishes to provide a full expression |
186 | language for definition of the attribute value. | 186 | language for definition of the attribute value. |
187 | 187 | ||
@@ -235,15 +235,15 @@ for interpretation into any suitable number representation. An implementation | |||
235 | may in practice implement numbers with limited precision so long as the | 235 | may in practice implement numbers with limited precision so long as the |
236 | following constraints are met: | 236 | following constraints are met: |
237 | 237 | ||
238 | * Integers are represented with at least 256 bits. | 238 | - Integers are represented with at least 256 bits. |
239 | * Non-integer numbers are represented as floating point values with a | 239 | - Non-integer numbers are represented as floating point values with a |
240 | mantissa of at least 256 bits and a signed binary exponent of at least | 240 | mantissa of at least 256 bits and a signed binary exponent of at least |
241 | 16 bits. | 241 | 16 bits. |
242 | * An error is produced if an integer value given in source cannot be | 242 | - An error is produced if an integer value given in source cannot be |
243 | represented precisely. | 243 | represented precisely. |
244 | * An error is produced if a non-integer value cannot be represented due to | 244 | - An error is produced if a non-integer value cannot be represented due to |
245 | overflow. | 245 | overflow. |
246 | * A non-integer number is rounded to the nearest possible value when a | 246 | - A non-integer number is rounded to the nearest possible value when a |
247 | value is of too high a precision to be represented. | 247 | value is of too high a precision to be represented. |
248 | 248 | ||
249 | The _number_ type also requires representation of both positive and negative | 249 | The _number_ type also requires representation of both positive and negative |
@@ -265,11 +265,11 @@ _Structural types_ are types that are constructed by combining other types. | |||
265 | Each distinct combination of other types is itself a distinct type. There | 265 | Each distinct combination of other types is itself a distinct type. There |
266 | are two structural type _kinds_: | 266 | are two structural type _kinds_: |
267 | 267 | ||
268 | * _Object types_ are constructed of a set of named attributes, each of which | 268 | - _Object types_ are constructed of a set of named attributes, each of which |
269 | has a type. Attribute names are always strings. (_Object_ attributes are a | 269 | has a type. Attribute names are always strings. (_Object_ attributes are a |
270 | distinct idea from _body_ attributes, though calling applications | 270 | distinct idea from _body_ attributes, though calling applications |
271 | may choose to blur the distinction by use of common naming schemes.) | 271 | may choose to blur the distinction by use of common naming schemes.) |
272 | * _Tuple tupes_ are constructed of a sequence of elements, each of which | 272 | - _Tuple types_ are constructed of a sequence of elements, each of which |
273 | has a type. | 273 | has a type. |
274 | 274 | ||
275 | Values of structural types are compared for equality in terms of their | 275 | Values of structural types are compared for equality in terms of their |
@@ -284,9 +284,9 @@ have attributes or elements with identical types. | |||
284 | _Collection types_ are types that combine together an arbitrary number of | 284 | _Collection types_ are types that combine together an arbitrary number of |
285 | values of some other single type. There are three collection type _kinds_: | 285 | values of some other single type. There are three collection type _kinds_: |
286 | 286 | ||
287 | * _List types_ represent ordered sequences of values of their element type. | 287 | - _List types_ represent ordered sequences of values of their element type. |
288 | * _Map types_ represent values of their element type accessed via string keys. | 288 | - _Map types_ represent values of their element type accessed via string keys. |
289 | * _Set types_ represent unordered sets of distinct values of their element type. | 289 | - _Set types_ represent unordered sets of distinct values of their element type. |
290 | 290 | ||
291 | For each of these kinds and each distinct element type there is a distinct | 291 | For each of these kinds and each distinct element type there is a distinct |
292 | collection type. For example, "list of string" is a distinct type from | 292 | collection type. For example, "list of string" is a distinct type from |
@@ -301,10 +301,10 @@ the same element type. | |||
301 | 301 | ||
302 | ### Null values | 302 | ### Null values |
303 | 303 | ||
304 | Each type has a null value. The null value of a type represents the absense | 304 | Each type has a null value. The null value of a type represents the absence |
305 | of a value, but with type information retained to allow for type checking. | 305 | of a value, but with type information retained to allow for type checking. |
306 | 306 | ||
307 | Null values are used primarily to represent the conditional absense of a | 307 | Null values are used primarily to represent the conditional absence of a |
308 | body attribute. In a syntax with a conditional operator, one of the result | 308 | body attribute. In a syntax with a conditional operator, one of the result |
309 | values of that conditional may be null to indicate that the attribute should be | 309 | values of that conditional may be null to indicate that the attribute should be |
310 | considered not present in that case. | 310 | considered not present in that case. |
@@ -376,9 +376,9 @@ a type has a non-commutative _matches_ relationship with a _type specification_. | |||
376 | A type specification is, in practice, just a different interpretation of a | 376 | A type specification is, in practice, just a different interpretation of a |
377 | type such that: | 377 | type such that: |
378 | 378 | ||
379 | * Any type _matches_ any type that it is identical to. | 379 | - Any type _matches_ any type that it is identical to. |
380 | 380 | ||
381 | * Any type _matches_ the dynamic pseudo-type. | 381 | - Any type _matches_ the dynamic pseudo-type. |
382 | 382 | ||
383 | For example, given a type specification "list of dynamic pseudo-type", the | 383 | For example, given a type specification "list of dynamic pseudo-type", the |
384 | concrete types "list of string" and "list of map" match, but the | 384 | concrete types "list of string" and "list of map" match, but the |
@@ -397,51 +397,51 @@ applications to provide functions that are interoperable with all syntaxes. | |||
397 | 397 | ||
398 | A _function_ is defined from the following elements: | 398 | A _function_ is defined from the following elements: |
399 | 399 | ||
400 | * Zero or more _positional parameters_, each with a name used for documentation, | 400 | - Zero or more _positional parameters_, each with a name used for documentation, |
401 | a type specification for expected argument values, and a flag for whether | 401 | a type specification for expected argument values, and a flag for whether |
402 | each of null values, unknown values, and values of the dynamic pseudo-type | 402 | each of null values, unknown values, and values of the dynamic pseudo-type |
403 | are accepted. | 403 | are accepted. |
404 | 404 | ||
405 | * Zero or one _variadic parameters_, with the same structure as the _positional_ | 405 | - Zero or one _variadic parameters_, with the same structure as the _positional_ |
406 | parameters, which if present collects any additional arguments provided at | 406 | parameters, which if present collects any additional arguments provided at |
407 | the function call site. | 407 | the function call site. |
408 | 408 | ||
409 | * A _result type definition_, which specifies the value type returned for each | 409 | - A _result type definition_, which specifies the value type returned for each |
410 | valid sequence of argument values. | 410 | valid sequence of argument values. |
411 | 411 | ||
412 | * A _result value definition_, which specifies the value returned for each | 412 | - A _result value definition_, which specifies the value returned for each |
413 | valid sequence of argument values. | 413 | valid sequence of argument values. |
414 | 414 | ||
415 | A _function call_, regardless of source syntax, consists of a sequence of | 415 | A _function call_, regardless of source syntax, consists of a sequence of |
416 | argument values. The argument values are each mapped to a corresponding | 416 | argument values. The argument values are each mapped to a corresponding |
417 | parameter as follows: | 417 | parameter as follows: |
418 | 418 | ||
419 | * For each of the function's positional parameters in sequence, take the next | 419 | - For each of the function's positional parameters in sequence, take the next |
420 | argument. If there are no more arguments, the call is erroneous. | 420 | argument. If there are no more arguments, the call is erroneous. |
421 | 421 | ||
422 | * If the function has a variadic parameter, take all remaining arguments that | 422 | - If the function has a variadic parameter, take all remaining arguments that |
423 | where not yet assigned to a positional parameter and collect them into | 423 | where not yet assigned to a positional parameter and collect them into |
424 | a sequence of variadic arguments that each correspond to the variadic | 424 | a sequence of variadic arguments that each correspond to the variadic |
425 | parameter. | 425 | parameter. |
426 | 426 | ||
427 | * If the function has _no_ variadic parameter, it is an error if any arguments | 427 | - If the function has _no_ variadic parameter, it is an error if any arguments |
428 | remain after taking one argument for each positional parameter. | 428 | remain after taking one argument for each positional parameter. |
429 | 429 | ||
430 | After mapping each argument to a parameter, semantic checking proceeds | 430 | After mapping each argument to a parameter, semantic checking proceeds |
431 | for each argument: | 431 | for each argument: |
432 | 432 | ||
433 | * If the argument value corresponding to a parameter does not match the | 433 | - If the argument value corresponding to a parameter does not match the |
434 | parameter's type specification, the call is erroneous. | 434 | parameter's type specification, the call is erroneous. |
435 | 435 | ||
436 | * If the argument value corresponding to a parameter is null and the parameter | 436 | - If the argument value corresponding to a parameter is null and the parameter |
437 | is not specified as accepting nulls, the call is erroneous. | 437 | is not specified as accepting nulls, the call is erroneous. |
438 | 438 | ||
439 | * If the argument value corresponding to a parameter is the dynamic value | 439 | - If the argument value corresponding to a parameter is the dynamic value |
440 | and the parameter is not specified as accepting values of the dynamic | 440 | and the parameter is not specified as accepting values of the dynamic |
441 | pseudo-type, the call is valid but its _result type_ is forced to be the | 441 | pseudo-type, the call is valid but its _result type_ is forced to be the |
442 | dynamic pseudo type. | 442 | dynamic pseudo type. |
443 | 443 | ||
444 | * If neither of the above conditions holds for any argument, the call is | 444 | - If neither of the above conditions holds for any argument, the call is |
445 | valid and the function's value type definition is used to determine the | 445 | valid and the function's value type definition is used to determine the |
446 | call's _result type_. A function _may_ vary its result type depending on | 446 | call's _result type_. A function _may_ vary its result type depending on |
447 | the argument _values_ as well as the argument _types_; for example, a | 447 | the argument _values_ as well as the argument _types_; for example, a |
@@ -450,15 +450,15 @@ for each argument: | |||
450 | 450 | ||
451 | If semantic checking succeeds without error, the call is _executed_: | 451 | If semantic checking succeeds without error, the call is _executed_: |
452 | 452 | ||
453 | * For each argument, if its value is unknown and its corresponding parameter | 453 | - For each argument, if its value is unknown and its corresponding parameter |
454 | is not specified as accepting unknowns, the _result value_ is forced to be an | 454 | is not specified as accepting unknowns, the _result value_ is forced to be an |
455 | unknown value of the result type. | 455 | unknown value of the result type. |
456 | 456 | ||
457 | * If the previous condition does not apply, the function's result value | 457 | - If the previous condition does not apply, the function's result value |
458 | definition is used to determine the call's _result value_. | 458 | definition is used to determine the call's _result value_. |
459 | 459 | ||
460 | The result of a function call expression is either an error, if one of the | 460 | The result of a function call expression is either an error, if one of the |
461 | erroenous conditions above applies, or the _result value_. | 461 | erroneous conditions above applies, or the _result value_. |
462 | 462 | ||
463 | ## Type Conversions and Unification | 463 | ## Type Conversions and Unification |
464 | 464 | ||
@@ -505,7 +505,7 @@ Bidirectional conversions are available between the string and number types, | |||
505 | and between the string and boolean types. | 505 | and between the string and boolean types. |
506 | 506 | ||
507 | The bool value true corresponds to the string containing the characters "true", | 507 | The bool value true corresponds to the string containing the characters "true", |
508 | while the bool value false corresponds to teh string containing the characters | 508 | while the bool value false corresponds to the string containing the characters |
509 | "false". Conversion from bool to string is safe, while the converse is | 509 | "false". Conversion from bool to string is safe, while the converse is |
510 | unsafe. The strings "1" and "0" are alternative string representations | 510 | unsafe. The strings "1" and "0" are alternative string representations |
511 | of true and false respectively. It is an error to convert a string other than | 511 | of true and false respectively. It is an error to convert a string other than |
@@ -631,20 +631,20 @@ diagnostics if they are applied to inappropriate expressions. | |||
631 | 631 | ||
632 | The following are the required static analysis functions: | 632 | The following are the required static analysis functions: |
633 | 633 | ||
634 | * **Static List**: Require list/tuple construction syntax to be used and | 634 | - **Static List**: Require list/tuple construction syntax to be used and |
635 | return a list of expressions for each of the elements given. | 635 | return a list of expressions for each of the elements given. |
636 | 636 | ||
637 | * **Static Map**: Require map/object construction syntax to be used and | 637 | - **Static Map**: Require map/object construction syntax to be used and |
638 | return a list of key/value pairs -- both expressions -- for each of | 638 | return a list of key/value pairs -- both expressions -- for each of |
639 | the elements given. The usual constraint that a map key must be a string | 639 | the elements given. The usual constraint that a map key must be a string |
640 | must not apply to this analysis, thus allowing applications to interpret | 640 | must not apply to this analysis, thus allowing applications to interpret |
641 | arbitrary keys as they see fit. | 641 | arbitrary keys as they see fit. |
642 | 642 | ||
643 | * **Static Call**: Require function call syntax to be used and return an | 643 | - **Static Call**: Require function call syntax to be used and return an |
644 | object describing the called function name and a list of expressions | 644 | object describing the called function name and a list of expressions |
645 | representing each of the call arguments. | 645 | representing each of the call arguments. |
646 | 646 | ||
647 | * **Static Traversal**: Require a reference to a symbol in the variable | 647 | - **Static Traversal**: Require a reference to a symbol in the variable |
648 | scope and return a description of the path from the root scope to the | 648 | scope and return a description of the path from the root scope to the |
649 | accessed attribute or index. | 649 | accessed attribute or index. |
650 | 650 | ||
@@ -670,18 +670,18 @@ with the goals of this specification. | |||
670 | The language-agnosticism of this specification assumes that certain behaviors | 670 | The language-agnosticism of this specification assumes that certain behaviors |
671 | are implemented separately for each syntax: | 671 | are implemented separately for each syntax: |
672 | 672 | ||
673 | * Matching of a body schema with the physical elements of a body in the | 673 | - Matching of a body schema with the physical elements of a body in the |
674 | source language, to determine correspondance between physical constructs | 674 | source language, to determine correspondence between physical constructs |
675 | and schema elements. | 675 | and schema elements. |
676 | 676 | ||
677 | * Implementing the _dynamic attributes_ body processing mode by either | 677 | - Implementing the _dynamic attributes_ body processing mode by either |
678 | interpreting all physical constructs as attributes or producing an error | 678 | interpreting all physical constructs as attributes or producing an error |
679 | if non-attribute constructs are present. | 679 | if non-attribute constructs are present. |
680 | 680 | ||
681 | * Providing an evaluation function for all possible expressions that produces | 681 | - Providing an evaluation function for all possible expressions that produces |
682 | a value given an evaluation context. | 682 | a value given an evaluation context. |
683 | 683 | ||
684 | * Providing the static analysis functionality described above in a manner that | 684 | - Providing the static analysis functionality described above in a manner that |
685 | makes sense within the convention of the syntax. | 685 | makes sense within the convention of the syntax. |
686 | 686 | ||
687 | The suggested implementation strategy is to use an implementation language's | 687 | The suggested implementation strategy is to use an implementation language's |
diff --git a/vendor/github.com/hashicorp/hcl2/hcl/structure_at_pos.go b/vendor/github.com/hashicorp/hcl2/hcl/structure_at_pos.go new file mode 100644 index 0000000..8521814 --- /dev/null +++ b/vendor/github.com/hashicorp/hcl2/hcl/structure_at_pos.go | |||
@@ -0,0 +1,117 @@ | |||
1 | package hcl | ||
2 | |||
3 | // ----------------------------------------------------------------------------- | ||
4 | // The methods in this file all have the general pattern of making a best-effort | ||
5 | // to find one or more constructs that contain a given source position. | ||
6 | // | ||
7 | // These all operate by delegating to an optional method of the same name and | ||
8 | // signature on the file's root body, allowing each syntax to potentially | ||
9 | // provide its own implementations of these. For syntaxes that don't implement | ||
10 | // them, the result is always nil. | ||
11 | // ----------------------------------------------------------------------------- | ||
12 | |||
13 | // BlocksAtPos attempts to find all of the blocks that contain the given | ||
14 | // position, ordered so that the outermost block is first and the innermost | ||
15 | // block is last. This is a best-effort method that may not be able to produce | ||
16 | // a complete result for all positions or for all HCL syntaxes. | ||
17 | // | ||
18 | // If the returned slice is non-empty, the first element is guaranteed to | ||
19 | // represent the same block as would be the result of OutermostBlockAtPos and | ||
20 | // the last element the result of InnermostBlockAtPos. However, the | ||
21 | // implementation may return two different objects describing the same block, | ||
22 | // so comparison by pointer identity is not possible. | ||
23 | // | ||
24 | // The result is nil if no blocks at all contain the given position. | ||
25 | func (f *File) BlocksAtPos(pos Pos) []*Block { | ||
26 | // The root body of the file must implement this interface in order | ||
27 | // to support BlocksAtPos. | ||
28 | type Interface interface { | ||
29 | BlocksAtPos(pos Pos) []*Block | ||
30 | } | ||
31 | |||
32 | impl, ok := f.Body.(Interface) | ||
33 | if !ok { | ||
34 | return nil | ||
35 | } | ||
36 | return impl.BlocksAtPos(pos) | ||
37 | } | ||
38 | |||
39 | // OutermostBlockAtPos attempts to find a top-level block in the receiving file | ||
40 | // that contains the given position. This is a best-effort method that may not | ||
41 | // be able to produce a result for all positions or for all HCL syntaxes. | ||
42 | // | ||
43 | // The result is nil if no single block could be selected for any reason. | ||
44 | func (f *File) OutermostBlockAtPos(pos Pos) *Block { | ||
45 | // The root body of the file must implement this interface in order | ||
46 | // to support OutermostBlockAtPos. | ||
47 | type Interface interface { | ||
48 | OutermostBlockAtPos(pos Pos) *Block | ||
49 | } | ||
50 | |||
51 | impl, ok := f.Body.(Interface) | ||
52 | if !ok { | ||
53 | return nil | ||
54 | } | ||
55 | return impl.OutermostBlockAtPos(pos) | ||
56 | } | ||
57 | |||
58 | // InnermostBlockAtPos attempts to find the most deeply-nested block in the | ||
59 | // receiving file that contains the given position. This is a best-effort | ||
60 | // method that may not be able to produce a result for all positions or for | ||
61 | // all HCL syntaxes. | ||
62 | // | ||
63 | // The result is nil if no single block could be selected for any reason. | ||
64 | func (f *File) InnermostBlockAtPos(pos Pos) *Block { | ||
65 | // The root body of the file must implement this interface in order | ||
66 | // to support InnermostBlockAtPos. | ||
67 | type Interface interface { | ||
68 | InnermostBlockAtPos(pos Pos) *Block | ||
69 | } | ||
70 | |||
71 | impl, ok := f.Body.(Interface) | ||
72 | if !ok { | ||
73 | return nil | ||
74 | } | ||
75 | return impl.InnermostBlockAtPos(pos) | ||
76 | } | ||
77 | |||
78 | // OutermostExprAtPos attempts to find an expression in the receiving file | ||
79 | // that contains the given position. This is a best-effort method that may not | ||
80 | // be able to produce a result for all positions or for all HCL syntaxes. | ||
81 | // | ||
82 | // Since expressions are often nested inside one another, this method returns | ||
83 | // the outermost "root" expression that is not contained by any other. | ||
84 | // | ||
85 | // The result is nil if no single expression could be selected for any reason. | ||
86 | func (f *File) OutermostExprAtPos(pos Pos) Expression { | ||
87 | // The root body of the file must implement this interface in order | ||
88 | // to support OutermostExprAtPos. | ||
89 | type Interface interface { | ||
90 | OutermostExprAtPos(pos Pos) Expression | ||
91 | } | ||
92 | |||
93 | impl, ok := f.Body.(Interface) | ||
94 | if !ok { | ||
95 | return nil | ||
96 | } | ||
97 | return impl.OutermostExprAtPos(pos) | ||
98 | } | ||
99 | |||
100 | // AttributeAtPos attempts to find an attribute definition in the receiving | ||
101 | // file that contains the given position. This is a best-effort method that may | ||
102 | // not be able to produce a result for all positions or for all HCL syntaxes. | ||
103 | // | ||
104 | // The result is nil if no single attribute could be selected for any reason. | ||
105 | func (f *File) AttributeAtPos(pos Pos) *Attribute { | ||
106 | // The root body of the file must implement this interface in order | ||
107 | // to support OutermostExprAtPos. | ||
108 | type Interface interface { | ||
109 | AttributeAtPos(pos Pos) *Attribute | ||
110 | } | ||
111 | |||
112 | impl, ok := f.Body.(Interface) | ||
113 | if !ok { | ||
114 | return nil | ||
115 | } | ||
116 | return impl.AttributeAtPos(pos) | ||
117 | } | ||
diff --git a/vendor/github.com/hashicorp/hcl2/hcl/traversal.go b/vendor/github.com/hashicorp/hcl2/hcl/traversal.go index 24f4c91..d710197 100644 --- a/vendor/github.com/hashicorp/hcl2/hcl/traversal.go +++ b/vendor/github.com/hashicorp/hcl2/hcl/traversal.go | |||
@@ -255,66 +255,7 @@ type TraverseAttr struct { | |||
255 | } | 255 | } |
256 | 256 | ||
257 | func (tn TraverseAttr) TraversalStep(val cty.Value) (cty.Value, Diagnostics) { | 257 | func (tn TraverseAttr) TraversalStep(val cty.Value) (cty.Value, Diagnostics) { |
258 | if val.IsNull() { | 258 | return GetAttr(val, tn.Name, &tn.SrcRange) |
259 | return cty.DynamicVal, Diagnostics{ | ||
260 | { | ||
261 | Severity: DiagError, | ||
262 | Summary: "Attempt to get attribute from null value", | ||
263 | Detail: "This value is null, so it does not have any attributes.", | ||
264 | Subject: &tn.SrcRange, | ||
265 | }, | ||
266 | } | ||
267 | } | ||
268 | |||
269 | ty := val.Type() | ||
270 | switch { | ||
271 | case ty.IsObjectType(): | ||
272 | if !ty.HasAttribute(tn.Name) { | ||
273 | return cty.DynamicVal, Diagnostics{ | ||
274 | { | ||
275 | Severity: DiagError, | ||
276 | Summary: "Unsupported attribute", | ||
277 | Detail: fmt.Sprintf("This object does not have an attribute named %q.", tn.Name), | ||
278 | Subject: &tn.SrcRange, | ||
279 | }, | ||
280 | } | ||
281 | } | ||
282 | |||
283 | if !val.IsKnown() { | ||
284 | return cty.UnknownVal(ty.AttributeType(tn.Name)), nil | ||
285 | } | ||
286 | |||
287 | return val.GetAttr(tn.Name), nil | ||
288 | case ty.IsMapType(): | ||
289 | if !val.IsKnown() { | ||
290 | return cty.UnknownVal(ty.ElementType()), nil | ||
291 | } | ||
292 | |||
293 | idx := cty.StringVal(tn.Name) | ||
294 | if val.HasIndex(idx).False() { | ||
295 | return cty.DynamicVal, Diagnostics{ | ||
296 | { | ||
297 | Severity: DiagError, | ||
298 | Summary: "Missing map element", | ||
299 | Detail: fmt.Sprintf("This map does not have an element with the key %q.", tn.Name), | ||
300 | Subject: &tn.SrcRange, | ||
301 | }, | ||
302 | } | ||
303 | } | ||
304 | |||
305 | return val.Index(idx), nil | ||
306 | case ty == cty.DynamicPseudoType: | ||
307 | return cty.DynamicVal, nil | ||
308 | default: | ||
309 | return cty.DynamicVal, Diagnostics{ | ||
310 | { | ||
311 | Severity: DiagError, | ||
312 | Summary: "Unsupported attribute", | ||
313 | Detail: "This value does not have any attributes.", | ||
314 | Subject: &tn.SrcRange, | ||
315 | }, | ||
316 | } | ||
317 | } | ||
318 | } | 259 | } |
319 | 260 | ||
320 | func (tn TraverseAttr) SourceRange() Range { | 261 | func (tn TraverseAttr) SourceRange() Range { |
diff --git a/vendor/github.com/hashicorp/hcl2/hcl/traversal_for_expr.go b/vendor/github.com/hashicorp/hcl2/hcl/traversal_for_expr.go index 5f52946..d4a565a 100644 --- a/vendor/github.com/hashicorp/hcl2/hcl/traversal_for_expr.go +++ b/vendor/github.com/hashicorp/hcl2/hcl/traversal_for_expr.go | |||
@@ -52,11 +52,14 @@ func AbsTraversalForExpr(expr Expression) (Traversal, Diagnostics) { | |||
52 | func RelTraversalForExpr(expr Expression) (Traversal, Diagnostics) { | 52 | func RelTraversalForExpr(expr Expression) (Traversal, Diagnostics) { |
53 | traversal, diags := AbsTraversalForExpr(expr) | 53 | traversal, diags := AbsTraversalForExpr(expr) |
54 | if len(traversal) > 0 { | 54 | if len(traversal) > 0 { |
55 | ret := make(Traversal, len(traversal)) | ||
56 | copy(ret, traversal) | ||
55 | root := traversal[0].(TraverseRoot) | 57 | root := traversal[0].(TraverseRoot) |
56 | traversal[0] = TraverseAttr{ | 58 | ret[0] = TraverseAttr{ |
57 | Name: root.Name, | 59 | Name: root.Name, |
58 | SrcRange: root.SrcRange, | 60 | SrcRange: root.SrcRange, |
59 | } | 61 | } |
62 | return ret, diags | ||
60 | } | 63 | } |
61 | return traversal, diags | 64 | return traversal, diags |
62 | } | 65 | } |
diff --git a/vendor/github.com/hashicorp/hcl2/hcldec/public.go b/vendor/github.com/hashicorp/hcl2/hcldec/public.go index 5d1f10a..3c80363 100644 --- a/vendor/github.com/hashicorp/hcl2/hcldec/public.go +++ b/vendor/github.com/hashicorp/hcl2/hcldec/public.go | |||
@@ -65,7 +65,10 @@ func ChildBlockTypes(spec Spec) map[string]Spec { | |||
65 | visit = func(s Spec) { | 65 | visit = func(s Spec) { |
66 | if bs, ok := s.(blockSpec); ok { | 66 | if bs, ok := s.(blockSpec); ok { |
67 | for _, blockS := range bs.blockHeaderSchemata() { | 67 | for _, blockS := range bs.blockHeaderSchemata() { |
68 | ret[blockS.Type] = bs.nestedSpec() | 68 | nested := bs.nestedSpec() |
69 | if nested != nil { // nil can be returned to dynamically opt out of this interface | ||
70 | ret[blockS.Type] = nested | ||
71 | } | ||
69 | } | 72 | } |
70 | } | 73 | } |
71 | 74 | ||
diff --git a/vendor/github.com/hashicorp/hcl2/hcldec/spec.go b/vendor/github.com/hashicorp/hcl2/hcldec/spec.go index 25cafcd..f9da7f6 100644 --- a/vendor/github.com/hashicorp/hcl2/hcldec/spec.go +++ b/vendor/github.com/hashicorp/hcl2/hcldec/spec.go | |||
@@ -3,6 +3,7 @@ package hcldec | |||
3 | import ( | 3 | import ( |
4 | "bytes" | 4 | "bytes" |
5 | "fmt" | 5 | "fmt" |
6 | "sort" | ||
6 | 7 | ||
7 | "github.com/hashicorp/hcl2/hcl" | 8 | "github.com/hashicorp/hcl2/hcl" |
8 | "github.com/zclconf/go-cty/cty" | 9 | "github.com/zclconf/go-cty/cty" |
@@ -477,6 +478,44 @@ func (s *BlockListSpec) decode(content *hcl.BodyContent, blockLabels []blockLabe | |||
477 | if len(elems) == 0 { | 478 | if len(elems) == 0 { |
478 | ret = cty.ListValEmpty(s.Nested.impliedType()) | 479 | ret = cty.ListValEmpty(s.Nested.impliedType()) |
479 | } else { | 480 | } else { |
481 | // Since our target is a list, all of the decoded elements must have the | ||
482 | // same type or cty.ListVal will panic below. Different types can arise | ||
483 | // if there is an attribute spec of type cty.DynamicPseudoType in the | ||
484 | // nested spec; all given values must be convertable to a single type | ||
485 | // in order for the result to be considered valid. | ||
486 | etys := make([]cty.Type, len(elems)) | ||
487 | for i, v := range elems { | ||
488 | etys[i] = v.Type() | ||
489 | } | ||
490 | ety, convs := convert.UnifyUnsafe(etys) | ||
491 | if ety == cty.NilType { | ||
492 | // FIXME: This is a pretty terrible error message. | ||
493 | diags = append(diags, &hcl.Diagnostic{ | ||
494 | Severity: hcl.DiagError, | ||
495 | Summary: fmt.Sprintf("Unconsistent argument types in %s blocks", s.TypeName), | ||
496 | Detail: "Corresponding attributes in all blocks of this type must be the same.", | ||
497 | Subject: &sourceRanges[0], | ||
498 | }) | ||
499 | return cty.DynamicVal, diags | ||
500 | } | ||
501 | for i, v := range elems { | ||
502 | if convs[i] != nil { | ||
503 | newV, err := convs[i](v) | ||
504 | if err != nil { | ||
505 | // FIXME: This is a pretty terrible error message. | ||
506 | diags = append(diags, &hcl.Diagnostic{ | ||
507 | Severity: hcl.DiagError, | ||
508 | Summary: fmt.Sprintf("Unconsistent argument types in %s blocks", s.TypeName), | ||
509 | Detail: fmt.Sprintf("Block with index %d has inconsistent argument types: %s.", i, err), | ||
510 | Subject: &sourceRanges[i], | ||
511 | }) | ||
512 | // Bail early here so we won't panic below in cty.ListVal | ||
513 | return cty.DynamicVal, diags | ||
514 | } | ||
515 | elems[i] = newV | ||
516 | } | ||
517 | } | ||
518 | |||
480 | ret = cty.ListVal(elems) | 519 | ret = cty.ListVal(elems) |
481 | } | 520 | } |
482 | 521 | ||
@@ -508,6 +547,127 @@ func (s *BlockListSpec) sourceRange(content *hcl.BodyContent, blockLabels []bloc | |||
508 | return sourceRange(childBlock.Body, labelsForBlock(childBlock), s.Nested) | 547 | return sourceRange(childBlock.Body, labelsForBlock(childBlock), s.Nested) |
509 | } | 548 | } |
510 | 549 | ||
550 | // A BlockTupleSpec is a Spec that produces a cty tuple of the results of | ||
551 | // decoding all of the nested blocks of a given type, using a nested spec. | ||
552 | // | ||
553 | // This is similar to BlockListSpec, but it permits the nested blocks to have | ||
554 | // different result types in situations where cty.DynamicPseudoType attributes | ||
555 | // are present. | ||
556 | type BlockTupleSpec struct { | ||
557 | TypeName string | ||
558 | Nested Spec | ||
559 | MinItems int | ||
560 | MaxItems int | ||
561 | } | ||
562 | |||
563 | func (s *BlockTupleSpec) visitSameBodyChildren(cb visitFunc) { | ||
564 | // leaf node ("Nested" does not use the same body) | ||
565 | } | ||
566 | |||
567 | // blockSpec implementation | ||
568 | func (s *BlockTupleSpec) blockHeaderSchemata() []hcl.BlockHeaderSchema { | ||
569 | return []hcl.BlockHeaderSchema{ | ||
570 | { | ||
571 | Type: s.TypeName, | ||
572 | LabelNames: findLabelSpecs(s.Nested), | ||
573 | }, | ||
574 | } | ||
575 | } | ||
576 | |||
577 | // blockSpec implementation | ||
578 | func (s *BlockTupleSpec) nestedSpec() Spec { | ||
579 | return s.Nested | ||
580 | } | ||
581 | |||
582 | // specNeedingVariables implementation | ||
583 | func (s *BlockTupleSpec) variablesNeeded(content *hcl.BodyContent) []hcl.Traversal { | ||
584 | var ret []hcl.Traversal | ||
585 | |||
586 | for _, childBlock := range content.Blocks { | ||
587 | if childBlock.Type != s.TypeName { | ||
588 | continue | ||
589 | } | ||
590 | |||
591 | ret = append(ret, Variables(childBlock.Body, s.Nested)...) | ||
592 | } | ||
593 | |||
594 | return ret | ||
595 | } | ||
596 | |||
597 | func (s *BlockTupleSpec) decode(content *hcl.BodyContent, blockLabels []blockLabel, ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) { | ||
598 | var diags hcl.Diagnostics | ||
599 | |||
600 | if s.Nested == nil { | ||
601 | panic("BlockListSpec with no Nested Spec") | ||
602 | } | ||
603 | |||
604 | var elems []cty.Value | ||
605 | var sourceRanges []hcl.Range | ||
606 | for _, childBlock := range content.Blocks { | ||
607 | if childBlock.Type != s.TypeName { | ||
608 | continue | ||
609 | } | ||
610 | |||
611 | val, _, childDiags := decode(childBlock.Body, labelsForBlock(childBlock), ctx, s.Nested, false) | ||
612 | diags = append(diags, childDiags...) | ||
613 | elems = append(elems, val) | ||
614 | sourceRanges = append(sourceRanges, sourceRange(childBlock.Body, labelsForBlock(childBlock), s.Nested)) | ||
615 | } | ||
616 | |||
617 | if len(elems) < s.MinItems { | ||
618 | diags = append(diags, &hcl.Diagnostic{ | ||
619 | Severity: hcl.DiagError, | ||
620 | Summary: fmt.Sprintf("Insufficient %s blocks", s.TypeName), | ||
621 | Detail: fmt.Sprintf("At least %d %q blocks are required.", s.MinItems, s.TypeName), | ||
622 | Subject: &content.MissingItemRange, | ||
623 | }) | ||
624 | } else if s.MaxItems > 0 && len(elems) > s.MaxItems { | ||
625 | diags = append(diags, &hcl.Diagnostic{ | ||
626 | Severity: hcl.DiagError, | ||
627 | Summary: fmt.Sprintf("Too many %s blocks", s.TypeName), | ||
628 | Detail: fmt.Sprintf("No more than %d %q blocks are allowed", s.MaxItems, s.TypeName), | ||
629 | Subject: &sourceRanges[s.MaxItems], | ||
630 | }) | ||
631 | } | ||
632 | |||
633 | var ret cty.Value | ||
634 | |||
635 | if len(elems) == 0 { | ||
636 | ret = cty.EmptyTupleVal | ||
637 | } else { | ||
638 | ret = cty.TupleVal(elems) | ||
639 | } | ||
640 | |||
641 | return ret, diags | ||
642 | } | ||
643 | |||
644 | func (s *BlockTupleSpec) impliedType() cty.Type { | ||
645 | // We can't predict our type, because we don't know how many blocks | ||
646 | // there will be until we decode. | ||
647 | return cty.DynamicPseudoType | ||
648 | } | ||
649 | |||
650 | func (s *BlockTupleSpec) sourceRange(content *hcl.BodyContent, blockLabels []blockLabel) hcl.Range { | ||
651 | // We return the source range of the _first_ block of the given type, | ||
652 | // since they are not guaranteed to form a contiguous range. | ||
653 | |||
654 | var childBlock *hcl.Block | ||
655 | for _, candidate := range content.Blocks { | ||
656 | if candidate.Type != s.TypeName { | ||
657 | continue | ||
658 | } | ||
659 | |||
660 | childBlock = candidate | ||
661 | break | ||
662 | } | ||
663 | |||
664 | if childBlock == nil { | ||
665 | return content.MissingItemRange | ||
666 | } | ||
667 | |||
668 | return sourceRange(childBlock.Body, labelsForBlock(childBlock), s.Nested) | ||
669 | } | ||
670 | |||
511 | // A BlockSetSpec is a Spec that produces a cty set of the results of | 671 | // A BlockSetSpec is a Spec that produces a cty set of the results of |
512 | // decoding all of the nested blocks of a given type, using a nested spec. | 672 | // decoding all of the nested blocks of a given type, using a nested spec. |
513 | type BlockSetSpec struct { | 673 | type BlockSetSpec struct { |
@@ -592,6 +752,44 @@ func (s *BlockSetSpec) decode(content *hcl.BodyContent, blockLabels []blockLabel | |||
592 | if len(elems) == 0 { | 752 | if len(elems) == 0 { |
593 | ret = cty.SetValEmpty(s.Nested.impliedType()) | 753 | ret = cty.SetValEmpty(s.Nested.impliedType()) |
594 | } else { | 754 | } else { |
755 | // Since our target is a set, all of the decoded elements must have the | ||
756 | // same type or cty.SetVal will panic below. Different types can arise | ||
757 | // if there is an attribute spec of type cty.DynamicPseudoType in the | ||
758 | // nested spec; all given values must be convertable to a single type | ||
759 | // in order for the result to be considered valid. | ||
760 | etys := make([]cty.Type, len(elems)) | ||
761 | for i, v := range elems { | ||
762 | etys[i] = v.Type() | ||
763 | } | ||
764 | ety, convs := convert.UnifyUnsafe(etys) | ||
765 | if ety == cty.NilType { | ||
766 | // FIXME: This is a pretty terrible error message. | ||
767 | diags = append(diags, &hcl.Diagnostic{ | ||
768 | Severity: hcl.DiagError, | ||
769 | Summary: fmt.Sprintf("Unconsistent argument types in %s blocks", s.TypeName), | ||
770 | Detail: "Corresponding attributes in all blocks of this type must be the same.", | ||
771 | Subject: &sourceRanges[0], | ||
772 | }) | ||
773 | return cty.DynamicVal, diags | ||
774 | } | ||
775 | for i, v := range elems { | ||
776 | if convs[i] != nil { | ||
777 | newV, err := convs[i](v) | ||
778 | if err != nil { | ||
779 | // FIXME: This is a pretty terrible error message. | ||
780 | diags = append(diags, &hcl.Diagnostic{ | ||
781 | Severity: hcl.DiagError, | ||
782 | Summary: fmt.Sprintf("Unconsistent argument types in %s blocks", s.TypeName), | ||
783 | Detail: fmt.Sprintf("Block with index %d has inconsistent argument types: %s.", i, err), | ||
784 | Subject: &sourceRanges[i], | ||
785 | }) | ||
786 | // Bail early here so we won't panic below in cty.ListVal | ||
787 | return cty.DynamicVal, diags | ||
788 | } | ||
789 | elems[i] = newV | ||
790 | } | ||
791 | } | ||
792 | |||
595 | ret = cty.SetVal(elems) | 793 | ret = cty.SetVal(elems) |
596 | } | 794 | } |
597 | 795 | ||
@@ -672,7 +870,10 @@ func (s *BlockMapSpec) decode(content *hcl.BodyContent, blockLabels []blockLabel | |||
672 | var diags hcl.Diagnostics | 870 | var diags hcl.Diagnostics |
673 | 871 | ||
674 | if s.Nested == nil { | 872 | if s.Nested == nil { |
675 | panic("BlockSetSpec with no Nested Spec") | 873 | panic("BlockMapSpec with no Nested Spec") |
874 | } | ||
875 | if ImpliedType(s).HasDynamicTypes() { | ||
876 | panic("cty.DynamicPseudoType attributes may not be used inside a BlockMapSpec") | ||
676 | } | 877 | } |
677 | 878 | ||
678 | elems := map[string]interface{}{} | 879 | elems := map[string]interface{}{} |
@@ -765,6 +966,307 @@ func (s *BlockMapSpec) sourceRange(content *hcl.BodyContent, blockLabels []block | |||
765 | return sourceRange(childBlock.Body, labelsForBlock(childBlock), s.Nested) | 966 | return sourceRange(childBlock.Body, labelsForBlock(childBlock), s.Nested) |
766 | } | 967 | } |
767 | 968 | ||
969 | // A BlockObjectSpec is a Spec that produces a cty object of the results of | ||
970 | // decoding all of the nested blocks of a given type, using a nested spec. | ||
971 | // | ||
972 | // One level of object structure is created for each of the given label names. | ||
973 | // There must be at least one given label name. | ||
974 | // | ||
975 | // This is similar to BlockMapSpec, but it permits the nested blocks to have | ||
976 | // different result types in situations where cty.DynamicPseudoType attributes | ||
977 | // are present. | ||
978 | type BlockObjectSpec struct { | ||
979 | TypeName string | ||
980 | LabelNames []string | ||
981 | Nested Spec | ||
982 | } | ||
983 | |||
984 | func (s *BlockObjectSpec) visitSameBodyChildren(cb visitFunc) { | ||
985 | // leaf node ("Nested" does not use the same body) | ||
986 | } | ||
987 | |||
988 | // blockSpec implementation | ||
989 | func (s *BlockObjectSpec) blockHeaderSchemata() []hcl.BlockHeaderSchema { | ||
990 | return []hcl.BlockHeaderSchema{ | ||
991 | { | ||
992 | Type: s.TypeName, | ||
993 | LabelNames: append(s.LabelNames, findLabelSpecs(s.Nested)...), | ||
994 | }, | ||
995 | } | ||
996 | } | ||
997 | |||
998 | // blockSpec implementation | ||
999 | func (s *BlockObjectSpec) nestedSpec() Spec { | ||
1000 | return s.Nested | ||
1001 | } | ||
1002 | |||
1003 | // specNeedingVariables implementation | ||
1004 | func (s *BlockObjectSpec) variablesNeeded(content *hcl.BodyContent) []hcl.Traversal { | ||
1005 | var ret []hcl.Traversal | ||
1006 | |||
1007 | for _, childBlock := range content.Blocks { | ||
1008 | if childBlock.Type != s.TypeName { | ||
1009 | continue | ||
1010 | } | ||
1011 | |||
1012 | ret = append(ret, Variables(childBlock.Body, s.Nested)...) | ||
1013 | } | ||
1014 | |||
1015 | return ret | ||
1016 | } | ||
1017 | |||
1018 | func (s *BlockObjectSpec) decode(content *hcl.BodyContent, blockLabels []blockLabel, ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) { | ||
1019 | var diags hcl.Diagnostics | ||
1020 | |||
1021 | if s.Nested == nil { | ||
1022 | panic("BlockObjectSpec with no Nested Spec") | ||
1023 | } | ||
1024 | |||
1025 | elems := map[string]interface{}{} | ||
1026 | for _, childBlock := range content.Blocks { | ||
1027 | if childBlock.Type != s.TypeName { | ||
1028 | continue | ||
1029 | } | ||
1030 | |||
1031 | childLabels := labelsForBlock(childBlock) | ||
1032 | val, _, childDiags := decode(childBlock.Body, childLabels[len(s.LabelNames):], ctx, s.Nested, false) | ||
1033 | targetMap := elems | ||
1034 | for _, key := range childBlock.Labels[:len(s.LabelNames)-1] { | ||
1035 | if _, exists := targetMap[key]; !exists { | ||
1036 | targetMap[key] = make(map[string]interface{}) | ||
1037 | } | ||
1038 | targetMap = targetMap[key].(map[string]interface{}) | ||
1039 | } | ||
1040 | |||
1041 | diags = append(diags, childDiags...) | ||
1042 | |||
1043 | key := childBlock.Labels[len(s.LabelNames)-1] | ||
1044 | if _, exists := targetMap[key]; exists { | ||
1045 | labelsBuf := bytes.Buffer{} | ||
1046 | for _, label := range childBlock.Labels { | ||
1047 | fmt.Fprintf(&labelsBuf, " %q", label) | ||
1048 | } | ||
1049 | diags = append(diags, &hcl.Diagnostic{ | ||
1050 | Severity: hcl.DiagError, | ||
1051 | Summary: fmt.Sprintf("Duplicate %s block", s.TypeName), | ||
1052 | Detail: fmt.Sprintf( | ||
1053 | "A block for %s%s was already defined. The %s labels must be unique.", | ||
1054 | s.TypeName, labelsBuf.String(), s.TypeName, | ||
1055 | ), | ||
1056 | Subject: &childBlock.DefRange, | ||
1057 | }) | ||
1058 | continue | ||
1059 | } | ||
1060 | |||
1061 | targetMap[key] = val | ||
1062 | } | ||
1063 | |||
1064 | if len(elems) == 0 { | ||
1065 | return cty.EmptyObjectVal, diags | ||
1066 | } | ||
1067 | |||
1068 | var ctyObj func(map[string]interface{}, int) cty.Value | ||
1069 | ctyObj = func(raw map[string]interface{}, depth int) cty.Value { | ||
1070 | vals := make(map[string]cty.Value, len(raw)) | ||
1071 | if depth == 1 { | ||
1072 | for k, v := range raw { | ||
1073 | vals[k] = v.(cty.Value) | ||
1074 | } | ||
1075 | } else { | ||
1076 | for k, v := range raw { | ||
1077 | vals[k] = ctyObj(v.(map[string]interface{}), depth-1) | ||
1078 | } | ||
1079 | } | ||
1080 | return cty.ObjectVal(vals) | ||
1081 | } | ||
1082 | |||
1083 | return ctyObj(elems, len(s.LabelNames)), diags | ||
1084 | } | ||
1085 | |||
1086 | func (s *BlockObjectSpec) impliedType() cty.Type { | ||
1087 | // We can't predict our type, since we don't know how many blocks are | ||
1088 | // present and what labels they have until we decode. | ||
1089 | return cty.DynamicPseudoType | ||
1090 | } | ||
1091 | |||
1092 | func (s *BlockObjectSpec) sourceRange(content *hcl.BodyContent, blockLabels []blockLabel) hcl.Range { | ||
1093 | // We return the source range of the _first_ block of the given type, | ||
1094 | // since they are not guaranteed to form a contiguous range. | ||
1095 | |||
1096 | var childBlock *hcl.Block | ||
1097 | for _, candidate := range content.Blocks { | ||
1098 | if candidate.Type != s.TypeName { | ||
1099 | continue | ||
1100 | } | ||
1101 | |||
1102 | childBlock = candidate | ||
1103 | break | ||
1104 | } | ||
1105 | |||
1106 | if childBlock == nil { | ||
1107 | return content.MissingItemRange | ||
1108 | } | ||
1109 | |||
1110 | return sourceRange(childBlock.Body, labelsForBlock(childBlock), s.Nested) | ||
1111 | } | ||
1112 | |||
1113 | // A BlockAttrsSpec is a Spec that interprets a single block as if it were | ||
1114 | // a map of some element type. That is, each attribute within the block | ||
1115 | // becomes a key in the resulting map and the attribute's value becomes the | ||
1116 | // element value, after conversion to the given element type. The resulting | ||
1117 | // value is a cty.Map of the given element type. | ||
1118 | // | ||
1119 | // This spec imposes a validation constraint that there be exactly one block | ||
1120 | // of the given type name and that this block may contain only attributes. The | ||
1121 | // block does not accept any labels. | ||
1122 | // | ||
1123 | // This is an alternative to an AttrSpec of a map type for situations where | ||
1124 | // block syntax is desired. Note that block syntax does not permit dynamic | ||
1125 | // keys, construction of the result via a "for" expression, etc. In most cases | ||
1126 | // an AttrSpec is preferred if the desired result is a map whose keys are | ||
1127 | // chosen by the user rather than by schema. | ||
1128 | type BlockAttrsSpec struct { | ||
1129 | TypeName string | ||
1130 | ElementType cty.Type | ||
1131 | Required bool | ||
1132 | } | ||
1133 | |||
1134 | func (s *BlockAttrsSpec) visitSameBodyChildren(cb visitFunc) { | ||
1135 | // leaf node | ||
1136 | } | ||
1137 | |||
1138 | // blockSpec implementation | ||
1139 | func (s *BlockAttrsSpec) blockHeaderSchemata() []hcl.BlockHeaderSchema { | ||
1140 | return []hcl.BlockHeaderSchema{ | ||
1141 | { | ||
1142 | Type: s.TypeName, | ||
1143 | LabelNames: nil, | ||
1144 | }, | ||
1145 | } | ||
1146 | } | ||
1147 | |||
1148 | // blockSpec implementation | ||
1149 | func (s *BlockAttrsSpec) nestedSpec() Spec { | ||
1150 | // This is an odd case: we aren't actually going to apply a nested spec | ||
1151 | // in this case, since we're going to interpret the body directly as | ||
1152 | // attributes, but we need to return something non-nil so that the | ||
1153 | // decoder will recognize this as a block spec. We won't actually be | ||
1154 | // using this for anything at decode time. | ||
1155 | return noopSpec{} | ||
1156 | } | ||
1157 | |||
1158 | // specNeedingVariables implementation | ||
1159 | func (s *BlockAttrsSpec) variablesNeeded(content *hcl.BodyContent) []hcl.Traversal { | ||
1160 | |||
1161 | block, _ := s.findBlock(content) | ||
1162 | if block == nil { | ||
1163 | return nil | ||
1164 | } | ||
1165 | |||
1166 | var vars []hcl.Traversal | ||
1167 | |||
1168 | attrs, diags := block.Body.JustAttributes() | ||
1169 | if diags.HasErrors() { | ||
1170 | return nil | ||
1171 | } | ||
1172 | |||
1173 | for _, attr := range attrs { | ||
1174 | vars = append(vars, attr.Expr.Variables()...) | ||
1175 | } | ||
1176 | |||
1177 | // We'll return the variables references in source order so that any | ||
1178 | // error messages that result are also in source order. | ||
1179 | sort.Slice(vars, func(i, j int) bool { | ||
1180 | return vars[i].SourceRange().Start.Byte < vars[j].SourceRange().Start.Byte | ||
1181 | }) | ||
1182 | |||
1183 | return vars | ||
1184 | } | ||
1185 | |||
1186 | func (s *BlockAttrsSpec) decode(content *hcl.BodyContent, blockLabels []blockLabel, ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) { | ||
1187 | var diags hcl.Diagnostics | ||
1188 | |||
1189 | block, other := s.findBlock(content) | ||
1190 | if block == nil { | ||
1191 | if s.Required { | ||
1192 | diags = append(diags, &hcl.Diagnostic{ | ||
1193 | Severity: hcl.DiagError, | ||
1194 | Summary: fmt.Sprintf("Missing %s block", s.TypeName), | ||
1195 | Detail: fmt.Sprintf( | ||
1196 | "A block of type %q is required here.", s.TypeName, | ||
1197 | ), | ||
1198 | Subject: &content.MissingItemRange, | ||
1199 | }) | ||
1200 | } | ||
1201 | return cty.NullVal(cty.Map(s.ElementType)), diags | ||
1202 | } | ||
1203 | if other != nil { | ||
1204 | diags = append(diags, &hcl.Diagnostic{ | ||
1205 | Severity: hcl.DiagError, | ||
1206 | Summary: fmt.Sprintf("Duplicate %s block", s.TypeName), | ||
1207 | Detail: fmt.Sprintf( | ||
1208 | "Only one block of type %q is allowed. Previous definition was at %s.", | ||
1209 | s.TypeName, block.DefRange.String(), | ||
1210 | ), | ||
1211 | Subject: &other.DefRange, | ||
1212 | }) | ||
1213 | } | ||
1214 | |||
1215 | attrs, attrDiags := block.Body.JustAttributes() | ||
1216 | diags = append(diags, attrDiags...) | ||
1217 | |||
1218 | if len(attrs) == 0 { | ||
1219 | return cty.MapValEmpty(s.ElementType), diags | ||
1220 | } | ||
1221 | |||
1222 | vals := make(map[string]cty.Value, len(attrs)) | ||
1223 | for name, attr := range attrs { | ||
1224 | attrVal, attrDiags := attr.Expr.Value(ctx) | ||
1225 | diags = append(diags, attrDiags...) | ||
1226 | |||
1227 | attrVal, err := convert.Convert(attrVal, s.ElementType) | ||
1228 | if err != nil { | ||
1229 | diags = append(diags, &hcl.Diagnostic{ | ||
1230 | Severity: hcl.DiagError, | ||
1231 | Summary: "Invalid attribute value", | ||
1232 | Detail: fmt.Sprintf("Invalid value for attribute of %q block: %s.", s.TypeName, err), | ||
1233 | Subject: attr.Expr.Range().Ptr(), | ||
1234 | }) | ||
1235 | attrVal = cty.UnknownVal(s.ElementType) | ||
1236 | } | ||
1237 | |||
1238 | vals[name] = attrVal | ||
1239 | } | ||
1240 | |||
1241 | return cty.MapVal(vals), diags | ||
1242 | } | ||
1243 | |||
1244 | func (s *BlockAttrsSpec) impliedType() cty.Type { | ||
1245 | return cty.Map(s.ElementType) | ||
1246 | } | ||
1247 | |||
1248 | func (s *BlockAttrsSpec) sourceRange(content *hcl.BodyContent, blockLabels []blockLabel) hcl.Range { | ||
1249 | block, _ := s.findBlock(content) | ||
1250 | if block == nil { | ||
1251 | return content.MissingItemRange | ||
1252 | } | ||
1253 | return block.DefRange | ||
1254 | } | ||
1255 | |||
1256 | func (s *BlockAttrsSpec) findBlock(content *hcl.BodyContent) (block *hcl.Block, other *hcl.Block) { | ||
1257 | for _, candidate := range content.Blocks { | ||
1258 | if candidate.Type != s.TypeName { | ||
1259 | continue | ||
1260 | } | ||
1261 | if block != nil { | ||
1262 | return block, candidate | ||
1263 | } | ||
1264 | block = candidate | ||
1265 | } | ||
1266 | |||
1267 | return block, nil | ||
1268 | } | ||
1269 | |||
768 | // A BlockLabelSpec is a Spec that returns a cty.String representing the | 1270 | // A BlockLabelSpec is a Spec that returns a cty.String representing the |
769 | // label of the block its given body belongs to, if indeed its given body | 1271 | // label of the block its given body belongs to, if indeed its given body |
770 | // belongs to a block. It is a programming error to use this in a non-block | 1272 | // belongs to a block. It is a programming error to use this in a non-block |
@@ -848,6 +1350,16 @@ func findLabelSpecs(spec Spec) []string { | |||
848 | // | 1350 | // |
849 | // The two specifications must have the same implied result type for correct | 1351 | // The two specifications must have the same implied result type for correct |
850 | // operation. If not, the result is undefined. | 1352 | // operation. If not, the result is undefined. |
1353 | // | ||
1354 | // Any requirements imposed by the "Default" spec apply even if "Primary" does | ||
1355 | // not return null. For example, if the "Default" spec is for a required | ||
1356 | // attribute then that attribute is always required, regardless of the result | ||
1357 | // of the "Primary" spec. | ||
1358 | // | ||
1359 | // The "Default" spec must not describe a nested block, since otherwise the | ||
1360 | // result of ChildBlockTypes would not be decidable without evaluation. If | ||
1361 | // the default spec _does_ describe a nested block then the result is | ||
1362 | // undefined. | ||
851 | type DefaultSpec struct { | 1363 | type DefaultSpec struct { |
852 | Primary Spec | 1364 | Primary Spec |
853 | Default Spec | 1365 | Default Spec |
@@ -872,6 +1384,38 @@ func (s *DefaultSpec) impliedType() cty.Type { | |||
872 | return s.Primary.impliedType() | 1384 | return s.Primary.impliedType() |
873 | } | 1385 | } |
874 | 1386 | ||
1387 | // attrSpec implementation | ||
1388 | func (s *DefaultSpec) attrSchemata() []hcl.AttributeSchema { | ||
1389 | // We must pass through the union of both of our nested specs so that | ||
1390 | // we'll have both values available in the result. | ||
1391 | var ret []hcl.AttributeSchema | ||
1392 | if as, ok := s.Primary.(attrSpec); ok { | ||
1393 | ret = append(ret, as.attrSchemata()...) | ||
1394 | } | ||
1395 | if as, ok := s.Default.(attrSpec); ok { | ||
1396 | ret = append(ret, as.attrSchemata()...) | ||
1397 | } | ||
1398 | return ret | ||
1399 | } | ||
1400 | |||
1401 | // blockSpec implementation | ||
1402 | func (s *DefaultSpec) blockHeaderSchemata() []hcl.BlockHeaderSchema { | ||
1403 | // Only the primary spec may describe a block, since otherwise | ||
1404 | // our nestedSpec method below can't know which to return. | ||
1405 | if bs, ok := s.Primary.(blockSpec); ok { | ||
1406 | return bs.blockHeaderSchemata() | ||
1407 | } | ||
1408 | return nil | ||
1409 | } | ||
1410 | |||
1411 | // blockSpec implementation | ||
1412 | func (s *DefaultSpec) nestedSpec() Spec { | ||
1413 | if bs, ok := s.Primary.(blockSpec); ok { | ||
1414 | return bs.nestedSpec() | ||
1415 | } | ||
1416 | return nil | ||
1417 | } | ||
1418 | |||
875 | func (s *DefaultSpec) sourceRange(content *hcl.BodyContent, blockLabels []blockLabel) hcl.Range { | 1419 | func (s *DefaultSpec) sourceRange(content *hcl.BodyContent, blockLabels []blockLabel) hcl.Range { |
876 | // We can't tell from here which of the two specs will ultimately be used | 1420 | // We can't tell from here which of the two specs will ultimately be used |
877 | // in our result, so we'll just assume the first. This is usually the right | 1421 | // in our result, so we'll just assume the first. This is usually the right |
@@ -996,3 +1540,28 @@ func (s *TransformFuncSpec) sourceRange(content *hcl.BodyContent, blockLabels [] | |||
996 | // not super-accurate, because there's nothing better to return. | 1540 | // not super-accurate, because there's nothing better to return. |
997 | return s.Wrapped.sourceRange(content, blockLabels) | 1541 | return s.Wrapped.sourceRange(content, blockLabels) |
998 | } | 1542 | } |
1543 | |||
1544 | // noopSpec is a placeholder spec that does nothing, used in situations where | ||
1545 | // a non-nil placeholder spec is required. It is not exported because there is | ||
1546 | // no reason to use it directly; it is always an implementation detail only. | ||
1547 | type noopSpec struct { | ||
1548 | } | ||
1549 | |||
1550 | func (s noopSpec) decode(content *hcl.BodyContent, blockLabels []blockLabel, ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) { | ||
1551 | return cty.NullVal(cty.DynamicPseudoType), nil | ||
1552 | } | ||
1553 | |||
1554 | func (s noopSpec) impliedType() cty.Type { | ||
1555 | return cty.DynamicPseudoType | ||
1556 | } | ||
1557 | |||
1558 | func (s noopSpec) visitSameBodyChildren(cb visitFunc) { | ||
1559 | // nothing to do | ||
1560 | } | ||
1561 | |||
1562 | func (s noopSpec) sourceRange(content *hcl.BodyContent, blockLabels []blockLabel) hcl.Range { | ||
1563 | // No useful range for a noopSpec, and nobody should be calling this anyway. | ||
1564 | return hcl.Range{ | ||
1565 | Filename: "noopSpec", | ||
1566 | } | ||
1567 | } | ||
diff --git a/vendor/github.com/hashicorp/hcl2/hcldec/variables.go b/vendor/github.com/hashicorp/hcl2/hcldec/variables.go index 427b0d0..7662516 100644 --- a/vendor/github.com/hashicorp/hcl2/hcldec/variables.go +++ b/vendor/github.com/hashicorp/hcl2/hcldec/variables.go | |||
@@ -15,20 +15,22 @@ import ( | |||
15 | // be incomplete, but that's assumed to be okay because the eventual call | 15 | // be incomplete, but that's assumed to be okay because the eventual call |
16 | // to Decode will produce error diagnostics anyway. | 16 | // to Decode will produce error diagnostics anyway. |
17 | func Variables(body hcl.Body, spec Spec) []hcl.Traversal { | 17 | func Variables(body hcl.Body, spec Spec) []hcl.Traversal { |
18 | var vars []hcl.Traversal | ||
18 | schema := ImpliedSchema(spec) | 19 | schema := ImpliedSchema(spec) |
19 | |||
20 | content, _, _ := body.PartialContent(schema) | 20 | content, _, _ := body.PartialContent(schema) |
21 | 21 | ||
22 | var vars []hcl.Traversal | ||
23 | |||
24 | if vs, ok := spec.(specNeedingVariables); ok { | 22 | if vs, ok := spec.(specNeedingVariables); ok { |
25 | vars = append(vars, vs.variablesNeeded(content)...) | 23 | vars = append(vars, vs.variablesNeeded(content)...) |
26 | } | 24 | } |
27 | spec.visitSameBodyChildren(func(s Spec) { | 25 | |
26 | var visitFn visitFunc | ||
27 | visitFn = func(s Spec) { | ||
28 | if vs, ok := s.(specNeedingVariables); ok { | 28 | if vs, ok := s.(specNeedingVariables); ok { |
29 | vars = append(vars, vs.variablesNeeded(content)...) | 29 | vars = append(vars, vs.variablesNeeded(content)...) |
30 | } | 30 | } |
31 | }) | 31 | s.visitSameBodyChildren(visitFn) |
32 | } | ||
33 | spec.visitSameBodyChildren(visitFn) | ||
32 | 34 | ||
33 | return vars | 35 | return vars |
34 | } | 36 | } |
diff --git a/vendor/github.com/hashicorp/hcl2/hcled/doc.go b/vendor/github.com/hashicorp/hcl2/hcled/doc.go new file mode 100644 index 0000000..1a80144 --- /dev/null +++ b/vendor/github.com/hashicorp/hcl2/hcled/doc.go | |||
@@ -0,0 +1,4 @@ | |||
1 | // Package hcled provides functionality intended to help an application | ||
2 | // that embeds HCL to deliver relevant information to a text editor or IDE | ||
3 | // for navigating around and analyzing configuration files. | ||
4 | package hcled | ||
diff --git a/vendor/github.com/hashicorp/hcl2/hcled/navigation.go b/vendor/github.com/hashicorp/hcl2/hcled/navigation.go new file mode 100644 index 0000000..5d10cd8 --- /dev/null +++ b/vendor/github.com/hashicorp/hcl2/hcled/navigation.go | |||
@@ -0,0 +1,34 @@ | |||
1 | package hcled | ||
2 | |||
3 | import ( | ||
4 | "github.com/hashicorp/hcl2/hcl" | ||
5 | ) | ||
6 | |||
7 | type contextStringer interface { | ||
8 | ContextString(offset int) string | ||
9 | } | ||
10 | |||
11 | // ContextString returns a string describing the context of the given byte | ||
12 | // offset, if available. An empty string is returned if no such information | ||
13 | // is available, or otherwise the returned string is in a form that depends | ||
14 | // on the language used to write the referenced file. | ||
15 | func ContextString(file *hcl.File, offset int) string { | ||
16 | if cser, ok := file.Nav.(contextStringer); ok { | ||
17 | return cser.ContextString(offset) | ||
18 | } | ||
19 | return "" | ||
20 | } | ||
21 | |||
22 | type contextDefRanger interface { | ||
23 | ContextDefRange(offset int) hcl.Range | ||
24 | } | ||
25 | |||
26 | func ContextDefRange(file *hcl.File, offset int) hcl.Range { | ||
27 | if cser, ok := file.Nav.(contextDefRanger); ok { | ||
28 | defRange := cser.ContextDefRange(offset) | ||
29 | if !defRange.Empty() { | ||
30 | return defRange | ||
31 | } | ||
32 | } | ||
33 | return file.Body.MissingItemRange() | ||
34 | } | ||
diff --git a/vendor/github.com/hashicorp/hcl2/hclwrite/ast.go b/vendor/github.com/hashicorp/hcl2/hclwrite/ast.go new file mode 100644 index 0000000..0904165 --- /dev/null +++ b/vendor/github.com/hashicorp/hcl2/hclwrite/ast.go | |||
@@ -0,0 +1,121 @@ | |||
1 | package hclwrite | ||
2 | |||
3 | import ( | ||
4 | "bytes" | ||
5 | "io" | ||
6 | ) | ||
7 | |||
8 | type File struct { | ||
9 | inTree | ||
10 | |||
11 | srcBytes []byte | ||
12 | body *node | ||
13 | } | ||
14 | |||
15 | // NewEmptyFile constructs a new file with no content, ready to be mutated | ||
16 | // by other calls that append to its body. | ||
17 | func NewEmptyFile() *File { | ||
18 | f := &File{ | ||
19 | inTree: newInTree(), | ||
20 | } | ||
21 | body := newBody() | ||
22 | f.body = f.children.Append(body) | ||
23 | return f | ||
24 | } | ||
25 | |||
26 | // Body returns the root body of the file, which contains the top-level | ||
27 | // attributes and blocks. | ||
28 | func (f *File) Body() *Body { | ||
29 | return f.body.content.(*Body) | ||
30 | } | ||
31 | |||
32 | // WriteTo writes the tokens underlying the receiving file to the given writer. | ||
33 | // | ||
34 | // The tokens first have a simple formatting pass applied that adjusts only | ||
35 | // the spaces between them. | ||
36 | func (f *File) WriteTo(wr io.Writer) (int64, error) { | ||
37 | tokens := f.inTree.children.BuildTokens(nil) | ||
38 | format(tokens) | ||
39 | return tokens.WriteTo(wr) | ||
40 | } | ||
41 | |||
42 | // Bytes returns a buffer containing the source code resulting from the | ||
43 | // tokens underlying the receiving file. If any updates have been made via | ||
44 | // the AST API, these will be reflected in the result. | ||
45 | func (f *File) Bytes() []byte { | ||
46 | buf := &bytes.Buffer{} | ||
47 | f.WriteTo(buf) | ||
48 | return buf.Bytes() | ||
49 | } | ||
50 | |||
51 | type comments struct { | ||
52 | leafNode | ||
53 | |||
54 | parent *node | ||
55 | tokens Tokens | ||
56 | } | ||
57 | |||
58 | func newComments(tokens Tokens) *comments { | ||
59 | return &comments{ | ||
60 | tokens: tokens, | ||
61 | } | ||
62 | } | ||
63 | |||
64 | func (c *comments) BuildTokens(to Tokens) Tokens { | ||
65 | return c.tokens.BuildTokens(to) | ||
66 | } | ||
67 | |||
68 | type identifier struct { | ||
69 | leafNode | ||
70 | |||
71 | parent *node | ||
72 | token *Token | ||
73 | } | ||
74 | |||
75 | func newIdentifier(token *Token) *identifier { | ||
76 | return &identifier{ | ||
77 | token: token, | ||
78 | } | ||
79 | } | ||
80 | |||
81 | func (i *identifier) BuildTokens(to Tokens) Tokens { | ||
82 | return append(to, i.token) | ||
83 | } | ||
84 | |||
85 | func (i *identifier) hasName(name string) bool { | ||
86 | return name == string(i.token.Bytes) | ||
87 | } | ||
88 | |||
89 | type number struct { | ||
90 | leafNode | ||
91 | |||
92 | parent *node | ||
93 | token *Token | ||
94 | } | ||
95 | |||
96 | func newNumber(token *Token) *number { | ||
97 | return &number{ | ||
98 | token: token, | ||
99 | } | ||
100 | } | ||
101 | |||
102 | func (n *number) BuildTokens(to Tokens) Tokens { | ||
103 | return append(to, n.token) | ||
104 | } | ||
105 | |||
106 | type quoted struct { | ||
107 | leafNode | ||
108 | |||
109 | parent *node | ||
110 | tokens Tokens | ||
111 | } | ||
112 | |||
113 | func newQuoted(tokens Tokens) *quoted { | ||
114 | return "ed{ | ||
115 | tokens: tokens, | ||
116 | } | ||
117 | } | ||
118 | |||
119 | func (q *quoted) BuildTokens(to Tokens) Tokens { | ||
120 | return q.tokens.BuildTokens(to) | ||
121 | } | ||
diff --git a/vendor/github.com/hashicorp/hcl2/hclwrite/ast_attribute.go b/vendor/github.com/hashicorp/hcl2/hclwrite/ast_attribute.go new file mode 100644 index 0000000..975fa74 --- /dev/null +++ b/vendor/github.com/hashicorp/hcl2/hclwrite/ast_attribute.go | |||
@@ -0,0 +1,48 @@ | |||
1 | package hclwrite | ||
2 | |||
3 | import ( | ||
4 | "github.com/hashicorp/hcl2/hcl/hclsyntax" | ||
5 | ) | ||
6 | |||
7 | type Attribute struct { | ||
8 | inTree | ||
9 | |||
10 | leadComments *node | ||
11 | name *node | ||
12 | expr *node | ||
13 | lineComments *node | ||
14 | } | ||
15 | |||
16 | func newAttribute() *Attribute { | ||
17 | return &Attribute{ | ||
18 | inTree: newInTree(), | ||
19 | } | ||
20 | } | ||
21 | |||
22 | func (a *Attribute) init(name string, expr *Expression) { | ||
23 | expr.assertUnattached() | ||
24 | |||
25 | nameTok := newIdentToken(name) | ||
26 | nameObj := newIdentifier(nameTok) | ||
27 | a.leadComments = a.children.Append(newComments(nil)) | ||
28 | a.name = a.children.Append(nameObj) | ||
29 | a.children.AppendUnstructuredTokens(Tokens{ | ||
30 | { | ||
31 | Type: hclsyntax.TokenEqual, | ||
32 | Bytes: []byte{'='}, | ||
33 | }, | ||
34 | }) | ||
35 | a.expr = a.children.Append(expr) | ||
36 | a.expr.list = a.children | ||
37 | a.lineComments = a.children.Append(newComments(nil)) | ||
38 | a.children.AppendUnstructuredTokens(Tokens{ | ||
39 | { | ||
40 | Type: hclsyntax.TokenNewline, | ||
41 | Bytes: []byte{'\n'}, | ||
42 | }, | ||
43 | }) | ||
44 | } | ||
45 | |||
46 | func (a *Attribute) Expr() *Expression { | ||
47 | return a.expr.content.(*Expression) | ||
48 | } | ||
diff --git a/vendor/github.com/hashicorp/hcl2/hclwrite/ast_block.go b/vendor/github.com/hashicorp/hcl2/hclwrite/ast_block.go new file mode 100644 index 0000000..d5fd32b --- /dev/null +++ b/vendor/github.com/hashicorp/hcl2/hclwrite/ast_block.go | |||
@@ -0,0 +1,74 @@ | |||
1 | package hclwrite | ||
2 | |||
3 | import ( | ||
4 | "github.com/hashicorp/hcl2/hcl/hclsyntax" | ||
5 | "github.com/zclconf/go-cty/cty" | ||
6 | ) | ||
7 | |||
8 | type Block struct { | ||
9 | inTree | ||
10 | |||
11 | leadComments *node | ||
12 | typeName *node | ||
13 | labels nodeSet | ||
14 | open *node | ||
15 | body *node | ||
16 | close *node | ||
17 | } | ||
18 | |||
19 | func newBlock() *Block { | ||
20 | return &Block{ | ||
21 | inTree: newInTree(), | ||
22 | labels: newNodeSet(), | ||
23 | } | ||
24 | } | ||
25 | |||
26 | // NewBlock constructs a new, empty block with the given type name and labels. | ||
27 | func NewBlock(typeName string, labels []string) *Block { | ||
28 | block := newBlock() | ||
29 | block.init(typeName, labels) | ||
30 | return block | ||
31 | } | ||
32 | |||
33 | func (b *Block) init(typeName string, labels []string) { | ||
34 | nameTok := newIdentToken(typeName) | ||
35 | nameObj := newIdentifier(nameTok) | ||
36 | b.leadComments = b.children.Append(newComments(nil)) | ||
37 | b.typeName = b.children.Append(nameObj) | ||
38 | for _, label := range labels { | ||
39 | labelToks := TokensForValue(cty.StringVal(label)) | ||
40 | labelObj := newQuoted(labelToks) | ||
41 | labelNode := b.children.Append(labelObj) | ||
42 | b.labels.Add(labelNode) | ||
43 | } | ||
44 | b.open = b.children.AppendUnstructuredTokens(Tokens{ | ||
45 | { | ||
46 | Type: hclsyntax.TokenOBrace, | ||
47 | Bytes: []byte{'{'}, | ||
48 | }, | ||
49 | { | ||
50 | Type: hclsyntax.TokenNewline, | ||
51 | Bytes: []byte{'\n'}, | ||
52 | }, | ||
53 | }) | ||
54 | body := newBody() // initially totally empty; caller can append to it subsequently | ||
55 | b.body = b.children.Append(body) | ||
56 | b.close = b.children.AppendUnstructuredTokens(Tokens{ | ||
57 | { | ||
58 | Type: hclsyntax.TokenCBrace, | ||
59 | Bytes: []byte{'}'}, | ||
60 | }, | ||
61 | { | ||
62 | Type: hclsyntax.TokenNewline, | ||
63 | Bytes: []byte{'\n'}, | ||
64 | }, | ||
65 | }) | ||
66 | } | ||
67 | |||
68 | // Body returns the body that represents the content of the receiving block. | ||
69 | // | ||
70 | // Appending to or otherwise modifying this body will make changes to the | ||
71 | // tokens that are generated between the blocks open and close braces. | ||
72 | func (b *Block) Body() *Body { | ||
73 | return b.body.content.(*Body) | ||
74 | } | ||
diff --git a/vendor/github.com/hashicorp/hcl2/hclwrite/ast_body.go b/vendor/github.com/hashicorp/hcl2/hclwrite/ast_body.go new file mode 100644 index 0000000..cf69fee --- /dev/null +++ b/vendor/github.com/hashicorp/hcl2/hclwrite/ast_body.go | |||
@@ -0,0 +1,153 @@ | |||
1 | package hclwrite | ||
2 | |||
3 | import ( | ||
4 | "github.com/hashicorp/hcl2/hcl" | ||
5 | "github.com/hashicorp/hcl2/hcl/hclsyntax" | ||
6 | "github.com/zclconf/go-cty/cty" | ||
7 | ) | ||
8 | |||
9 | type Body struct { | ||
10 | inTree | ||
11 | |||
12 | items nodeSet | ||
13 | } | ||
14 | |||
15 | func newBody() *Body { | ||
16 | return &Body{ | ||
17 | inTree: newInTree(), | ||
18 | items: newNodeSet(), | ||
19 | } | ||
20 | } | ||
21 | |||
22 | func (b *Body) appendItem(c nodeContent) *node { | ||
23 | nn := b.children.Append(c) | ||
24 | b.items.Add(nn) | ||
25 | return nn | ||
26 | } | ||
27 | |||
28 | func (b *Body) appendItemNode(nn *node) *node { | ||
29 | nn.assertUnattached() | ||
30 | b.children.AppendNode(nn) | ||
31 | b.items.Add(nn) | ||
32 | return nn | ||
33 | } | ||
34 | |||
35 | // Clear removes all of the items from the body, making it empty. | ||
36 | func (b *Body) Clear() { | ||
37 | b.children.Clear() | ||
38 | } | ||
39 | |||
40 | func (b *Body) AppendUnstructuredTokens(ts Tokens) { | ||
41 | b.inTree.children.Append(ts) | ||
42 | } | ||
43 | |||
44 | // Attributes returns a new map of all of the attributes in the body, with | ||
45 | // the attribute names as the keys. | ||
46 | func (b *Body) Attributes() map[string]*Attribute { | ||
47 | ret := make(map[string]*Attribute) | ||
48 | for n := range b.items { | ||
49 | if attr, isAttr := n.content.(*Attribute); isAttr { | ||
50 | nameObj := attr.name.content.(*identifier) | ||
51 | name := string(nameObj.token.Bytes) | ||
52 | ret[name] = attr | ||
53 | } | ||
54 | } | ||
55 | return ret | ||
56 | } | ||
57 | |||
58 | // Blocks returns a new slice of all the blocks in the body. | ||
59 | func (b *Body) Blocks() []*Block { | ||
60 | ret := make([]*Block, 0, len(b.items)) | ||
61 | for n := range b.items { | ||
62 | if block, isBlock := n.content.(*Block); isBlock { | ||
63 | ret = append(ret, block) | ||
64 | } | ||
65 | } | ||
66 | return ret | ||
67 | } | ||
68 | |||
69 | // GetAttribute returns the attribute from the body that has the given name, | ||
70 | // or returns nil if there is currently no matching attribute. | ||
71 | func (b *Body) GetAttribute(name string) *Attribute { | ||
72 | for n := range b.items { | ||
73 | if attr, isAttr := n.content.(*Attribute); isAttr { | ||
74 | nameObj := attr.name.content.(*identifier) | ||
75 | if nameObj.hasName(name) { | ||
76 | // We've found it! | ||
77 | return attr | ||
78 | } | ||
79 | } | ||
80 | } | ||
81 | |||
82 | return nil | ||
83 | } | ||
84 | |||
85 | // SetAttributeValue either replaces the expression of an existing attribute | ||
86 | // of the given name or adds a new attribute definition to the end of the block. | ||
87 | // | ||
88 | // The value is given as a cty.Value, and must therefore be a literal. To set | ||
89 | // a variable reference or other traversal, use SetAttributeTraversal. | ||
90 | // | ||
91 | // The return value is the attribute that was either modified in-place or | ||
92 | // created. | ||
93 | func (b *Body) SetAttributeValue(name string, val cty.Value) *Attribute { | ||
94 | attr := b.GetAttribute(name) | ||
95 | expr := NewExpressionLiteral(val) | ||
96 | if attr != nil { | ||
97 | attr.expr = attr.expr.ReplaceWith(expr) | ||
98 | } else { | ||
99 | attr := newAttribute() | ||
100 | attr.init(name, expr) | ||
101 | b.appendItem(attr) | ||
102 | } | ||
103 | return attr | ||
104 | } | ||
105 | |||
106 | // SetAttributeTraversal either replaces the expression of an existing attribute | ||
107 | // of the given name or adds a new attribute definition to the end of the body. | ||
108 | // | ||
109 | // The new expression is given as a hcl.Traversal, which must be an absolute | ||
110 | // traversal. To set a literal value, use SetAttributeValue. | ||
111 | // | ||
112 | // The return value is the attribute that was either modified in-place or | ||
113 | // created. | ||
114 | func (b *Body) SetAttributeTraversal(name string, traversal hcl.Traversal) *Attribute { | ||
115 | attr := b.GetAttribute(name) | ||
116 | expr := NewExpressionAbsTraversal(traversal) | ||
117 | if attr != nil { | ||
118 | attr.expr = attr.expr.ReplaceWith(expr) | ||
119 | } else { | ||
120 | attr := newAttribute() | ||
121 | attr.init(name, expr) | ||
122 | b.appendItem(attr) | ||
123 | } | ||
124 | return attr | ||
125 | } | ||
126 | |||
127 | // AppendBlock appends an existing block (which must not be already attached | ||
128 | // to a body) to the end of the receiving body. | ||
129 | func (b *Body) AppendBlock(block *Block) *Block { | ||
130 | b.appendItem(block) | ||
131 | return block | ||
132 | } | ||
133 | |||
134 | // AppendNewBlock appends a new nested block to the end of the receiving body | ||
135 | // with the given type name and labels. | ||
136 | func (b *Body) AppendNewBlock(typeName string, labels []string) *Block { | ||
137 | block := newBlock() | ||
138 | block.init(typeName, labels) | ||
139 | b.appendItem(block) | ||
140 | return block | ||
141 | } | ||
142 | |||
143 | // AppendNewline appends a newline token to th end of the receiving body, | ||
144 | // which generally serves as a separator between different sets of body | ||
145 | // contents. | ||
146 | func (b *Body) AppendNewline() { | ||
147 | b.AppendUnstructuredTokens(Tokens{ | ||
148 | { | ||
149 | Type: hclsyntax.TokenNewline, | ||
150 | Bytes: []byte{'\n'}, | ||
151 | }, | ||
152 | }) | ||
153 | } | ||
diff --git a/vendor/github.com/hashicorp/hcl2/hclwrite/ast_expression.go b/vendor/github.com/hashicorp/hcl2/hclwrite/ast_expression.go new file mode 100644 index 0000000..62d89fb --- /dev/null +++ b/vendor/github.com/hashicorp/hcl2/hclwrite/ast_expression.go | |||
@@ -0,0 +1,201 @@ | |||
1 | package hclwrite | ||
2 | |||
3 | import ( | ||
4 | "fmt" | ||
5 | |||
6 | "github.com/hashicorp/hcl2/hcl" | ||
7 | "github.com/hashicorp/hcl2/hcl/hclsyntax" | ||
8 | "github.com/zclconf/go-cty/cty" | ||
9 | ) | ||
10 | |||
11 | type Expression struct { | ||
12 | inTree | ||
13 | |||
14 | absTraversals nodeSet | ||
15 | } | ||
16 | |||
17 | func newExpression() *Expression { | ||
18 | return &Expression{ | ||
19 | inTree: newInTree(), | ||
20 | absTraversals: newNodeSet(), | ||
21 | } | ||
22 | } | ||
23 | |||
24 | // NewExpressionLiteral constructs an an expression that represents the given | ||
25 | // literal value. | ||
26 | // | ||
27 | // Since an unknown value cannot be represented in source code, this function | ||
28 | // will panic if the given value is unknown or contains a nested unknown value. | ||
29 | // Use val.IsWhollyKnown before calling to be sure. | ||
30 | // | ||
31 | // HCL native syntax does not directly represent lists, maps, and sets, and | ||
32 | // instead relies on the automatic conversions to those collection types from | ||
33 | // either list or tuple constructor syntax. Therefore converting collection | ||
34 | // values to source code and re-reading them will lose type information, and | ||
35 | // the reader must provide a suitable type at decode time to recover the | ||
36 | // original value. | ||
37 | func NewExpressionLiteral(val cty.Value) *Expression { | ||
38 | toks := TokensForValue(val) | ||
39 | expr := newExpression() | ||
40 | expr.children.AppendUnstructuredTokens(toks) | ||
41 | return expr | ||
42 | } | ||
43 | |||
44 | // NewExpressionAbsTraversal constructs an expression that represents the | ||
45 | // given traversal, which must be absolute or this function will panic. | ||
46 | func NewExpressionAbsTraversal(traversal hcl.Traversal) *Expression { | ||
47 | if traversal.IsRelative() { | ||
48 | panic("can't construct expression from relative traversal") | ||
49 | } | ||
50 | |||
51 | physT := newTraversal() | ||
52 | rootName := traversal.RootName() | ||
53 | steps := traversal[1:] | ||
54 | |||
55 | { | ||
56 | tn := newTraverseName() | ||
57 | tn.name = tn.children.Append(newIdentifier(&Token{ | ||
58 | Type: hclsyntax.TokenIdent, | ||
59 | Bytes: []byte(rootName), | ||
60 | })) | ||
61 | physT.steps.Add(physT.children.Append(tn)) | ||
62 | } | ||
63 | |||
64 | for _, step := range steps { | ||
65 | switch ts := step.(type) { | ||
66 | case hcl.TraverseAttr: | ||
67 | tn := newTraverseName() | ||
68 | tn.children.AppendUnstructuredTokens(Tokens{ | ||
69 | { | ||
70 | Type: hclsyntax.TokenDot, | ||
71 | Bytes: []byte{'.'}, | ||
72 | }, | ||
73 | }) | ||
74 | tn.name = tn.children.Append(newIdentifier(&Token{ | ||
75 | Type: hclsyntax.TokenIdent, | ||
76 | Bytes: []byte(ts.Name), | ||
77 | })) | ||
78 | physT.steps.Add(physT.children.Append(tn)) | ||
79 | case hcl.TraverseIndex: | ||
80 | ti := newTraverseIndex() | ||
81 | ti.children.AppendUnstructuredTokens(Tokens{ | ||
82 | { | ||
83 | Type: hclsyntax.TokenOBrack, | ||
84 | Bytes: []byte{'['}, | ||
85 | }, | ||
86 | }) | ||
87 | indexExpr := NewExpressionLiteral(ts.Key) | ||
88 | ti.key = ti.children.Append(indexExpr) | ||
89 | ti.children.AppendUnstructuredTokens(Tokens{ | ||
90 | { | ||
91 | Type: hclsyntax.TokenCBrack, | ||
92 | Bytes: []byte{']'}, | ||
93 | }, | ||
94 | }) | ||
95 | physT.steps.Add(physT.children.Append(ti)) | ||
96 | } | ||
97 | } | ||
98 | |||
99 | expr := newExpression() | ||
100 | expr.absTraversals.Add(expr.children.Append(physT)) | ||
101 | return expr | ||
102 | } | ||
103 | |||
104 | // Variables returns the absolute traversals that exist within the receiving | ||
105 | // expression. | ||
106 | func (e *Expression) Variables() []*Traversal { | ||
107 | nodes := e.absTraversals.List() | ||
108 | ret := make([]*Traversal, len(nodes)) | ||
109 | for i, node := range nodes { | ||
110 | ret[i] = node.content.(*Traversal) | ||
111 | } | ||
112 | return ret | ||
113 | } | ||
114 | |||
115 | // RenameVariablePrefix examines each of the absolute traversals in the | ||
116 | // receiving expression to see if they have the given sequence of names as | ||
117 | // a prefix prefix. If so, they are updated in place to have the given | ||
118 | // replacement names instead of that prefix. | ||
119 | // | ||
120 | // This can be used to implement symbol renaming. The calling application can | ||
121 | // visit all relevant expressions in its input and apply the same renaming | ||
122 | // to implement a global symbol rename. | ||
123 | // | ||
124 | // The search and replacement traversals must be the same length, or this | ||
125 | // method will panic. Only attribute access operations can be matched and | ||
126 | // replaced. Index steps never match the prefix. | ||
127 | func (e *Expression) RenameVariablePrefix(search, replacement []string) { | ||
128 | if len(search) != len(replacement) { | ||
129 | panic(fmt.Sprintf("search and replacement length mismatch (%d and %d)", len(search), len(replacement))) | ||
130 | } | ||
131 | Traversals: | ||
132 | for node := range e.absTraversals { | ||
133 | traversal := node.content.(*Traversal) | ||
134 | if len(traversal.steps) < len(search) { | ||
135 | // If it's shorter then it can't have our prefix | ||
136 | continue | ||
137 | } | ||
138 | |||
139 | stepNodes := traversal.steps.List() | ||
140 | for i, name := range search { | ||
141 | step, isName := stepNodes[i].content.(*TraverseName) | ||
142 | if !isName { | ||
143 | continue Traversals // only name nodes can match | ||
144 | } | ||
145 | foundNameBytes := step.name.content.(*identifier).token.Bytes | ||
146 | if len(foundNameBytes) != len(name) { | ||
147 | continue Traversals | ||
148 | } | ||
149 | if string(foundNameBytes) != name { | ||
150 | continue Traversals | ||
151 | } | ||
152 | } | ||
153 | |||
154 | // If we get here then the prefix matched, so now we'll swap in | ||
155 | // the replacement strings. | ||
156 | for i, name := range replacement { | ||
157 | step := stepNodes[i].content.(*TraverseName) | ||
158 | token := step.name.content.(*identifier).token | ||
159 | token.Bytes = []byte(name) | ||
160 | } | ||
161 | } | ||
162 | } | ||
163 | |||
164 | // Traversal represents a sequence of variable, attribute, and/or index | ||
165 | // operations. | ||
166 | type Traversal struct { | ||
167 | inTree | ||
168 | |||
169 | steps nodeSet | ||
170 | } | ||
171 | |||
172 | func newTraversal() *Traversal { | ||
173 | return &Traversal{ | ||
174 | inTree: newInTree(), | ||
175 | steps: newNodeSet(), | ||
176 | } | ||
177 | } | ||
178 | |||
179 | type TraverseName struct { | ||
180 | inTree | ||
181 | |||
182 | name *node | ||
183 | } | ||
184 | |||
185 | func newTraverseName() *TraverseName { | ||
186 | return &TraverseName{ | ||
187 | inTree: newInTree(), | ||
188 | } | ||
189 | } | ||
190 | |||
191 | type TraverseIndex struct { | ||
192 | inTree | ||
193 | |||
194 | key *node | ||
195 | } | ||
196 | |||
197 | func newTraverseIndex() *TraverseIndex { | ||
198 | return &TraverseIndex{ | ||
199 | inTree: newInTree(), | ||
200 | } | ||
201 | } | ||
diff --git a/vendor/github.com/hashicorp/hcl2/hclwrite/doc.go b/vendor/github.com/hashicorp/hcl2/hclwrite/doc.go new file mode 100644 index 0000000..56d5b77 --- /dev/null +++ b/vendor/github.com/hashicorp/hcl2/hclwrite/doc.go | |||
@@ -0,0 +1,11 @@ | |||
1 | // Package hclwrite deals with the problem of generating HCL configuration | ||
2 | // and of making specific surgical changes to existing HCL configurations. | ||
3 | // | ||
4 | // It operates at a different level of abstraction than the main HCL parser | ||
5 | // and AST, since details such as the placement of comments and newlines | ||
6 | // are preserved when unchanged. | ||
7 | // | ||
8 | // The hclwrite API follows a similar principle to XML/HTML DOM, allowing nodes | ||
9 | // to be read out, created and inserted, etc. Nodes represent syntax constructs | ||
10 | // rather than semantic concepts. | ||
11 | package hclwrite | ||
diff --git a/vendor/github.com/hashicorp/hcl2/hclwrite/format.go b/vendor/github.com/hashicorp/hcl2/hclwrite/format.go new file mode 100644 index 0000000..f20ae23 --- /dev/null +++ b/vendor/github.com/hashicorp/hcl2/hclwrite/format.go | |||
@@ -0,0 +1,492 @@ | |||
1 | package hclwrite | ||
2 | |||
3 | import ( | ||
4 | "github.com/hashicorp/hcl2/hcl/hclsyntax" | ||
5 | ) | ||
6 | |||
7 | var inKeyword = hclsyntax.Keyword([]byte{'i', 'n'}) | ||
8 | |||
9 | // placeholder token used when we don't have a token but we don't want | ||
10 | // to pass a real "nil" and complicate things with nil pointer checks | ||
11 | var nilToken = &Token{ | ||
12 | Type: hclsyntax.TokenNil, | ||
13 | Bytes: []byte{}, | ||
14 | SpacesBefore: 0, | ||
15 | } | ||
16 | |||
17 | // format rewrites tokens within the given sequence, in-place, to adjust the | ||
18 | // whitespace around their content to achieve canonical formatting. | ||
19 | func format(tokens Tokens) { | ||
20 | // Formatting is a multi-pass process. More details on the passes below, | ||
21 | // but this is the overview: | ||
22 | // - adjust the leading space on each line to create appropriate | ||
23 | // indentation | ||
24 | // - adjust spaces between tokens in a single cell using a set of rules | ||
25 | // - adjust the leading space in the "assign" and "comment" cells on each | ||
26 | // line to vertically align with neighboring lines. | ||
27 | // All of these steps operate in-place on the given tokens, so a caller | ||
28 | // may collect a flat sequence of all of the tokens underlying an AST | ||
29 | // and pass it here and we will then indirectly modify the AST itself. | ||
30 | // Formatting must change only whitespace. Specifically, that means | ||
31 | // changing the SpacesBefore attribute on a token while leaving the | ||
32 | // other token attributes unchanged. | ||
33 | |||
34 | lines := linesForFormat(tokens) | ||
35 | formatIndent(lines) | ||
36 | formatSpaces(lines) | ||
37 | formatCells(lines) | ||
38 | } | ||
39 | |||
40 | func formatIndent(lines []formatLine) { | ||
41 | // Our methodology for indents is to take the input one line at a time | ||
42 | // and count the bracketing delimiters on each line. If a line has a net | ||
43 | // increase in open brackets, we increase the indent level by one and | ||
44 | // remember how many new openers we had. If the line has a net _decrease_, | ||
45 | // we'll compare it to the most recent number of openers and decrease the | ||
46 | // dedent level by one each time we pass an indent level remembered | ||
47 | // earlier. | ||
48 | // The "indent stack" used here allows for us to recognize degenerate | ||
49 | // input where brackets are not symmetrical within lines and avoid | ||
50 | // pushing things too far left or right, creating confusion. | ||
51 | |||
52 | // We'll start our indent stack at a reasonable capacity to minimize the | ||
53 | // chance of us needing to grow it; 10 here means 10 levels of indent, | ||
54 | // which should be more than enough for reasonable HCL uses. | ||
55 | indents := make([]int, 0, 10) | ||
56 | |||
57 | inHeredoc := false | ||
58 | for i := range lines { | ||
59 | line := &lines[i] | ||
60 | if len(line.lead) == 0 { | ||
61 | continue | ||
62 | } | ||
63 | |||
64 | if inHeredoc { | ||
65 | for _, token := range line.lead { | ||
66 | if token.Type == hclsyntax.TokenCHeredoc { | ||
67 | inHeredoc = false | ||
68 | } | ||
69 | } | ||
70 | continue // don't touch indentation inside heredocs | ||
71 | } | ||
72 | |||
73 | if line.lead[0].Type == hclsyntax.TokenNewline { | ||
74 | // Never place spaces before a newline | ||
75 | line.lead[0].SpacesBefore = 0 | ||
76 | continue | ||
77 | } | ||
78 | |||
79 | netBrackets := 0 | ||
80 | for _, token := range line.lead { | ||
81 | netBrackets += tokenBracketChange(token) | ||
82 | if token.Type == hclsyntax.TokenOHeredoc { | ||
83 | inHeredoc = true | ||
84 | } | ||
85 | } | ||
86 | for _, token := range line.assign { | ||
87 | netBrackets += tokenBracketChange(token) | ||
88 | } | ||
89 | |||
90 | switch { | ||
91 | case netBrackets > 0: | ||
92 | line.lead[0].SpacesBefore = 2 * len(indents) | ||
93 | indents = append(indents, netBrackets) | ||
94 | case netBrackets < 0: | ||
95 | closed := -netBrackets | ||
96 | for closed > 0 && len(indents) > 0 { | ||
97 | switch { | ||
98 | |||
99 | case closed > indents[len(indents)-1]: | ||
100 | closed -= indents[len(indents)-1] | ||
101 | indents = indents[:len(indents)-1] | ||
102 | |||
103 | case closed < indents[len(indents)-1]: | ||
104 | indents[len(indents)-1] -= closed | ||
105 | closed = 0 | ||
106 | |||
107 | default: | ||
108 | indents = indents[:len(indents)-1] | ||
109 | closed = 0 | ||
110 | } | ||
111 | } | ||
112 | line.lead[0].SpacesBefore = 2 * len(indents) | ||
113 | default: | ||
114 | line.lead[0].SpacesBefore = 2 * len(indents) | ||
115 | } | ||
116 | } | ||
117 | } | ||
118 | |||
119 | func formatSpaces(lines []formatLine) { | ||
120 | for _, line := range lines { | ||
121 | for i, token := range line.lead { | ||
122 | var before, after *Token | ||
123 | if i > 0 { | ||
124 | before = line.lead[i-1] | ||
125 | } else { | ||
126 | before = nilToken | ||
127 | } | ||
128 | if i < (len(line.lead) - 1) { | ||
129 | after = line.lead[i+1] | ||
130 | } else { | ||
131 | after = nilToken | ||
132 | } | ||
133 | if spaceAfterToken(token, before, after) { | ||
134 | after.SpacesBefore = 1 | ||
135 | } else { | ||
136 | after.SpacesBefore = 0 | ||
137 | } | ||
138 | } | ||
139 | for i, token := range line.assign { | ||
140 | if i == 0 { | ||
141 | // first token in "assign" always has one space before to | ||
142 | // separate the equals sign from what it's assigning. | ||
143 | token.SpacesBefore = 1 | ||
144 | } | ||
145 | |||
146 | var before, after *Token | ||
147 | if i > 0 { | ||
148 | before = line.assign[i-1] | ||
149 | } else { | ||
150 | before = nilToken | ||
151 | } | ||
152 | if i < (len(line.assign) - 1) { | ||
153 | after = line.assign[i+1] | ||
154 | } else { | ||
155 | after = nilToken | ||
156 | } | ||
157 | if spaceAfterToken(token, before, after) { | ||
158 | after.SpacesBefore = 1 | ||
159 | } else { | ||
160 | after.SpacesBefore = 0 | ||
161 | } | ||
162 | } | ||
163 | |||
164 | } | ||
165 | } | ||
166 | |||
167 | func formatCells(lines []formatLine) { | ||
168 | |||
169 | chainStart := -1 | ||
170 | maxColumns := 0 | ||
171 | |||
172 | // We'll deal with the "assign" cell first, since moving that will | ||
173 | // also impact the "comment" cell. | ||
174 | closeAssignChain := func(i int) { | ||
175 | for _, chainLine := range lines[chainStart:i] { | ||
176 | columns := chainLine.lead.Columns() | ||
177 | spaces := (maxColumns - columns) + 1 | ||
178 | chainLine.assign[0].SpacesBefore = spaces | ||
179 | } | ||
180 | chainStart = -1 | ||
181 | maxColumns = 0 | ||
182 | } | ||
183 | for i, line := range lines { | ||
184 | if line.assign == nil { | ||
185 | if chainStart != -1 { | ||
186 | closeAssignChain(i) | ||
187 | } | ||
188 | } else { | ||
189 | if chainStart == -1 { | ||
190 | chainStart = i | ||
191 | } | ||
192 | columns := line.lead.Columns() | ||
193 | if columns > maxColumns { | ||
194 | maxColumns = columns | ||
195 | } | ||
196 | } | ||
197 | } | ||
198 | if chainStart != -1 { | ||
199 | closeAssignChain(len(lines)) | ||
200 | } | ||
201 | |||
202 | // Now we'll deal with the comments | ||
203 | closeCommentChain := func(i int) { | ||
204 | for _, chainLine := range lines[chainStart:i] { | ||
205 | columns := chainLine.lead.Columns() + chainLine.assign.Columns() | ||
206 | spaces := (maxColumns - columns) + 1 | ||
207 | chainLine.comment[0].SpacesBefore = spaces | ||
208 | } | ||
209 | chainStart = -1 | ||
210 | maxColumns = 0 | ||
211 | } | ||
212 | for i, line := range lines { | ||
213 | if line.comment == nil { | ||
214 | if chainStart != -1 { | ||
215 | closeCommentChain(i) | ||
216 | } | ||
217 | } else { | ||
218 | if chainStart == -1 { | ||
219 | chainStart = i | ||
220 | } | ||
221 | columns := line.lead.Columns() + line.assign.Columns() | ||
222 | if columns > maxColumns { | ||
223 | maxColumns = columns | ||
224 | } | ||
225 | } | ||
226 | } | ||
227 | if chainStart != -1 { | ||
228 | closeCommentChain(len(lines)) | ||
229 | } | ||
230 | |||
231 | } | ||
232 | |||
233 | // spaceAfterToken decides whether a particular subject token should have a | ||
234 | // space after it when surrounded by the given before and after tokens. | ||
235 | // "before" can be TokenNil, if the subject token is at the start of a sequence. | ||
236 | func spaceAfterToken(subject, before, after *Token) bool { | ||
237 | switch { | ||
238 | |||
239 | case after.Type == hclsyntax.TokenNewline || after.Type == hclsyntax.TokenNil: | ||
240 | // Never add spaces before a newline | ||
241 | return false | ||
242 | |||
243 | case subject.Type == hclsyntax.TokenIdent && after.Type == hclsyntax.TokenOParen: | ||
244 | // Don't split a function name from open paren in a call | ||
245 | return false | ||
246 | |||
247 | case subject.Type == hclsyntax.TokenDot || after.Type == hclsyntax.TokenDot: | ||
248 | // Don't use spaces around attribute access dots | ||
249 | return false | ||
250 | |||
251 | case after.Type == hclsyntax.TokenComma || after.Type == hclsyntax.TokenEllipsis: | ||
252 | // No space right before a comma or ... in an argument list | ||
253 | return false | ||
254 | |||
255 | case subject.Type == hclsyntax.TokenComma: | ||
256 | // Always a space after a comma | ||
257 | return true | ||
258 | |||
259 | case subject.Type == hclsyntax.TokenQuotedLit || subject.Type == hclsyntax.TokenStringLit || subject.Type == hclsyntax.TokenOQuote || subject.Type == hclsyntax.TokenOHeredoc || after.Type == hclsyntax.TokenQuotedLit || after.Type == hclsyntax.TokenStringLit || after.Type == hclsyntax.TokenCQuote || after.Type == hclsyntax.TokenCHeredoc: | ||
260 | // No extra spaces within templates | ||
261 | return false | ||
262 | |||
263 | case inKeyword.TokenMatches(subject.asHCLSyntax()) && before.Type == hclsyntax.TokenIdent: | ||
264 | // This is a special case for inside for expressions where a user | ||
265 | // might want to use a literal tuple constructor: | ||
266 | // [for x in [foo]: x] | ||
267 | // ... in that case, we would normally produce in[foo] thinking that | ||
268 | // in is a reference, but we'll recognize it as a keyword here instead | ||
269 | // to make the result less confusing. | ||
270 | return true | ||
271 | |||
272 | case after.Type == hclsyntax.TokenOBrack && (subject.Type == hclsyntax.TokenIdent || subject.Type == hclsyntax.TokenNumberLit || tokenBracketChange(subject) < 0): | ||
273 | return false | ||
274 | |||
275 | case subject.Type == hclsyntax.TokenMinus: | ||
276 | // Since a minus can either be subtraction or negation, and the latter | ||
277 | // should _not_ have a space after it, we need to use some heuristics | ||
278 | // to decide which case this is. | ||
279 | // We guess that we have a negation if the token before doesn't look | ||
280 | // like it could be the end of an expression. | ||
281 | |||
282 | switch before.Type { | ||
283 | |||
284 | case hclsyntax.TokenNil: | ||
285 | // Minus at the start of input must be a negation | ||
286 | return false | ||
287 | |||
288 | case hclsyntax.TokenOParen, hclsyntax.TokenOBrace, hclsyntax.TokenOBrack, hclsyntax.TokenEqual, hclsyntax.TokenColon, hclsyntax.TokenComma, hclsyntax.TokenQuestion: | ||
289 | // Minus immediately after an opening bracket or separator must be a negation. | ||
290 | return false | ||
291 | |||
292 | case hclsyntax.TokenPlus, hclsyntax.TokenStar, hclsyntax.TokenSlash, hclsyntax.TokenPercent, hclsyntax.TokenMinus: | ||
293 | // Minus immediately after another arithmetic operator must be negation. | ||
294 | return false | ||
295 | |||
296 | case hclsyntax.TokenEqualOp, hclsyntax.TokenNotEqual, hclsyntax.TokenGreaterThan, hclsyntax.TokenGreaterThanEq, hclsyntax.TokenLessThan, hclsyntax.TokenLessThanEq: | ||
297 | // Minus immediately after another comparison operator must be negation. | ||
298 | return false | ||
299 | |||
300 | case hclsyntax.TokenAnd, hclsyntax.TokenOr, hclsyntax.TokenBang: | ||
301 | // Minus immediately after logical operator doesn't make sense but probably intended as negation. | ||
302 | return false | ||
303 | |||
304 | default: | ||
305 | return true | ||
306 | } | ||
307 | |||
308 | case subject.Type == hclsyntax.TokenOBrace || after.Type == hclsyntax.TokenCBrace: | ||
309 | // Unlike other bracket types, braces have spaces on both sides of them, | ||
310 | // both in single-line nested blocks foo { bar = baz } and in object | ||
311 | // constructor expressions foo = { bar = baz }. | ||
312 | if subject.Type == hclsyntax.TokenOBrace && after.Type == hclsyntax.TokenCBrace { | ||
313 | // An open brace followed by a close brace is an exception, however. | ||
314 | // e.g. foo {} rather than foo { } | ||
315 | return false | ||
316 | } | ||
317 | return true | ||
318 | |||
319 | // In the unlikely event that an interpolation expression is just | ||
320 | // a single object constructor, we'll put a space between the ${ and | ||
321 | // the following { to make this more obvious, and then the same | ||
322 | // thing for the two braces at the end. | ||
323 | case (subject.Type == hclsyntax.TokenTemplateInterp || subject.Type == hclsyntax.TokenTemplateControl) && after.Type == hclsyntax.TokenOBrace: | ||
324 | return true | ||
325 | case subject.Type == hclsyntax.TokenCBrace && after.Type == hclsyntax.TokenTemplateSeqEnd: | ||
326 | return true | ||
327 | |||
328 | // Don't add spaces between interpolated items | ||
329 | case subject.Type == hclsyntax.TokenTemplateSeqEnd && after.Type == hclsyntax.TokenTemplateInterp: | ||
330 | return false | ||
331 | |||
332 | case tokenBracketChange(subject) > 0: | ||
333 | // No spaces after open brackets | ||
334 | return false | ||
335 | |||
336 | case tokenBracketChange(after) < 0: | ||
337 | // No spaces before close brackets | ||
338 | return false | ||
339 | |||
340 | default: | ||
341 | // Most tokens are space-separated | ||
342 | return true | ||
343 | |||
344 | } | ||
345 | } | ||
346 | |||
347 | func linesForFormat(tokens Tokens) []formatLine { | ||
348 | if len(tokens) == 0 { | ||
349 | return make([]formatLine, 0) | ||
350 | } | ||
351 | |||
352 | // first we'll count our lines, so we can allocate the array for them in | ||
353 | // a single block. (We want to minimize memory pressure in this codepath, | ||
354 | // so it can be run somewhat-frequently by editor integrations.) | ||
355 | lineCount := 1 // if there are zero newlines then there is one line | ||
356 | for _, tok := range tokens { | ||
357 | if tokenIsNewline(tok) { | ||
358 | lineCount++ | ||
359 | } | ||
360 | } | ||
361 | |||
362 | // To start, we'll just put everything in the "lead" cell on each line, | ||
363 | // and then do another pass over the lines afterwards to adjust. | ||
364 | lines := make([]formatLine, lineCount) | ||
365 | li := 0 | ||
366 | lineStart := 0 | ||
367 | for i, tok := range tokens { | ||
368 | if tok.Type == hclsyntax.TokenEOF { | ||
369 | // The EOF token doesn't belong to any line, and terminates the | ||
370 | // token sequence. | ||
371 | lines[li].lead = tokens[lineStart:i] | ||
372 | break | ||
373 | } | ||
374 | |||
375 | if tokenIsNewline(tok) { | ||
376 | lines[li].lead = tokens[lineStart : i+1] | ||
377 | lineStart = i + 1 | ||
378 | li++ | ||
379 | } | ||
380 | } | ||
381 | |||
382 | // If a set of tokens doesn't end in TokenEOF (e.g. because it's a | ||
383 | // fragment of tokens from the middle of a file) then we might fall | ||
384 | // out here with a line still pending. | ||
385 | if lineStart < len(tokens) { | ||
386 | lines[li].lead = tokens[lineStart:] | ||
387 | if lines[li].lead[len(lines[li].lead)-1].Type == hclsyntax.TokenEOF { | ||
388 | lines[li].lead = lines[li].lead[:len(lines[li].lead)-1] | ||
389 | } | ||
390 | } | ||
391 | |||
392 | // Now we'll pick off any trailing comments and attribute assignments | ||
393 | // to shuffle off into the "comment" and "assign" cells. | ||
394 | inHeredoc := false | ||
395 | for i := range lines { | ||
396 | line := &lines[i] | ||
397 | if len(line.lead) == 0 { | ||
398 | // if the line is empty then there's nothing for us to do | ||
399 | // (this should happen only for the final line, because all other | ||
400 | // lines would have a newline token of some kind) | ||
401 | continue | ||
402 | } | ||
403 | |||
404 | if inHeredoc { | ||
405 | for _, tok := range line.lead { | ||
406 | if tok.Type == hclsyntax.TokenCHeredoc { | ||
407 | inHeredoc = false | ||
408 | break | ||
409 | } | ||
410 | } | ||
411 | // Inside a heredoc everything is "lead", even if there's a | ||
412 | // template interpolation embedded in there that might otherwise | ||
413 | // confuse our logic below. | ||
414 | continue | ||
415 | } | ||
416 | |||
417 | for _, tok := range line.lead { | ||
418 | if tok.Type == hclsyntax.TokenOHeredoc { | ||
419 | inHeredoc = true | ||
420 | break | ||
421 | } | ||
422 | } | ||
423 | |||
424 | if len(line.lead) > 1 && line.lead[len(line.lead)-1].Type == hclsyntax.TokenComment { | ||
425 | line.comment = line.lead[len(line.lead)-1:] | ||
426 | line.lead = line.lead[:len(line.lead)-1] | ||
427 | } | ||
428 | |||
429 | for i, tok := range line.lead { | ||
430 | if i > 0 && tok.Type == hclsyntax.TokenEqual { | ||
431 | // We only move the tokens into "assign" if the RHS seems to | ||
432 | // be a whole expression, which we determine by counting | ||
433 | // brackets. If there's a net positive number of brackets | ||
434 | // then that suggests we're introducing a multi-line expression. | ||
435 | netBrackets := 0 | ||
436 | for _, token := range line.lead[i:] { | ||
437 | netBrackets += tokenBracketChange(token) | ||
438 | } | ||
439 | |||
440 | if netBrackets == 0 { | ||
441 | line.assign = line.lead[i:] | ||
442 | line.lead = line.lead[:i] | ||
443 | } | ||
444 | break | ||
445 | } | ||
446 | } | ||
447 | } | ||
448 | |||
449 | return lines | ||
450 | } | ||
451 | |||
452 | func tokenIsNewline(tok *Token) bool { | ||
453 | if tok.Type == hclsyntax.TokenNewline { | ||
454 | return true | ||
455 | } else if tok.Type == hclsyntax.TokenComment { | ||
456 | // Single line tokens (# and //) consume their terminating newline, | ||
457 | // so we need to treat them as newline tokens as well. | ||
458 | if len(tok.Bytes) > 0 && tok.Bytes[len(tok.Bytes)-1] == '\n' { | ||
459 | return true | ||
460 | } | ||
461 | } | ||
462 | return false | ||
463 | } | ||
464 | |||
465 | func tokenBracketChange(tok *Token) int { | ||
466 | switch tok.Type { | ||
467 | case hclsyntax.TokenOBrace, hclsyntax.TokenOBrack, hclsyntax.TokenOParen, hclsyntax.TokenTemplateControl, hclsyntax.TokenTemplateInterp: | ||
468 | return 1 | ||
469 | case hclsyntax.TokenCBrace, hclsyntax.TokenCBrack, hclsyntax.TokenCParen, hclsyntax.TokenTemplateSeqEnd: | ||
470 | return -1 | ||
471 | default: | ||
472 | return 0 | ||
473 | } | ||
474 | } | ||
475 | |||
476 | // formatLine represents a single line of source code for formatting purposes, | ||
477 | // splitting its tokens into up to three "cells": | ||
478 | // | ||
479 | // lead: always present, representing everything up to one of the others | ||
480 | // assign: if line contains an attribute assignment, represents the tokens | ||
481 | // starting at (and including) the equals symbol | ||
482 | // comment: if line contains any non-comment tokens and ends with a | ||
483 | // single-line comment token, represents the comment. | ||
484 | // | ||
485 | // When formatting, the leading spaces of the first tokens in each of these | ||
486 | // cells is adjusted to align vertically their occurences on consecutive | ||
487 | // rows. | ||
488 | type formatLine struct { | ||
489 | lead Tokens | ||
490 | assign Tokens | ||
491 | comment Tokens | ||
492 | } | ||
diff --git a/vendor/github.com/hashicorp/hcl2/hclwrite/generate.go b/vendor/github.com/hashicorp/hcl2/hclwrite/generate.go new file mode 100644 index 0000000..d249cfd --- /dev/null +++ b/vendor/github.com/hashicorp/hcl2/hclwrite/generate.go | |||
@@ -0,0 +1,250 @@ | |||
1 | package hclwrite | ||
2 | |||
3 | import ( | ||
4 | "fmt" | ||
5 | "unicode" | ||
6 | "unicode/utf8" | ||
7 | |||
8 | "github.com/hashicorp/hcl2/hcl" | ||
9 | "github.com/hashicorp/hcl2/hcl/hclsyntax" | ||
10 | "github.com/zclconf/go-cty/cty" | ||
11 | ) | ||
12 | |||
13 | // TokensForValue returns a sequence of tokens that represents the given | ||
14 | // constant value. | ||
15 | // | ||
16 | // This function only supports types that are used by HCL. In particular, it | ||
17 | // does not support capsule types and will panic if given one. | ||
18 | // | ||
19 | // It is not possible to express an unknown value in source code, so this | ||
20 | // function will panic if the given value is unknown or contains any unknown | ||
21 | // values. A caller can call the value's IsWhollyKnown method to verify that | ||
22 | // no unknown values are present before calling TokensForValue. | ||
23 | func TokensForValue(val cty.Value) Tokens { | ||
24 | toks := appendTokensForValue(val, nil) | ||
25 | format(toks) // fiddle with the SpacesBefore field to get canonical spacing | ||
26 | return toks | ||
27 | } | ||
28 | |||
29 | // TokensForTraversal returns a sequence of tokens that represents the given | ||
30 | // traversal. | ||
31 | // | ||
32 | // If the traversal is absolute then the result is a self-contained, valid | ||
33 | // reference expression. If the traversal is relative then the returned tokens | ||
34 | // could be appended to some other expression tokens to traverse into the | ||
35 | // represented expression. | ||
36 | func TokensForTraversal(traversal hcl.Traversal) Tokens { | ||
37 | toks := appendTokensForTraversal(traversal, nil) | ||
38 | format(toks) // fiddle with the SpacesBefore field to get canonical spacing | ||
39 | return toks | ||
40 | } | ||
41 | |||
42 | func appendTokensForValue(val cty.Value, toks Tokens) Tokens { | ||
43 | switch { | ||
44 | |||
45 | case !val.IsKnown(): | ||
46 | panic("cannot produce tokens for unknown value") | ||
47 | |||
48 | case val.IsNull(): | ||
49 | toks = append(toks, &Token{ | ||
50 | Type: hclsyntax.TokenIdent, | ||
51 | Bytes: []byte(`null`), | ||
52 | }) | ||
53 | |||
54 | case val.Type() == cty.Bool: | ||
55 | var src []byte | ||
56 | if val.True() { | ||
57 | src = []byte(`true`) | ||
58 | } else { | ||
59 | src = []byte(`false`) | ||
60 | } | ||
61 | toks = append(toks, &Token{ | ||
62 | Type: hclsyntax.TokenIdent, | ||
63 | Bytes: src, | ||
64 | }) | ||
65 | |||
66 | case val.Type() == cty.Number: | ||
67 | bf := val.AsBigFloat() | ||
68 | srcStr := bf.Text('f', -1) | ||
69 | toks = append(toks, &Token{ | ||
70 | Type: hclsyntax.TokenNumberLit, | ||
71 | Bytes: []byte(srcStr), | ||
72 | }) | ||
73 | |||
74 | case val.Type() == cty.String: | ||
75 | // TODO: If it's a multi-line string ending in a newline, format | ||
76 | // it as a HEREDOC instead. | ||
77 | src := escapeQuotedStringLit(val.AsString()) | ||
78 | toks = append(toks, &Token{ | ||
79 | Type: hclsyntax.TokenOQuote, | ||
80 | Bytes: []byte{'"'}, | ||
81 | }) | ||
82 | if len(src) > 0 { | ||
83 | toks = append(toks, &Token{ | ||
84 | Type: hclsyntax.TokenQuotedLit, | ||
85 | Bytes: src, | ||
86 | }) | ||
87 | } | ||
88 | toks = append(toks, &Token{ | ||
89 | Type: hclsyntax.TokenCQuote, | ||
90 | Bytes: []byte{'"'}, | ||
91 | }) | ||
92 | |||
93 | case val.Type().IsListType() || val.Type().IsSetType() || val.Type().IsTupleType(): | ||
94 | toks = append(toks, &Token{ | ||
95 | Type: hclsyntax.TokenOBrack, | ||
96 | Bytes: []byte{'['}, | ||
97 | }) | ||
98 | |||
99 | i := 0 | ||
100 | for it := val.ElementIterator(); it.Next(); { | ||
101 | if i > 0 { | ||
102 | toks = append(toks, &Token{ | ||
103 | Type: hclsyntax.TokenComma, | ||
104 | Bytes: []byte{','}, | ||
105 | }) | ||
106 | } | ||
107 | _, eVal := it.Element() | ||
108 | toks = appendTokensForValue(eVal, toks) | ||
109 | i++ | ||
110 | } | ||
111 | |||
112 | toks = append(toks, &Token{ | ||
113 | Type: hclsyntax.TokenCBrack, | ||
114 | Bytes: []byte{']'}, | ||
115 | }) | ||
116 | |||
117 | case val.Type().IsMapType() || val.Type().IsObjectType(): | ||
118 | toks = append(toks, &Token{ | ||
119 | Type: hclsyntax.TokenOBrace, | ||
120 | Bytes: []byte{'{'}, | ||
121 | }) | ||
122 | |||
123 | i := 0 | ||
124 | for it := val.ElementIterator(); it.Next(); { | ||
125 | if i > 0 { | ||
126 | toks = append(toks, &Token{ | ||
127 | Type: hclsyntax.TokenComma, | ||
128 | Bytes: []byte{','}, | ||
129 | }) | ||
130 | } | ||
131 | eKey, eVal := it.Element() | ||
132 | if hclsyntax.ValidIdentifier(eKey.AsString()) { | ||
133 | toks = append(toks, &Token{ | ||
134 | Type: hclsyntax.TokenIdent, | ||
135 | Bytes: []byte(eKey.AsString()), | ||
136 | }) | ||
137 | } else { | ||
138 | toks = appendTokensForValue(eKey, toks) | ||
139 | } | ||
140 | toks = append(toks, &Token{ | ||
141 | Type: hclsyntax.TokenEqual, | ||
142 | Bytes: []byte{'='}, | ||
143 | }) | ||
144 | toks = appendTokensForValue(eVal, toks) | ||
145 | i++ | ||
146 | } | ||
147 | |||
148 | toks = append(toks, &Token{ | ||
149 | Type: hclsyntax.TokenCBrace, | ||
150 | Bytes: []byte{'}'}, | ||
151 | }) | ||
152 | |||
153 | default: | ||
154 | panic(fmt.Sprintf("cannot produce tokens for %#v", val)) | ||
155 | } | ||
156 | |||
157 | return toks | ||
158 | } | ||
159 | |||
160 | func appendTokensForTraversal(traversal hcl.Traversal, toks Tokens) Tokens { | ||
161 | for _, step := range traversal { | ||
162 | appendTokensForTraversalStep(step, toks) | ||
163 | } | ||
164 | return toks | ||
165 | } | ||
166 | |||
167 | func appendTokensForTraversalStep(step hcl.Traverser, toks Tokens) { | ||
168 | switch ts := step.(type) { | ||
169 | case hcl.TraverseRoot: | ||
170 | toks = append(toks, &Token{ | ||
171 | Type: hclsyntax.TokenIdent, | ||
172 | Bytes: []byte(ts.Name), | ||
173 | }) | ||
174 | case hcl.TraverseAttr: | ||
175 | toks = append( | ||
176 | toks, | ||
177 | &Token{ | ||
178 | Type: hclsyntax.TokenDot, | ||
179 | Bytes: []byte{'.'}, | ||
180 | }, | ||
181 | &Token{ | ||
182 | Type: hclsyntax.TokenIdent, | ||
183 | Bytes: []byte(ts.Name), | ||
184 | }, | ||
185 | ) | ||
186 | case hcl.TraverseIndex: | ||
187 | toks = append(toks, &Token{ | ||
188 | Type: hclsyntax.TokenOBrack, | ||
189 | Bytes: []byte{'['}, | ||
190 | }) | ||
191 | appendTokensForValue(ts.Key, toks) | ||
192 | toks = append(toks, &Token{ | ||
193 | Type: hclsyntax.TokenCBrack, | ||
194 | Bytes: []byte{']'}, | ||
195 | }) | ||
196 | default: | ||
197 | panic(fmt.Sprintf("unsupported traversal step type %T", step)) | ||
198 | } | ||
199 | } | ||
200 | |||
201 | func escapeQuotedStringLit(s string) []byte { | ||
202 | if len(s) == 0 { | ||
203 | return nil | ||
204 | } | ||
205 | buf := make([]byte, 0, len(s)) | ||
206 | for i, r := range s { | ||
207 | switch r { | ||
208 | case '\n': | ||
209 | buf = append(buf, '\\', 'n') | ||
210 | case '\r': | ||
211 | buf = append(buf, '\\', 'r') | ||
212 | case '\t': | ||
213 | buf = append(buf, '\\', 't') | ||
214 | case '"': | ||
215 | buf = append(buf, '\\', '"') | ||
216 | case '\\': | ||
217 | buf = append(buf, '\\', '\\') | ||
218 | case '$', '%': | ||
219 | buf = appendRune(buf, r) | ||
220 | remain := s[i+1:] | ||
221 | if len(remain) > 0 && remain[0] == '{' { | ||
222 | // Double up our template introducer symbol to escape it. | ||
223 | buf = appendRune(buf, r) | ||
224 | } | ||
225 | default: | ||
226 | if !unicode.IsPrint(r) { | ||
227 | var fmted string | ||
228 | if r < 65536 { | ||
229 | fmted = fmt.Sprintf("\\u%04x", r) | ||
230 | } else { | ||
231 | fmted = fmt.Sprintf("\\U%08x", r) | ||
232 | } | ||
233 | buf = append(buf, fmted...) | ||
234 | } else { | ||
235 | buf = appendRune(buf, r) | ||
236 | } | ||
237 | } | ||
238 | } | ||
239 | return buf | ||
240 | } | ||
241 | |||
242 | func appendRune(b []byte, r rune) []byte { | ||
243 | l := utf8.RuneLen(r) | ||
244 | for i := 0; i < l; i++ { | ||
245 | b = append(b, 0) // make room at the end of our buffer | ||
246 | } | ||
247 | ch := b[len(b)-l:] | ||
248 | utf8.EncodeRune(ch, r) | ||
249 | return b | ||
250 | } | ||
diff --git a/vendor/github.com/hashicorp/hcl2/hclwrite/native_node_sorter.go b/vendor/github.com/hashicorp/hcl2/hclwrite/native_node_sorter.go new file mode 100644 index 0000000..a13c0ec --- /dev/null +++ b/vendor/github.com/hashicorp/hcl2/hclwrite/native_node_sorter.go | |||
@@ -0,0 +1,23 @@ | |||
1 | package hclwrite | ||
2 | |||
3 | import ( | ||
4 | "github.com/hashicorp/hcl2/hcl/hclsyntax" | ||
5 | ) | ||
6 | |||
7 | type nativeNodeSorter struct { | ||
8 | Nodes []hclsyntax.Node | ||
9 | } | ||
10 | |||
11 | func (s nativeNodeSorter) Len() int { | ||
12 | return len(s.Nodes) | ||
13 | } | ||
14 | |||
15 | func (s nativeNodeSorter) Less(i, j int) bool { | ||
16 | rangeI := s.Nodes[i].Range() | ||
17 | rangeJ := s.Nodes[j].Range() | ||
18 | return rangeI.Start.Byte < rangeJ.Start.Byte | ||
19 | } | ||
20 | |||
21 | func (s nativeNodeSorter) Swap(i, j int) { | ||
22 | s.Nodes[i], s.Nodes[j] = s.Nodes[j], s.Nodes[i] | ||
23 | } | ||
diff --git a/vendor/github.com/hashicorp/hcl2/hclwrite/node.go b/vendor/github.com/hashicorp/hcl2/hclwrite/node.go new file mode 100644 index 0000000..71fd00f --- /dev/null +++ b/vendor/github.com/hashicorp/hcl2/hclwrite/node.go | |||
@@ -0,0 +1,236 @@ | |||
1 | package hclwrite | ||
2 | |||
3 | import ( | ||
4 | "fmt" | ||
5 | |||
6 | "github.com/google/go-cmp/cmp" | ||
7 | ) | ||
8 | |||
9 | // node represents a node in the AST. | ||
10 | type node struct { | ||
11 | content nodeContent | ||
12 | |||
13 | list *nodes | ||
14 | before, after *node | ||
15 | } | ||
16 | |||
17 | func newNode(c nodeContent) *node { | ||
18 | return &node{ | ||
19 | content: c, | ||
20 | } | ||
21 | } | ||
22 | |||
23 | func (n *node) Equal(other *node) bool { | ||
24 | return cmp.Equal(n.content, other.content) | ||
25 | } | ||
26 | |||
27 | func (n *node) BuildTokens(to Tokens) Tokens { | ||
28 | return n.content.BuildTokens(to) | ||
29 | } | ||
30 | |||
31 | // Detach removes the receiver from the list it currently belongs to. If the | ||
32 | // node is not currently in a list, this is a no-op. | ||
33 | func (n *node) Detach() { | ||
34 | if n.list == nil { | ||
35 | return | ||
36 | } | ||
37 | if n.before != nil { | ||
38 | n.before.after = n.after | ||
39 | } | ||
40 | if n.after != nil { | ||
41 | n.after.before = n.before | ||
42 | } | ||
43 | if n.list.first == n { | ||
44 | n.list.first = n.after | ||
45 | } | ||
46 | if n.list.last == n { | ||
47 | n.list.last = n.before | ||
48 | } | ||
49 | n.list = nil | ||
50 | n.before = nil | ||
51 | n.after = nil | ||
52 | } | ||
53 | |||
54 | // ReplaceWith removes the receiver from the list it currently belongs to and | ||
55 | // inserts a new node with the given content in its place. If the node is not | ||
56 | // currently in a list, this function will panic. | ||
57 | // | ||
58 | // The return value is the newly-constructed node, containing the given content. | ||
59 | // After this function returns, the reciever is no longer attached to a list. | ||
60 | func (n *node) ReplaceWith(c nodeContent) *node { | ||
61 | if n.list == nil { | ||
62 | panic("can't replace node that is not in a list") | ||
63 | } | ||
64 | |||
65 | before := n.before | ||
66 | after := n.after | ||
67 | list := n.list | ||
68 | n.before, n.after, n.list = nil, nil, nil | ||
69 | |||
70 | nn := newNode(c) | ||
71 | nn.before = before | ||
72 | nn.after = after | ||
73 | nn.list = list | ||
74 | if before != nil { | ||
75 | before.after = nn | ||
76 | } | ||
77 | if after != nil { | ||
78 | after.before = nn | ||
79 | } | ||
80 | return nn | ||
81 | } | ||
82 | |||
83 | func (n *node) assertUnattached() { | ||
84 | if n.list != nil { | ||
85 | panic(fmt.Sprintf("attempt to attach already-attached node %#v", n)) | ||
86 | } | ||
87 | } | ||
88 | |||
89 | // nodeContent is the interface type implemented by all AST content types. | ||
90 | type nodeContent interface { | ||
91 | walkChildNodes(w internalWalkFunc) | ||
92 | BuildTokens(to Tokens) Tokens | ||
93 | } | ||
94 | |||
95 | // nodes is a list of nodes. | ||
96 | type nodes struct { | ||
97 | first, last *node | ||
98 | } | ||
99 | |||
100 | func (ns *nodes) BuildTokens(to Tokens) Tokens { | ||
101 | for n := ns.first; n != nil; n = n.after { | ||
102 | to = n.BuildTokens(to) | ||
103 | } | ||
104 | return to | ||
105 | } | ||
106 | |||
107 | func (ns *nodes) Clear() { | ||
108 | ns.first = nil | ||
109 | ns.last = nil | ||
110 | } | ||
111 | |||
112 | func (ns *nodes) Append(c nodeContent) *node { | ||
113 | n := &node{ | ||
114 | content: c, | ||
115 | } | ||
116 | ns.AppendNode(n) | ||
117 | n.list = ns | ||
118 | return n | ||
119 | } | ||
120 | |||
121 | func (ns *nodes) AppendNode(n *node) { | ||
122 | if ns.last != nil { | ||
123 | n.before = ns.last | ||
124 | ns.last.after = n | ||
125 | } | ||
126 | n.list = ns | ||
127 | ns.last = n | ||
128 | if ns.first == nil { | ||
129 | ns.first = n | ||
130 | } | ||
131 | } | ||
132 | |||
133 | func (ns *nodes) AppendUnstructuredTokens(tokens Tokens) *node { | ||
134 | if len(tokens) == 0 { | ||
135 | return nil | ||
136 | } | ||
137 | n := newNode(tokens) | ||
138 | ns.AppendNode(n) | ||
139 | n.list = ns | ||
140 | return n | ||
141 | } | ||
142 | |||
143 | // nodeSet is an unordered set of nodes. It is used to describe a set of nodes | ||
144 | // that all belong to the same list that have some role or characteristic | ||
145 | // in common. | ||
146 | type nodeSet map[*node]struct{} | ||
147 | |||
148 | func newNodeSet() nodeSet { | ||
149 | return make(nodeSet) | ||
150 | } | ||
151 | |||
152 | func (ns nodeSet) Has(n *node) bool { | ||
153 | if ns == nil { | ||
154 | return false | ||
155 | } | ||
156 | _, exists := ns[n] | ||
157 | return exists | ||
158 | } | ||
159 | |||
160 | func (ns nodeSet) Add(n *node) { | ||
161 | ns[n] = struct{}{} | ||
162 | } | ||
163 | |||
164 | func (ns nodeSet) Remove(n *node) { | ||
165 | delete(ns, n) | ||
166 | } | ||
167 | |||
168 | func (ns nodeSet) List() []*node { | ||
169 | if len(ns) == 0 { | ||
170 | return nil | ||
171 | } | ||
172 | |||
173 | ret := make([]*node, 0, len(ns)) | ||
174 | |||
175 | // Determine which list we are working with. We assume here that all of | ||
176 | // the nodes belong to the same list, since that is part of the contract | ||
177 | // for nodeSet. | ||
178 | var list *nodes | ||
179 | for n := range ns { | ||
180 | list = n.list | ||
181 | break | ||
182 | } | ||
183 | |||
184 | // We recover the order by iterating over the whole list. This is not | ||
185 | // the most efficient way to do it, but our node lists should always be | ||
186 | // small so not worth making things more complex. | ||
187 | for n := list.first; n != nil; n = n.after { | ||
188 | if ns.Has(n) { | ||
189 | ret = append(ret, n) | ||
190 | } | ||
191 | } | ||
192 | return ret | ||
193 | } | ||
194 | |||
195 | type internalWalkFunc func(*node) | ||
196 | |||
197 | // inTree can be embedded into a content struct that has child nodes to get | ||
198 | // a standard implementation of the NodeContent interface and a record of | ||
199 | // a potential parent node. | ||
200 | type inTree struct { | ||
201 | parent *node | ||
202 | children *nodes | ||
203 | } | ||
204 | |||
205 | func newInTree() inTree { | ||
206 | return inTree{ | ||
207 | children: &nodes{}, | ||
208 | } | ||
209 | } | ||
210 | |||
211 | func (it *inTree) assertUnattached() { | ||
212 | if it.parent != nil { | ||
213 | panic(fmt.Sprintf("node is already attached to %T", it.parent.content)) | ||
214 | } | ||
215 | } | ||
216 | |||
217 | func (it *inTree) walkChildNodes(w internalWalkFunc) { | ||
218 | for n := it.children.first; n != nil; n = n.after { | ||
219 | w(n) | ||
220 | } | ||
221 | } | ||
222 | |||
223 | func (it *inTree) BuildTokens(to Tokens) Tokens { | ||
224 | for n := it.children.first; n != nil; n = n.after { | ||
225 | to = n.BuildTokens(to) | ||
226 | } | ||
227 | return to | ||
228 | } | ||
229 | |||
230 | // leafNode can be embedded into a content struct to give it a do-nothing | ||
231 | // implementation of walkChildNodes | ||
232 | type leafNode struct { | ||
233 | } | ||
234 | |||
235 | func (n *leafNode) walkChildNodes(w internalWalkFunc) { | ||
236 | } | ||
diff --git a/vendor/github.com/hashicorp/hcl2/hclwrite/parser.go b/vendor/github.com/hashicorp/hcl2/hclwrite/parser.go new file mode 100644 index 0000000..1876818 --- /dev/null +++ b/vendor/github.com/hashicorp/hcl2/hclwrite/parser.go | |||
@@ -0,0 +1,594 @@ | |||
1 | package hclwrite | ||
2 | |||
3 | import ( | ||
4 | "fmt" | ||
5 | "sort" | ||
6 | |||
7 | "github.com/hashicorp/hcl2/hcl" | ||
8 | "github.com/hashicorp/hcl2/hcl/hclsyntax" | ||
9 | "github.com/zclconf/go-cty/cty" | ||
10 | ) | ||
11 | |||
12 | // Our "parser" here is actually not doing any parsing of its own. Instead, | ||
13 | // it leans on the native parser in hclsyntax, and then uses the source ranges | ||
14 | // from the AST to partition the raw token sequence to match the raw tokens | ||
15 | // up to AST nodes. | ||
16 | // | ||
17 | // This strategy feels somewhat counter-intuitive, since most of the work the | ||
18 | // parser does is thrown away here, but this strategy is chosen because the | ||
19 | // normal parsing work done by hclsyntax is considered to be the "main case", | ||
20 | // while modifying and re-printing source is more of an edge case, used only | ||
21 | // in ancillary tools, and so it's good to keep all the main parsing logic | ||
22 | // with the main case but keep all of the extra complexity of token wrangling | ||
23 | // out of the main parser, which is already rather complex just serving the | ||
24 | // use-cases it already serves. | ||
25 | // | ||
26 | // If the parsing step produces any errors, the returned File is nil because | ||
27 | // we can't reliably extract tokens from the partial AST produced by an | ||
28 | // erroneous parse. | ||
29 | func parse(src []byte, filename string, start hcl.Pos) (*File, hcl.Diagnostics) { | ||
30 | file, diags := hclsyntax.ParseConfig(src, filename, start) | ||
31 | if diags.HasErrors() { | ||
32 | return nil, diags | ||
33 | } | ||
34 | |||
35 | // To do our work here, we use the "native" tokens (those from hclsyntax) | ||
36 | // to match against source ranges in the AST, but ultimately produce | ||
37 | // slices from our sequence of "writer" tokens, which contain only | ||
38 | // *relative* position information that is more appropriate for | ||
39 | // transformation/writing use-cases. | ||
40 | nativeTokens, diags := hclsyntax.LexConfig(src, filename, start) | ||
41 | if diags.HasErrors() { | ||
42 | // should never happen, since we would've caught these diags in | ||
43 | // the first call above. | ||
44 | return nil, diags | ||
45 | } | ||
46 | writerTokens := writerTokens(nativeTokens) | ||
47 | |||
48 | from := inputTokens{ | ||
49 | nativeTokens: nativeTokens, | ||
50 | writerTokens: writerTokens, | ||
51 | } | ||
52 | |||
53 | before, root, after := parseBody(file.Body.(*hclsyntax.Body), from) | ||
54 | ret := &File{ | ||
55 | inTree: newInTree(), | ||
56 | |||
57 | srcBytes: src, | ||
58 | body: root, | ||
59 | } | ||
60 | |||
61 | nodes := ret.inTree.children | ||
62 | nodes.Append(before.Tokens()) | ||
63 | nodes.AppendNode(root) | ||
64 | nodes.Append(after.Tokens()) | ||
65 | |||
66 | return ret, diags | ||
67 | } | ||
68 | |||
69 | type inputTokens struct { | ||
70 | nativeTokens hclsyntax.Tokens | ||
71 | writerTokens Tokens | ||
72 | } | ||
73 | |||
74 | func (it inputTokens) Partition(rng hcl.Range) (before, within, after inputTokens) { | ||
75 | start, end := partitionTokens(it.nativeTokens, rng) | ||
76 | before = it.Slice(0, start) | ||
77 | within = it.Slice(start, end) | ||
78 | after = it.Slice(end, len(it.nativeTokens)) | ||
79 | return | ||
80 | } | ||
81 | |||
82 | func (it inputTokens) PartitionType(ty hclsyntax.TokenType) (before, within, after inputTokens) { | ||
83 | for i, t := range it.writerTokens { | ||
84 | if t.Type == ty { | ||
85 | return it.Slice(0, i), it.Slice(i, i+1), it.Slice(i+1, len(it.nativeTokens)) | ||
86 | } | ||
87 | } | ||
88 | panic(fmt.Sprintf("didn't find any token of type %s", ty)) | ||
89 | } | ||
90 | |||
91 | func (it inputTokens) PartitionTypeSingle(ty hclsyntax.TokenType) (before inputTokens, found *Token, after inputTokens) { | ||
92 | before, within, after := it.PartitionType(ty) | ||
93 | if within.Len() != 1 { | ||
94 | panic("PartitionType found more than one token") | ||
95 | } | ||
96 | return before, within.Tokens()[0], after | ||
97 | } | ||
98 | |||
99 | // PartitionIncludeComments is like Partition except the returned "within" | ||
100 | // range includes any lead and line comments associated with the range. | ||
101 | func (it inputTokens) PartitionIncludingComments(rng hcl.Range) (before, within, after inputTokens) { | ||
102 | start, end := partitionTokens(it.nativeTokens, rng) | ||
103 | start = partitionLeadCommentTokens(it.nativeTokens[:start]) | ||
104 | _, afterNewline := partitionLineEndTokens(it.nativeTokens[end:]) | ||
105 | end += afterNewline | ||
106 | |||
107 | before = it.Slice(0, start) | ||
108 | within = it.Slice(start, end) | ||
109 | after = it.Slice(end, len(it.nativeTokens)) | ||
110 | return | ||
111 | |||
112 | } | ||
113 | |||
114 | // PartitionBlockItem is similar to PartitionIncludeComments but it returns | ||
115 | // the comments as separate token sequences so that they can be captured into | ||
116 | // AST attributes. It makes assumptions that apply only to block items, so | ||
117 | // should not be used for other constructs. | ||
118 | func (it inputTokens) PartitionBlockItem(rng hcl.Range) (before, leadComments, within, lineComments, newline, after inputTokens) { | ||
119 | before, within, after = it.Partition(rng) | ||
120 | before, leadComments = before.PartitionLeadComments() | ||
121 | lineComments, newline, after = after.PartitionLineEndTokens() | ||
122 | return | ||
123 | } | ||
124 | |||
125 | func (it inputTokens) PartitionLeadComments() (before, within inputTokens) { | ||
126 | start := partitionLeadCommentTokens(it.nativeTokens) | ||
127 | before = it.Slice(0, start) | ||
128 | within = it.Slice(start, len(it.nativeTokens)) | ||
129 | return | ||
130 | } | ||
131 | |||
132 | func (it inputTokens) PartitionLineEndTokens() (comments, newline, after inputTokens) { | ||
133 | afterComments, afterNewline := partitionLineEndTokens(it.nativeTokens) | ||
134 | comments = it.Slice(0, afterComments) | ||
135 | newline = it.Slice(afterComments, afterNewline) | ||
136 | after = it.Slice(afterNewline, len(it.nativeTokens)) | ||
137 | return | ||
138 | } | ||
139 | |||
140 | func (it inputTokens) Slice(start, end int) inputTokens { | ||
141 | // When we slice, we create a new slice with no additional capacity because | ||
142 | // we expect that these slices will be mutated in order to insert | ||
143 | // new code into the AST, and we want to ensure that a new underlying | ||
144 | // array gets allocated in that case, rather than writing into some | ||
145 | // following slice and corrupting it. | ||
146 | return inputTokens{ | ||
147 | nativeTokens: it.nativeTokens[start:end:end], | ||
148 | writerTokens: it.writerTokens[start:end:end], | ||
149 | } | ||
150 | } | ||
151 | |||
152 | func (it inputTokens) Len() int { | ||
153 | return len(it.nativeTokens) | ||
154 | } | ||
155 | |||
156 | func (it inputTokens) Tokens() Tokens { | ||
157 | return it.writerTokens | ||
158 | } | ||
159 | |||
160 | func (it inputTokens) Types() []hclsyntax.TokenType { | ||
161 | ret := make([]hclsyntax.TokenType, len(it.nativeTokens)) | ||
162 | for i, tok := range it.nativeTokens { | ||
163 | ret[i] = tok.Type | ||
164 | } | ||
165 | return ret | ||
166 | } | ||
167 | |||
168 | // parseBody locates the given body within the given input tokens and returns | ||
169 | // the resulting *Body object as well as the tokens that appeared before and | ||
170 | // after it. | ||
171 | func parseBody(nativeBody *hclsyntax.Body, from inputTokens) (inputTokens, *node, inputTokens) { | ||
172 | before, within, after := from.PartitionIncludingComments(nativeBody.SrcRange) | ||
173 | |||
174 | // The main AST doesn't retain the original source ordering of the | ||
175 | // body items, so we need to reconstruct that ordering by inspecting | ||
176 | // their source ranges. | ||
177 | nativeItems := make([]hclsyntax.Node, 0, len(nativeBody.Attributes)+len(nativeBody.Blocks)) | ||
178 | for _, nativeAttr := range nativeBody.Attributes { | ||
179 | nativeItems = append(nativeItems, nativeAttr) | ||
180 | } | ||
181 | for _, nativeBlock := range nativeBody.Blocks { | ||
182 | nativeItems = append(nativeItems, nativeBlock) | ||
183 | } | ||
184 | sort.Sort(nativeNodeSorter{nativeItems}) | ||
185 | |||
186 | body := &Body{ | ||
187 | inTree: newInTree(), | ||
188 | items: newNodeSet(), | ||
189 | } | ||
190 | |||
191 | remain := within | ||
192 | for _, nativeItem := range nativeItems { | ||
193 | beforeItem, item, afterItem := parseBodyItem(nativeItem, remain) | ||
194 | |||
195 | if beforeItem.Len() > 0 { | ||
196 | body.AppendUnstructuredTokens(beforeItem.Tokens()) | ||
197 | } | ||
198 | body.appendItemNode(item) | ||
199 | |||
200 | remain = afterItem | ||
201 | } | ||
202 | |||
203 | if remain.Len() > 0 { | ||
204 | body.AppendUnstructuredTokens(remain.Tokens()) | ||
205 | } | ||
206 | |||
207 | return before, newNode(body), after | ||
208 | } | ||
209 | |||
210 | func parseBodyItem(nativeItem hclsyntax.Node, from inputTokens) (inputTokens, *node, inputTokens) { | ||
211 | before, leadComments, within, lineComments, newline, after := from.PartitionBlockItem(nativeItem.Range()) | ||
212 | |||
213 | var item *node | ||
214 | |||
215 | switch tItem := nativeItem.(type) { | ||
216 | case *hclsyntax.Attribute: | ||
217 | item = parseAttribute(tItem, within, leadComments, lineComments, newline) | ||
218 | case *hclsyntax.Block: | ||
219 | item = parseBlock(tItem, within, leadComments, lineComments, newline) | ||
220 | default: | ||
221 | // should never happen if caller is behaving | ||
222 | panic("unsupported native item type") | ||
223 | } | ||
224 | |||
225 | return before, item, after | ||
226 | } | ||
227 | |||
228 | func parseAttribute(nativeAttr *hclsyntax.Attribute, from, leadComments, lineComments, newline inputTokens) *node { | ||
229 | attr := &Attribute{ | ||
230 | inTree: newInTree(), | ||
231 | } | ||
232 | children := attr.inTree.children | ||
233 | |||
234 | { | ||
235 | cn := newNode(newComments(leadComments.Tokens())) | ||
236 | attr.leadComments = cn | ||
237 | children.AppendNode(cn) | ||
238 | } | ||
239 | |||
240 | before, nameTokens, from := from.Partition(nativeAttr.NameRange) | ||
241 | { | ||
242 | children.AppendUnstructuredTokens(before.Tokens()) | ||
243 | if nameTokens.Len() != 1 { | ||
244 | // Should never happen with valid input | ||
245 | panic("attribute name is not exactly one token") | ||
246 | } | ||
247 | token := nameTokens.Tokens()[0] | ||
248 | in := newNode(newIdentifier(token)) | ||
249 | attr.name = in | ||
250 | children.AppendNode(in) | ||
251 | } | ||
252 | |||
253 | before, equalsTokens, from := from.Partition(nativeAttr.EqualsRange) | ||
254 | children.AppendUnstructuredTokens(before.Tokens()) | ||
255 | children.AppendUnstructuredTokens(equalsTokens.Tokens()) | ||
256 | |||
257 | before, exprTokens, from := from.Partition(nativeAttr.Expr.Range()) | ||
258 | { | ||
259 | children.AppendUnstructuredTokens(before.Tokens()) | ||
260 | exprNode := parseExpression(nativeAttr.Expr, exprTokens) | ||
261 | attr.expr = exprNode | ||
262 | children.AppendNode(exprNode) | ||
263 | } | ||
264 | |||
265 | { | ||
266 | cn := newNode(newComments(lineComments.Tokens())) | ||
267 | attr.lineComments = cn | ||
268 | children.AppendNode(cn) | ||
269 | } | ||
270 | |||
271 | children.AppendUnstructuredTokens(newline.Tokens()) | ||
272 | |||
273 | // Collect any stragglers, though there shouldn't be any | ||
274 | children.AppendUnstructuredTokens(from.Tokens()) | ||
275 | |||
276 | return newNode(attr) | ||
277 | } | ||
278 | |||
279 | func parseBlock(nativeBlock *hclsyntax.Block, from, leadComments, lineComments, newline inputTokens) *node { | ||
280 | block := &Block{ | ||
281 | inTree: newInTree(), | ||
282 | labels: newNodeSet(), | ||
283 | } | ||
284 | children := block.inTree.children | ||
285 | |||
286 | { | ||
287 | cn := newNode(newComments(leadComments.Tokens())) | ||
288 | block.leadComments = cn | ||
289 | children.AppendNode(cn) | ||
290 | } | ||
291 | |||
292 | before, typeTokens, from := from.Partition(nativeBlock.TypeRange) | ||
293 | { | ||
294 | children.AppendUnstructuredTokens(before.Tokens()) | ||
295 | if typeTokens.Len() != 1 { | ||
296 | // Should never happen with valid input | ||
297 | panic("block type name is not exactly one token") | ||
298 | } | ||
299 | token := typeTokens.Tokens()[0] | ||
300 | in := newNode(newIdentifier(token)) | ||
301 | block.typeName = in | ||
302 | children.AppendNode(in) | ||
303 | } | ||
304 | |||
305 | for _, rng := range nativeBlock.LabelRanges { | ||
306 | var labelTokens inputTokens | ||
307 | before, labelTokens, from = from.Partition(rng) | ||
308 | children.AppendUnstructuredTokens(before.Tokens()) | ||
309 | tokens := labelTokens.Tokens() | ||
310 | ln := newNode(newQuoted(tokens)) | ||
311 | block.labels.Add(ln) | ||
312 | children.AppendNode(ln) | ||
313 | } | ||
314 | |||
315 | before, oBrace, from := from.Partition(nativeBlock.OpenBraceRange) | ||
316 | children.AppendUnstructuredTokens(before.Tokens()) | ||
317 | children.AppendUnstructuredTokens(oBrace.Tokens()) | ||
318 | |||
319 | // We go a bit out of order here: we go hunting for the closing brace | ||
320 | // so that we have a delimited body, but then we'll deal with the body | ||
321 | // before we actually append the closing brace and any straggling tokens | ||
322 | // that appear after it. | ||
323 | bodyTokens, cBrace, from := from.Partition(nativeBlock.CloseBraceRange) | ||
324 | before, body, after := parseBody(nativeBlock.Body, bodyTokens) | ||
325 | children.AppendUnstructuredTokens(before.Tokens()) | ||
326 | block.body = body | ||
327 | children.AppendNode(body) | ||
328 | children.AppendUnstructuredTokens(after.Tokens()) | ||
329 | |||
330 | children.AppendUnstructuredTokens(cBrace.Tokens()) | ||
331 | |||
332 | // stragglers | ||
333 | children.AppendUnstructuredTokens(from.Tokens()) | ||
334 | if lineComments.Len() > 0 { | ||
335 | // blocks don't actually have line comments, so we'll just treat | ||
336 | // them as extra stragglers | ||
337 | children.AppendUnstructuredTokens(lineComments.Tokens()) | ||
338 | } | ||
339 | children.AppendUnstructuredTokens(newline.Tokens()) | ||
340 | |||
341 | return newNode(block) | ||
342 | } | ||
343 | |||
344 | func parseExpression(nativeExpr hclsyntax.Expression, from inputTokens) *node { | ||
345 | expr := newExpression() | ||
346 | children := expr.inTree.children | ||
347 | |||
348 | nativeVars := nativeExpr.Variables() | ||
349 | |||
350 | for _, nativeTraversal := range nativeVars { | ||
351 | before, traversal, after := parseTraversal(nativeTraversal, from) | ||
352 | children.AppendUnstructuredTokens(before.Tokens()) | ||
353 | children.AppendNode(traversal) | ||
354 | expr.absTraversals.Add(traversal) | ||
355 | from = after | ||
356 | } | ||
357 | // Attach any stragglers that don't belong to a traversal to the expression | ||
358 | // itself. In an expression with no traversals at all, this is just the | ||
359 | // entirety of "from". | ||
360 | children.AppendUnstructuredTokens(from.Tokens()) | ||
361 | |||
362 | return newNode(expr) | ||
363 | } | ||
364 | |||
365 | func parseTraversal(nativeTraversal hcl.Traversal, from inputTokens) (before inputTokens, n *node, after inputTokens) { | ||
366 | traversal := newTraversal() | ||
367 | children := traversal.inTree.children | ||
368 | before, from, after = from.Partition(nativeTraversal.SourceRange()) | ||
369 | |||
370 | stepAfter := from | ||
371 | for _, nativeStep := range nativeTraversal { | ||
372 | before, step, after := parseTraversalStep(nativeStep, stepAfter) | ||
373 | children.AppendUnstructuredTokens(before.Tokens()) | ||
374 | children.AppendNode(step) | ||
375 | traversal.steps.Add(step) | ||
376 | stepAfter = after | ||
377 | } | ||
378 | |||
379 | return before, newNode(traversal), after | ||
380 | } | ||
381 | |||
382 | func parseTraversalStep(nativeStep hcl.Traverser, from inputTokens) (before inputTokens, n *node, after inputTokens) { | ||
383 | var children *nodes | ||
384 | switch tNativeStep := nativeStep.(type) { | ||
385 | |||
386 | case hcl.TraverseRoot, hcl.TraverseAttr: | ||
387 | step := newTraverseName() | ||
388 | children = step.inTree.children | ||
389 | before, from, after = from.Partition(nativeStep.SourceRange()) | ||
390 | inBefore, token, inAfter := from.PartitionTypeSingle(hclsyntax.TokenIdent) | ||
391 | name := newIdentifier(token) | ||
392 | children.AppendUnstructuredTokens(inBefore.Tokens()) | ||
393 | step.name = children.Append(name) | ||
394 | children.AppendUnstructuredTokens(inAfter.Tokens()) | ||
395 | return before, newNode(step), after | ||
396 | |||
397 | case hcl.TraverseIndex: | ||
398 | step := newTraverseIndex() | ||
399 | children = step.inTree.children | ||
400 | before, from, after = from.Partition(nativeStep.SourceRange()) | ||
401 | |||
402 | var inBefore, oBrack, keyTokens, cBrack inputTokens | ||
403 | inBefore, oBrack, from = from.PartitionType(hclsyntax.TokenOBrack) | ||
404 | children.AppendUnstructuredTokens(inBefore.Tokens()) | ||
405 | children.AppendUnstructuredTokens(oBrack.Tokens()) | ||
406 | keyTokens, cBrack, from = from.PartitionType(hclsyntax.TokenCBrack) | ||
407 | |||
408 | keyVal := tNativeStep.Key | ||
409 | switch keyVal.Type() { | ||
410 | case cty.String: | ||
411 | key := newQuoted(keyTokens.Tokens()) | ||
412 | step.key = children.Append(key) | ||
413 | case cty.Number: | ||
414 | valBefore, valToken, valAfter := keyTokens.PartitionTypeSingle(hclsyntax.TokenNumberLit) | ||
415 | children.AppendUnstructuredTokens(valBefore.Tokens()) | ||
416 | key := newNumber(valToken) | ||
417 | step.key = children.Append(key) | ||
418 | children.AppendUnstructuredTokens(valAfter.Tokens()) | ||
419 | } | ||
420 | |||
421 | children.AppendUnstructuredTokens(cBrack.Tokens()) | ||
422 | children.AppendUnstructuredTokens(from.Tokens()) | ||
423 | |||
424 | return before, newNode(step), after | ||
425 | default: | ||
426 | panic(fmt.Sprintf("unsupported traversal step type %T", nativeStep)) | ||
427 | } | ||
428 | |||
429 | } | ||
430 | |||
431 | // writerTokens takes a sequence of tokens as produced by the main hclsyntax | ||
432 | // package and transforms it into an equivalent sequence of tokens using | ||
433 | // this package's own token model. | ||
434 | // | ||
435 | // The resulting list contains the same number of tokens and uses the same | ||
436 | // indices as the input, allowing the two sets of tokens to be correlated | ||
437 | // by index. | ||
438 | func writerTokens(nativeTokens hclsyntax.Tokens) Tokens { | ||
439 | // Ultimately we want a slice of token _pointers_, but since we can | ||
440 | // predict how much memory we're going to devote to tokens we'll allocate | ||
441 | // it all as a single flat buffer and thus give the GC less work to do. | ||
442 | tokBuf := make([]Token, len(nativeTokens)) | ||
443 | var lastByteOffset int | ||
444 | for i, mainToken := range nativeTokens { | ||
445 | // Create a copy of the bytes so that we can mutate without | ||
446 | // corrupting the original token stream. | ||
447 | bytes := make([]byte, len(mainToken.Bytes)) | ||
448 | copy(bytes, mainToken.Bytes) | ||
449 | |||
450 | tokBuf[i] = Token{ | ||
451 | Type: mainToken.Type, | ||
452 | Bytes: bytes, | ||
453 | |||
454 | // We assume here that spaces are always ASCII spaces, since | ||
455 | // that's what the scanner also assumes, and thus the number | ||
456 | // of bytes skipped is also the number of space characters. | ||
457 | SpacesBefore: mainToken.Range.Start.Byte - lastByteOffset, | ||
458 | } | ||
459 | |||
460 | lastByteOffset = mainToken.Range.End.Byte | ||
461 | } | ||
462 | |||
463 | // Now make a slice of pointers into the previous slice. | ||
464 | ret := make(Tokens, len(tokBuf)) | ||
465 | for i := range ret { | ||
466 | ret[i] = &tokBuf[i] | ||
467 | } | ||
468 | |||
469 | return ret | ||
470 | } | ||
471 | |||
472 | // partitionTokens takes a sequence of tokens and a hcl.Range and returns | ||
473 | // two indices within the token sequence that correspond with the range | ||
474 | // boundaries, such that the slice operator could be used to produce | ||
475 | // three token sequences for before, within, and after respectively: | ||
476 | // | ||
477 | // start, end := partitionTokens(toks, rng) | ||
478 | // before := toks[:start] | ||
479 | // within := toks[start:end] | ||
480 | // after := toks[end:] | ||
481 | // | ||
482 | // This works best when the range is aligned with token boundaries (e.g. | ||
483 | // because it was produced in terms of the scanner's result) but if that isn't | ||
484 | // true then it will make a best effort that may produce strange results at | ||
485 | // the boundaries. | ||
486 | // | ||
487 | // Native hclsyntax tokens are used here, because they contain the necessary | ||
488 | // absolute position information. However, since writerTokens produces a | ||
489 | // correlatable sequence of writer tokens, the resulting indices can be | ||
490 | // used also to index into its result, allowing the partitioning of writer | ||
491 | // tokens to be driven by the partitioning of native tokens. | ||
492 | // | ||
493 | // The tokens are assumed to be in source order and non-overlapping, which | ||
494 | // will be true if the token sequence from the scanner is used directly. | ||
495 | func partitionTokens(toks hclsyntax.Tokens, rng hcl.Range) (start, end int) { | ||
496 | // We us a linear search here because we assume tha in most cases our | ||
497 | // target range is close to the beginning of the sequence, and the seqences | ||
498 | // are generally small for most reasonable files anyway. | ||
499 | for i := 0; ; i++ { | ||
500 | if i >= len(toks) { | ||
501 | // No tokens for the given range at all! | ||
502 | return len(toks), len(toks) | ||
503 | } | ||
504 | |||
505 | if toks[i].Range.Start.Byte >= rng.Start.Byte { | ||
506 | start = i | ||
507 | break | ||
508 | } | ||
509 | } | ||
510 | |||
511 | for i := start; ; i++ { | ||
512 | if i >= len(toks) { | ||
513 | // The range "hangs off" the end of the token sequence | ||
514 | return start, len(toks) | ||
515 | } | ||
516 | |||
517 | if toks[i].Range.Start.Byte >= rng.End.Byte { | ||
518 | end = i // end marker is exclusive | ||
519 | break | ||
520 | } | ||
521 | } | ||
522 | |||
523 | return start, end | ||
524 | } | ||
525 | |||
526 | // partitionLeadCommentTokens takes a sequence of tokens that is assumed | ||
527 | // to immediately precede a construct that can have lead comment tokens, | ||
528 | // and returns the index into that sequence where the lead comments begin. | ||
529 | // | ||
530 | // Lead comments are defined as whole lines containing only comment tokens | ||
531 | // with no blank lines between. If no such lines are found, the returned | ||
532 | // index will be len(toks). | ||
533 | func partitionLeadCommentTokens(toks hclsyntax.Tokens) int { | ||
534 | // single-line comments (which is what we're interested in here) | ||
535 | // consume their trailing newline, so we can just walk backwards | ||
536 | // until we stop seeing comment tokens. | ||
537 | for i := len(toks) - 1; i >= 0; i-- { | ||
538 | if toks[i].Type != hclsyntax.TokenComment { | ||
539 | return i + 1 | ||
540 | } | ||
541 | } | ||
542 | return 0 | ||
543 | } | ||
544 | |||
545 | // partitionLineEndTokens takes a sequence of tokens that is assumed | ||
546 | // to immediately follow a construct that can have a line comment, and | ||
547 | // returns first the index where any line comments end and then second | ||
548 | // the index immediately after the trailing newline. | ||
549 | // | ||
550 | // Line comments are defined as comments that appear immediately after | ||
551 | // a construct on the same line where its significant tokens ended. | ||
552 | // | ||
553 | // Since single-line comment tokens (# and //) include the newline that | ||
554 | // terminates them, in the presence of these the two returned indices | ||
555 | // will be the same since the comment itself serves as the line end. | ||
556 | func partitionLineEndTokens(toks hclsyntax.Tokens) (afterComment, afterNewline int) { | ||
557 | for i := 0; i < len(toks); i++ { | ||
558 | tok := toks[i] | ||
559 | if tok.Type != hclsyntax.TokenComment { | ||
560 | switch tok.Type { | ||
561 | case hclsyntax.TokenNewline: | ||
562 | return i, i + 1 | ||
563 | case hclsyntax.TokenEOF: | ||
564 | // Although this is valid, we mustn't include the EOF | ||
565 | // itself as our "newline" or else strange things will | ||
566 | // happen when we try to append new items. | ||
567 | return i, i | ||
568 | default: | ||
569 | // If we have well-formed input here then nothing else should be | ||
570 | // possible. This path should never happen, because we only try | ||
571 | // to extract tokens from the sequence if the parser succeeded, | ||
572 | // and it should catch this problem itself. | ||
573 | panic("malformed line trailers: expected only comments and newlines") | ||
574 | } | ||
575 | } | ||
576 | |||
577 | if len(tok.Bytes) > 0 && tok.Bytes[len(tok.Bytes)-1] == '\n' { | ||
578 | // Newline at the end of a single-line comment serves both as | ||
579 | // the end of comments *and* the end of the line. | ||
580 | return i + 1, i + 1 | ||
581 | } | ||
582 | } | ||
583 | return len(toks), len(toks) | ||
584 | } | ||
585 | |||
586 | // lexConfig uses the hclsyntax scanner to get a token stream and then | ||
587 | // rewrites it into this package's token model. | ||
588 | // | ||
589 | // Any errors produced during scanning are ignored, so the results of this | ||
590 | // function should be used with care. | ||
591 | func lexConfig(src []byte) Tokens { | ||
592 | mainTokens, _ := hclsyntax.LexConfig(src, "", hcl.Pos{Byte: 0, Line: 1, Column: 1}) | ||
593 | return writerTokens(mainTokens) | ||
594 | } | ||
diff --git a/vendor/github.com/hashicorp/hcl2/hclwrite/public.go b/vendor/github.com/hashicorp/hcl2/hclwrite/public.go new file mode 100644 index 0000000..4d5ce2a --- /dev/null +++ b/vendor/github.com/hashicorp/hcl2/hclwrite/public.go | |||
@@ -0,0 +1,44 @@ | |||
1 | package hclwrite | ||
2 | |||
3 | import ( | ||
4 | "bytes" | ||
5 | |||
6 | "github.com/hashicorp/hcl2/hcl" | ||
7 | ) | ||
8 | |||
9 | // NewFile creates a new file object that is empty and ready to have constructs | ||
10 | // added t it. | ||
11 | func NewFile() *File { | ||
12 | body := &Body{ | ||
13 | inTree: newInTree(), | ||
14 | items: newNodeSet(), | ||
15 | } | ||
16 | file := &File{ | ||
17 | inTree: newInTree(), | ||
18 | } | ||
19 | file.body = file.inTree.children.Append(body) | ||
20 | return file | ||
21 | } | ||
22 | |||
23 | // ParseConfig interprets the given source bytes into a *hclwrite.File. The | ||
24 | // resulting AST can be used to perform surgical edits on the source code | ||
25 | // before turning it back into bytes again. | ||
26 | func ParseConfig(src []byte, filename string, start hcl.Pos) (*File, hcl.Diagnostics) { | ||
27 | return parse(src, filename, start) | ||
28 | } | ||
29 | |||
30 | // Format takes source code and performs simple whitespace changes to transform | ||
31 | // it to a canonical layout style. | ||
32 | // | ||
33 | // Format skips constructing an AST and works directly with tokens, so it | ||
34 | // is less expensive than formatting via the AST for situations where no other | ||
35 | // changes will be made. It also ignores syntax errors and can thus be applied | ||
36 | // to partial source code, although the result in that case may not be | ||
37 | // desirable. | ||
38 | func Format(src []byte) []byte { | ||
39 | tokens := lexConfig(src) | ||
40 | format(tokens) | ||
41 | buf := &bytes.Buffer{} | ||
42 | tokens.WriteTo(buf) | ||
43 | return buf.Bytes() | ||
44 | } | ||
diff --git a/vendor/github.com/hashicorp/hcl2/hclwrite/tokens.go b/vendor/github.com/hashicorp/hcl2/hclwrite/tokens.go new file mode 100644 index 0000000..d87f818 --- /dev/null +++ b/vendor/github.com/hashicorp/hcl2/hclwrite/tokens.go | |||
@@ -0,0 +1,122 @@ | |||
1 | package hclwrite | ||
2 | |||
3 | import ( | ||
4 | "bytes" | ||
5 | "io" | ||
6 | |||
7 | "github.com/apparentlymart/go-textseg/textseg" | ||
8 | "github.com/hashicorp/hcl2/hcl" | ||
9 | "github.com/hashicorp/hcl2/hcl/hclsyntax" | ||
10 | ) | ||
11 | |||
12 | // Token is a single sequence of bytes annotated with a type. It is similar | ||
13 | // in purpose to hclsyntax.Token, but discards the source position information | ||
14 | // since that is not useful in code generation. | ||
15 | type Token struct { | ||
16 | Type hclsyntax.TokenType | ||
17 | Bytes []byte | ||
18 | |||
19 | // We record the number of spaces before each token so that we can | ||
20 | // reproduce the exact layout of the original file when we're making | ||
21 | // surgical changes in-place. When _new_ code is created it will always | ||
22 | // be in the canonical style, but we preserve layout of existing code. | ||
23 | SpacesBefore int | ||
24 | } | ||
25 | |||
26 | // asHCLSyntax returns the receiver expressed as an incomplete hclsyntax.Token. | ||
27 | // A complete token is not possible since we don't have source location | ||
28 | // information here, and so this method is unexported so we can be sure it will | ||
29 | // only be used for internal purposes where we know the range isn't important. | ||
30 | // | ||
31 | // This is primarily intended to allow us to re-use certain functionality from | ||
32 | // hclsyntax rather than re-implementing it against our own token type here. | ||
33 | func (t *Token) asHCLSyntax() hclsyntax.Token { | ||
34 | return hclsyntax.Token{ | ||
35 | Type: t.Type, | ||
36 | Bytes: t.Bytes, | ||
37 | Range: hcl.Range{ | ||
38 | Filename: "<invalid>", | ||
39 | }, | ||
40 | } | ||
41 | } | ||
42 | |||
43 | // Tokens is a flat list of tokens. | ||
44 | type Tokens []*Token | ||
45 | |||
46 | func (ts Tokens) Bytes() []byte { | ||
47 | buf := &bytes.Buffer{} | ||
48 | ts.WriteTo(buf) | ||
49 | return buf.Bytes() | ||
50 | } | ||
51 | |||
52 | func (ts Tokens) testValue() string { | ||
53 | return string(ts.Bytes()) | ||
54 | } | ||
55 | |||
56 | // Columns returns the number of columns (grapheme clusters) the token sequence | ||
57 | // occupies. The result is not meaningful if there are newline or single-line | ||
58 | // comment tokens in the sequence. | ||
59 | func (ts Tokens) Columns() int { | ||
60 | ret := 0 | ||
61 | for _, token := range ts { | ||
62 | ret += token.SpacesBefore // spaces are always worth one column each | ||
63 | ct, _ := textseg.TokenCount(token.Bytes, textseg.ScanGraphemeClusters) | ||
64 | ret += ct | ||
65 | } | ||
66 | return ret | ||
67 | } | ||
68 | |||
69 | // WriteTo takes an io.Writer and writes the bytes for each token to it, | ||
70 | // along with the spacing that separates each token. In other words, this | ||
71 | // allows serializing the tokens to a file or other such byte stream. | ||
72 | func (ts Tokens) WriteTo(wr io.Writer) (int64, error) { | ||
73 | // We know we're going to be writing a lot of small chunks of repeated | ||
74 | // space characters, so we'll prepare a buffer of these that we can | ||
75 | // easily pass to wr.Write without any further allocation. | ||
76 | spaces := make([]byte, 40) | ||
77 | for i := range spaces { | ||
78 | spaces[i] = ' ' | ||
79 | } | ||
80 | |||
81 | var n int64 | ||
82 | var err error | ||
83 | for _, token := range ts { | ||
84 | if err != nil { | ||
85 | return n, err | ||
86 | } | ||
87 | |||
88 | for spacesBefore := token.SpacesBefore; spacesBefore > 0; spacesBefore -= len(spaces) { | ||
89 | thisChunk := spacesBefore | ||
90 | if thisChunk > len(spaces) { | ||
91 | thisChunk = len(spaces) | ||
92 | } | ||
93 | var thisN int | ||
94 | thisN, err = wr.Write(spaces[:thisChunk]) | ||
95 | n += int64(thisN) | ||
96 | if err != nil { | ||
97 | return n, err | ||
98 | } | ||
99 | } | ||
100 | |||
101 | var thisN int | ||
102 | thisN, err = wr.Write(token.Bytes) | ||
103 | n += int64(thisN) | ||
104 | } | ||
105 | |||
106 | return n, err | ||
107 | } | ||
108 | |||
109 | func (ts Tokens) walkChildNodes(w internalWalkFunc) { | ||
110 | // Unstructured tokens have no child nodes | ||
111 | } | ||
112 | |||
113 | func (ts Tokens) BuildTokens(to Tokens) Tokens { | ||
114 | return append(to, ts...) | ||
115 | } | ||
116 | |||
117 | func newIdentToken(name string) *Token { | ||
118 | return &Token{ | ||
119 | Type: hclsyntax.TokenIdent, | ||
120 | Bytes: []byte(name), | ||
121 | } | ||
122 | } | ||