r - format_format.go
1 package r
2
3 // File automatically generated with format.sh.
4
5 import "fmt"
6
7 // Format implements the fmt.Formatter interface
8 func (f AdditionExpression) Format(s fmt.State, v rune) {
9 if v == 'v' && s.Flag('#') {
10 type X = AdditionExpression
11 type AdditionExpression X
12
13 fmt.Fprintf(s, "%#v", AdditionExpression(f))
14 } else {
15 format(&f, s, v)
16 }
17 }
18
19 // Format implements the fmt.Formatter interface
20 func (f AndExpression) Format(s fmt.State, v rune) {
21 if v == 'v' && s.Flag('#') {
22 type X = AndExpression
23 type AndExpression X
24
25 fmt.Fprintf(s, "%#v", AndExpression(f))
26 } else {
27 format(&f, s, v)
28 }
29 }
30
31 // Format implements the fmt.Formatter interface
32 func (f Arg) Format(s fmt.State, v rune) {
33 if v == 'v' && s.Flag('#') {
34 type X = Arg
35 type Arg X
36
37 fmt.Fprintf(s, "%#v", Arg(f))
38 } else {
39 format(&f, s, v)
40 }
41 }
42
43 // Format implements the fmt.Formatter interface
44 func (f ArgList) Format(s fmt.State, v rune) {
45 if v == 'v' && s.Flag('#') {
46 type X = ArgList
47 type ArgList X
48
49 fmt.Fprintf(s, "%#v", ArgList(f))
50 } else {
51 format(&f, s, v)
52 }
53 }
54
55 // Format implements the fmt.Formatter interface
56 func (f Argument) Format(s fmt.State, v rune) {
57 if v == 'v' && s.Flag('#') {
58 type X = Argument
59 type Argument X
60
61 fmt.Fprintf(s, "%#v", Argument(f))
62 } else {
63 format(&f, s, v)
64 }
65 }
66
67 // Format implements the fmt.Formatter interface
68 func (f AssignmentExpression) Format(s fmt.State, v rune) {
69 if v == 'v' && s.Flag('#') {
70 type X = AssignmentExpression
71 type AssignmentExpression X
72
73 fmt.Fprintf(s, "%#v", AssignmentExpression(f))
74 } else {
75 format(&f, s, v)
76 }
77 }
78
79 // Format implements the fmt.Formatter interface
80 func (f Call) Format(s fmt.State, v rune) {
81 if v == 'v' && s.Flag('#') {
82 type X = Call
83 type Call X
84
85 fmt.Fprintf(s, "%#v", Call(f))
86 } else {
87 format(&f, s, v)
88 }
89 }
90
91 // Format implements the fmt.Formatter interface
92 func (f CompoundExpression) Format(s fmt.State, v rune) {
93 if v == 'v' && s.Flag('#') {
94 type X = CompoundExpression
95 type CompoundExpression X
96
97 fmt.Fprintf(s, "%#v", CompoundExpression(f))
98 } else {
99 format(&f, s, v)
100 }
101 }
102
103 // Format implements the fmt.Formatter interface
104 func (f ExponentiationExpression) Format(s fmt.State, v rune) {
105 if v == 'v' && s.Flag('#') {
106 type X = ExponentiationExpression
107 type ExponentiationExpression X
108
109 fmt.Fprintf(s, "%#v", ExponentiationExpression(f))
110 } else {
111 format(&f, s, v)
112 }
113 }
114
115 // Format implements the fmt.Formatter interface
116 func (f Expression) Format(s fmt.State, v rune) {
117 if v == 'v' && s.Flag('#') {
118 type X = Expression
119 type Expression X
120
121 fmt.Fprintf(s, "%#v", Expression(f))
122 } else {
123 format(&f, s, v)
124 }
125 }
126
127 // Format implements the fmt.Formatter interface
128 func (f File) Format(s fmt.State, v rune) {
129 if v == 'v' && s.Flag('#') {
130 type X = File
131 type File X
132
133 fmt.Fprintf(s, "%#v", File(f))
134 } else {
135 format(&f, s, v)
136 }
137 }
138
139 // Format implements the fmt.Formatter interface
140 func (f FlowControl) Format(s fmt.State, v rune) {
141 if v == 'v' && s.Flag('#') {
142 type X = FlowControl
143 type FlowControl X
144
145 fmt.Fprintf(s, "%#v", FlowControl(f))
146 } else {
147 format(&f, s, v)
148 }
149 }
150
151 // Format implements the fmt.Formatter interface
152 func (f ForControl) Format(s fmt.State, v rune) {
153 if v == 'v' && s.Flag('#') {
154 type X = ForControl
155 type ForControl X
156
157 fmt.Fprintf(s, "%#v", ForControl(f))
158 } else {
159 format(&f, s, v)
160 }
161 }
162
163 // Format implements the fmt.Formatter interface
164 func (f FormulaeExpression) Format(s fmt.State, v rune) {
165 if v == 'v' && s.Flag('#') {
166 type X = FormulaeExpression
167 type FormulaeExpression X
168
169 fmt.Fprintf(s, "%#v", FormulaeExpression(f))
170 } else {
171 format(&f, s, v)
172 }
173 }
174
175 // Format implements the fmt.Formatter interface
176 func (f FunctionDefinition) Format(s fmt.State, v rune) {
177 if v == 'v' && s.Flag('#') {
178 type X = FunctionDefinition
179 type FunctionDefinition X
180
181 fmt.Fprintf(s, "%#v", FunctionDefinition(f))
182 } else {
183 format(&f, s, v)
184 }
185 }
186
187 // Format implements the fmt.Formatter interface
188 func (f IfControl) Format(s fmt.State, v rune) {
189 if v == 'v' && s.Flag('#') {
190 type X = IfControl
191 type IfControl X
192
193 fmt.Fprintf(s, "%#v", IfControl(f))
194 } else {
195 format(&f, s, v)
196 }
197 }
198
199 // Format implements the fmt.Formatter interface
200 func (f Index) Format(s fmt.State, v rune) {
201 if v == 'v' && s.Flag('#') {
202 type X = Index
203 type Index X
204
205 fmt.Fprintf(s, "%#v", Index(f))
206 } else {
207 format(&f, s, v)
208 }
209 }
210
211 // Format implements the fmt.Formatter interface
212 func (f IndexExpression) Format(s fmt.State, v rune) {
213 if v == 'v' && s.Flag('#') {
214 type X = IndexExpression
215 type IndexExpression X
216
217 fmt.Fprintf(s, "%#v", IndexExpression(f))
218 } else {
219 format(&f, s, v)
220 }
221 }
222
223 // Format implements the fmt.Formatter interface
224 func (f IndexOrCallExpression) Format(s fmt.State, v rune) {
225 if v == 'v' && s.Flag('#') {
226 type X = IndexOrCallExpression
227 type IndexOrCallExpression X
228
229 fmt.Fprintf(s, "%#v", IndexOrCallExpression(f))
230 } else {
231 format(&f, s, v)
232 }
233 }
234
235 // Format implements the fmt.Formatter interface
236 func (f MultiplicationExpression) Format(s fmt.State, v rune) {
237 if v == 'v' && s.Flag('#') {
238 type X = MultiplicationExpression
239 type MultiplicationExpression X
240
241 fmt.Fprintf(s, "%#v", MultiplicationExpression(f))
242 } else {
243 format(&f, s, v)
244 }
245 }
246
247 // Format implements the fmt.Formatter interface
248 func (f NotExpression) Format(s fmt.State, v rune) {
249 if v == 'v' && s.Flag('#') {
250 type X = NotExpression
251 type NotExpression X
252
253 fmt.Fprintf(s, "%#v", NotExpression(f))
254 } else {
255 format(&f, s, v)
256 }
257 }
258
259 // Format implements the fmt.Formatter interface
260 func (f OrExpression) Format(s fmt.State, v rune) {
261 if v == 'v' && s.Flag('#') {
262 type X = OrExpression
263 type OrExpression X
264
265 fmt.Fprintf(s, "%#v", OrExpression(f))
266 } else {
267 format(&f, s, v)
268 }
269 }
270
271 // Format implements the fmt.Formatter interface
272 func (f ParenthesizedExpression) Format(s fmt.State, v rune) {
273 if v == 'v' && s.Flag('#') {
274 type X = ParenthesizedExpression
275 type ParenthesizedExpression X
276
277 fmt.Fprintf(s, "%#v", ParenthesizedExpression(f))
278 } else {
279 format(&f, s, v)
280 }
281 }
282
283 // Format implements the fmt.Formatter interface
284 func (f PipeOrSpecialExpression) Format(s fmt.State, v rune) {
285 if v == 'v' && s.Flag('#') {
286 type X = PipeOrSpecialExpression
287 type PipeOrSpecialExpression X
288
289 fmt.Fprintf(s, "%#v", PipeOrSpecialExpression(f))
290 } else {
291 format(&f, s, v)
292 }
293 }
294
295 // Format implements the fmt.Formatter interface
296 func (f QueryExpression) Format(s fmt.State, v rune) {
297 if v == 'v' && s.Flag('#') {
298 type X = QueryExpression
299 type QueryExpression X
300
301 fmt.Fprintf(s, "%#v", QueryExpression(f))
302 } else {
303 format(&f, s, v)
304 }
305 }
306
307 // Format implements the fmt.Formatter interface
308 func (f RelationalExpression) Format(s fmt.State, v rune) {
309 if v == 'v' && s.Flag('#') {
310 type X = RelationalExpression
311 type RelationalExpression X
312
313 fmt.Fprintf(s, "%#v", RelationalExpression(f))
314 } else {
315 format(&f, s, v)
316 }
317 }
318
319 // Format implements the fmt.Formatter interface
320 func (f RepeatControl) Format(s fmt.State, v rune) {
321 if v == 'v' && s.Flag('#') {
322 type X = RepeatControl
323 type RepeatControl X
324
325 fmt.Fprintf(s, "%#v", RepeatControl(f))
326 } else {
327 format(&f, s, v)
328 }
329 }
330
331 // Format implements the fmt.Formatter interface
332 func (f ScopeExpression) Format(s fmt.State, v rune) {
333 if v == 'v' && s.Flag('#') {
334 type X = ScopeExpression
335 type ScopeExpression X
336
337 fmt.Fprintf(s, "%#v", ScopeExpression(f))
338 } else {
339 format(&f, s, v)
340 }
341 }
342
343 // Format implements the fmt.Formatter interface
344 func (f SequenceExpression) Format(s fmt.State, v rune) {
345 if v == 'v' && s.Flag('#') {
346 type X = SequenceExpression
347 type SequenceExpression X
348
349 fmt.Fprintf(s, "%#v", SequenceExpression(f))
350 } else {
351 format(&f, s, v)
352 }
353 }
354
355 // Format implements the fmt.Formatter interface
356 func (f SimpleExpression) Format(s fmt.State, v rune) {
357 if v == 'v' && s.Flag('#') {
358 type X = SimpleExpression
359 type SimpleExpression X
360
361 fmt.Fprintf(s, "%#v", SimpleExpression(f))
362 } else {
363 format(&f, s, v)
364 }
365 }
366
367 // Format implements the fmt.Formatter interface
368 func (f SubsetExpression) Format(s fmt.State, v rune) {
369 if v == 'v' && s.Flag('#') {
370 type X = SubsetExpression
371 type SubsetExpression X
372
373 fmt.Fprintf(s, "%#v", SubsetExpression(f))
374 } else {
375 format(&f, s, v)
376 }
377 }
378
379 // Format implements the fmt.Formatter interface
380 func (f UnaryExpression) Format(s fmt.State, v rune) {
381 if v == 'v' && s.Flag('#') {
382 type X = UnaryExpression
383 type UnaryExpression X
384
385 fmt.Fprintf(s, "%#v", UnaryExpression(f))
386 } else {
387 format(&f, s, v)
388 }
389 }
390
391 // Format implements the fmt.Formatter interface
392 func (f WhileControl) Format(s fmt.State, v rune) {
393 if v == 'v' && s.Flag('#') {
394 type X = WhileControl
395 type WhileControl X
396
397 fmt.Fprintf(s, "%#v", WhileControl(f))
398 } else {
399 format(&f, s, v)
400 }
401 }
402