ptx_parser/unparser/instruction/
tex.rs

1//! Original PTX specification:
2//!
3//! tex.geom.v4.dtype.ctype  d{|p}, [a, c] {, e} {, f};
4//! tex.geom.v4.dtype.ctype  d{|p}, [a, b, c] {, e} {, f};  // explicit sampler
5//! tex.geom.v2.f16x2.ctype  d{|p}, [a, c] {, e} {, f};
6//! tex.geom.v2.f16x2.ctype  d{|p}, [a, b, c] {, e} {, f};  // explicit sampler
7//! // mipmaps
8//! tex.base.geom.v4.dtype.ctype   d{|p}, [a, {b,} c] {, e} {, f};
9//! tex.level.geom.v4.dtype.ctype  d{|p}, [a, {b,} c], lod {, e} {, f};
10//! tex.grad.geom.v4.dtype.ctype   d{|p}, [a, {b,} c], dPdx, dPdy {, e} {, f};
11//! tex.base.geom.v2.f16x2.ctype   d{|p}, [a, {b,} c] {, e} {, f};
12//! tex.level.geom.v2.f16x2.ctype  d{|p}, [a, {b,} c], lod {, e} {, f};
13//! tex.grad.geom.v2.f16x2.ctype   d{|p}, [a, {b,} c], dPdx, dPdy {, e} {, f};
14//! .geom  = { .1d, .2d, .3d, .a1d, .a2d, .cube, .acube, .2dms, .a2dms };
15//! .dtype = { .u32, .s32, .f16,  .f32 };
16//! .ctype = {       .s32, .f32 };          // .cube, .acube require .f32
17//! // .2dms, .a2dms require .s32
18
19#![allow(unused)]
20
21use crate::lexer::PtxToken;
22use crate::unparser::{PtxUnparser, common::*};
23
24pub mod section_0 {
25    use super::*;
26    use crate::r#type::instruction::tex::section_0::*;
27
28    impl PtxUnparser for TexGeomV4DtypeCtype {
29        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
30            self.unparse_tokens_mode(tokens, false);
31        }
32        fn unparse_tokens_mode(&self, tokens: &mut ::std::vec::Vec<PtxToken>, spaced: bool) {
33            push_opcode(tokens, "tex");
34            match &self.geom {
35                Geom::Acube => {
36                    push_directive(tokens, "acube");
37                }
38                Geom::A2dms => {
39                    push_directive(tokens, "a2dms");
40                }
41                Geom::Cube => {
42                    push_directive(tokens, "cube");
43                }
44                Geom::_2dms => {
45                    push_directive(tokens, "2dms");
46                }
47                Geom::A1d => {
48                    push_directive(tokens, "a1d");
49                }
50                Geom::A2d => {
51                    push_directive(tokens, "a2d");
52                }
53                Geom::_1d => {
54                    push_directive(tokens, "1d");
55                }
56                Geom::_2d => {
57                    push_directive(tokens, "2d");
58                }
59                Geom::_3d => {
60                    push_directive(tokens, "3d");
61                }
62            }
63            push_directive(tokens, "v4");
64            match &self.dtype {
65                Dtype::U32 => {
66                    push_directive(tokens, "u32");
67                }
68                Dtype::S32 => {
69                    push_directive(tokens, "s32");
70                }
71                Dtype::F16 => {
72                    push_directive(tokens, "f16");
73                }
74                Dtype::F32 => {
75                    push_directive(tokens, "f32");
76                }
77            }
78            match &self.ctype {
79                Ctype::S32 => {
80                    push_directive(tokens, "s32");
81                }
82                Ctype::F32 => {
83                    push_directive(tokens, "f32");
84                }
85            }
86            if spaced {
87                tokens.push(PtxToken::Space);
88            }
89            self.d.unparse_tokens_mode(tokens, spaced);
90            if let Some(p_0) = self.p.as_ref() {
91                tokens.push(PtxToken::Pipe);
92                p_0.unparse_tokens_mode(tokens, spaced);
93            }
94            tokens.push(PtxToken::Comma);
95            if spaced {
96                tokens.push(PtxToken::Space);
97            }
98            self.a.unparse_tokens_mode(tokens, spaced);
99            if self.e.is_some() {
100                tokens.push(PtxToken::Comma);
101            }
102            if let Some(opt_1) = self.e.as_ref() {
103                if spaced {
104                    tokens.push(PtxToken::Space);
105                }
106                opt_1.unparse_tokens_mode(tokens, spaced);
107            }
108            if self.f.is_some() {
109                tokens.push(PtxToken::Comma);
110            }
111            if let Some(opt_2) = self.f.as_ref() {
112                if spaced {
113                    tokens.push(PtxToken::Space);
114                }
115                opt_2.unparse_tokens_mode(tokens, spaced);
116            }
117            tokens.push(PtxToken::Semicolon);
118            if spaced {
119                tokens.push(PtxToken::Newline);
120            }
121        }
122    }
123
124    impl PtxUnparser for TexGeomV4DtypeCtype1 {
125        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
126            self.unparse_tokens_mode(tokens, false);
127        }
128        fn unparse_tokens_mode(&self, tokens: &mut ::std::vec::Vec<PtxToken>, spaced: bool) {
129            push_opcode(tokens, "tex");
130            match &self.geom {
131                Geom::Acube => {
132                    push_directive(tokens, "acube");
133                }
134                Geom::A2dms => {
135                    push_directive(tokens, "a2dms");
136                }
137                Geom::Cube => {
138                    push_directive(tokens, "cube");
139                }
140                Geom::_2dms => {
141                    push_directive(tokens, "2dms");
142                }
143                Geom::A1d => {
144                    push_directive(tokens, "a1d");
145                }
146                Geom::A2d => {
147                    push_directive(tokens, "a2d");
148                }
149                Geom::_1d => {
150                    push_directive(tokens, "1d");
151                }
152                Geom::_2d => {
153                    push_directive(tokens, "2d");
154                }
155                Geom::_3d => {
156                    push_directive(tokens, "3d");
157                }
158            }
159            push_directive(tokens, "v4");
160            match &self.dtype {
161                Dtype::U32 => {
162                    push_directive(tokens, "u32");
163                }
164                Dtype::S32 => {
165                    push_directive(tokens, "s32");
166                }
167                Dtype::F16 => {
168                    push_directive(tokens, "f16");
169                }
170                Dtype::F32 => {
171                    push_directive(tokens, "f32");
172                }
173            }
174            match &self.ctype {
175                Ctype::S32 => {
176                    push_directive(tokens, "s32");
177                }
178                Ctype::F32 => {
179                    push_directive(tokens, "f32");
180                }
181            }
182            if spaced {
183                tokens.push(PtxToken::Space);
184            }
185            self.d.unparse_tokens_mode(tokens, spaced);
186            if let Some(p_3) = self.p.as_ref() {
187                tokens.push(PtxToken::Pipe);
188                p_3.unparse_tokens_mode(tokens, spaced);
189            }
190            tokens.push(PtxToken::Comma);
191            if spaced {
192                tokens.push(PtxToken::Space);
193            }
194            self.a.unparse_tokens_mode(tokens, spaced);
195            if self.e.is_some() {
196                tokens.push(PtxToken::Comma);
197            }
198            if let Some(opt_4) = self.e.as_ref() {
199                if spaced {
200                    tokens.push(PtxToken::Space);
201                }
202                opt_4.unparse_tokens_mode(tokens, spaced);
203            }
204            if self.f.is_some() {
205                tokens.push(PtxToken::Comma);
206            }
207            if let Some(opt_5) = self.f.as_ref() {
208                if spaced {
209                    tokens.push(PtxToken::Space);
210                }
211                opt_5.unparse_tokens_mode(tokens, spaced);
212            }
213            tokens.push(PtxToken::Semicolon);
214            if spaced {
215                tokens.push(PtxToken::Newline);
216            }
217        }
218    }
219
220    impl PtxUnparser for TexGeomV2F16x2Ctype {
221        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
222            self.unparse_tokens_mode(tokens, false);
223        }
224        fn unparse_tokens_mode(&self, tokens: &mut ::std::vec::Vec<PtxToken>, spaced: bool) {
225            push_opcode(tokens, "tex");
226            match &self.geom {
227                Geom::Acube => {
228                    push_directive(tokens, "acube");
229                }
230                Geom::A2dms => {
231                    push_directive(tokens, "a2dms");
232                }
233                Geom::Cube => {
234                    push_directive(tokens, "cube");
235                }
236                Geom::_2dms => {
237                    push_directive(tokens, "2dms");
238                }
239                Geom::A1d => {
240                    push_directive(tokens, "a1d");
241                }
242                Geom::A2d => {
243                    push_directive(tokens, "a2d");
244                }
245                Geom::_1d => {
246                    push_directive(tokens, "1d");
247                }
248                Geom::_2d => {
249                    push_directive(tokens, "2d");
250                }
251                Geom::_3d => {
252                    push_directive(tokens, "3d");
253                }
254            }
255            push_directive(tokens, "v2");
256            push_directive(tokens, "f16x2");
257            match &self.ctype {
258                Ctype::S32 => {
259                    push_directive(tokens, "s32");
260                }
261                Ctype::F32 => {
262                    push_directive(tokens, "f32");
263                }
264            }
265            if spaced {
266                tokens.push(PtxToken::Space);
267            }
268            self.d.unparse_tokens_mode(tokens, spaced);
269            if let Some(p_6) = self.p.as_ref() {
270                tokens.push(PtxToken::Pipe);
271                p_6.unparse_tokens_mode(tokens, spaced);
272            }
273            tokens.push(PtxToken::Comma);
274            if spaced {
275                tokens.push(PtxToken::Space);
276            }
277            self.a.unparse_tokens_mode(tokens, spaced);
278            if self.e.is_some() {
279                tokens.push(PtxToken::Comma);
280            }
281            if let Some(opt_7) = self.e.as_ref() {
282                if spaced {
283                    tokens.push(PtxToken::Space);
284                }
285                opt_7.unparse_tokens_mode(tokens, spaced);
286            }
287            if self.f.is_some() {
288                tokens.push(PtxToken::Comma);
289            }
290            if let Some(opt_8) = self.f.as_ref() {
291                if spaced {
292                    tokens.push(PtxToken::Space);
293                }
294                opt_8.unparse_tokens_mode(tokens, spaced);
295            }
296            tokens.push(PtxToken::Semicolon);
297            if spaced {
298                tokens.push(PtxToken::Newline);
299            }
300        }
301    }
302
303    impl PtxUnparser for TexGeomV2F16x2Ctype1 {
304        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
305            self.unparse_tokens_mode(tokens, false);
306        }
307        fn unparse_tokens_mode(&self, tokens: &mut ::std::vec::Vec<PtxToken>, spaced: bool) {
308            push_opcode(tokens, "tex");
309            match &self.geom {
310                Geom::Acube => {
311                    push_directive(tokens, "acube");
312                }
313                Geom::A2dms => {
314                    push_directive(tokens, "a2dms");
315                }
316                Geom::Cube => {
317                    push_directive(tokens, "cube");
318                }
319                Geom::_2dms => {
320                    push_directive(tokens, "2dms");
321                }
322                Geom::A1d => {
323                    push_directive(tokens, "a1d");
324                }
325                Geom::A2d => {
326                    push_directive(tokens, "a2d");
327                }
328                Geom::_1d => {
329                    push_directive(tokens, "1d");
330                }
331                Geom::_2d => {
332                    push_directive(tokens, "2d");
333                }
334                Geom::_3d => {
335                    push_directive(tokens, "3d");
336                }
337            }
338            push_directive(tokens, "v2");
339            push_directive(tokens, "f16x2");
340            match &self.ctype {
341                Ctype::S32 => {
342                    push_directive(tokens, "s32");
343                }
344                Ctype::F32 => {
345                    push_directive(tokens, "f32");
346                }
347            }
348            if spaced {
349                tokens.push(PtxToken::Space);
350            }
351            self.d.unparse_tokens_mode(tokens, spaced);
352            if let Some(p_9) = self.p.as_ref() {
353                tokens.push(PtxToken::Pipe);
354                p_9.unparse_tokens_mode(tokens, spaced);
355            }
356            tokens.push(PtxToken::Comma);
357            if spaced {
358                tokens.push(PtxToken::Space);
359            }
360            self.a.unparse_tokens_mode(tokens, spaced);
361            if self.e.is_some() {
362                tokens.push(PtxToken::Comma);
363            }
364            if let Some(opt_10) = self.e.as_ref() {
365                if spaced {
366                    tokens.push(PtxToken::Space);
367                }
368                opt_10.unparse_tokens_mode(tokens, spaced);
369            }
370            if self.f.is_some() {
371                tokens.push(PtxToken::Comma);
372            }
373            if let Some(opt_11) = self.f.as_ref() {
374                if spaced {
375                    tokens.push(PtxToken::Space);
376                }
377                opt_11.unparse_tokens_mode(tokens, spaced);
378            }
379            tokens.push(PtxToken::Semicolon);
380            if spaced {
381                tokens.push(PtxToken::Newline);
382            }
383        }
384    }
385
386    impl PtxUnparser for TexBaseGeomV4DtypeCtype {
387        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
388            self.unparse_tokens_mode(tokens, false);
389        }
390        fn unparse_tokens_mode(&self, tokens: &mut ::std::vec::Vec<PtxToken>, spaced: bool) {
391            push_opcode(tokens, "tex");
392            push_directive(tokens, "base");
393            match &self.geom {
394                Geom::Acube => {
395                    push_directive(tokens, "acube");
396                }
397                Geom::A2dms => {
398                    push_directive(tokens, "a2dms");
399                }
400                Geom::Cube => {
401                    push_directive(tokens, "cube");
402                }
403                Geom::_2dms => {
404                    push_directive(tokens, "2dms");
405                }
406                Geom::A1d => {
407                    push_directive(tokens, "a1d");
408                }
409                Geom::A2d => {
410                    push_directive(tokens, "a2d");
411                }
412                Geom::_1d => {
413                    push_directive(tokens, "1d");
414                }
415                Geom::_2d => {
416                    push_directive(tokens, "2d");
417                }
418                Geom::_3d => {
419                    push_directive(tokens, "3d");
420                }
421            }
422            push_directive(tokens, "v4");
423            match &self.dtype {
424                Dtype::U32 => {
425                    push_directive(tokens, "u32");
426                }
427                Dtype::S32 => {
428                    push_directive(tokens, "s32");
429                }
430                Dtype::F16 => {
431                    push_directive(tokens, "f16");
432                }
433                Dtype::F32 => {
434                    push_directive(tokens, "f32");
435                }
436            }
437            match &self.ctype {
438                Ctype::S32 => {
439                    push_directive(tokens, "s32");
440                }
441                Ctype::F32 => {
442                    push_directive(tokens, "f32");
443                }
444            }
445            if spaced {
446                tokens.push(PtxToken::Space);
447            }
448            self.d.unparse_tokens_mode(tokens, spaced);
449            if let Some(p_12) = self.p.as_ref() {
450                tokens.push(PtxToken::Pipe);
451                p_12.unparse_tokens_mode(tokens, spaced);
452            }
453            tokens.push(PtxToken::Comma);
454            if spaced {
455                tokens.push(PtxToken::Space);
456            }
457            self.a.unparse_tokens_mode(tokens, spaced);
458            if self.e.is_some() {
459                tokens.push(PtxToken::Comma);
460            }
461            if let Some(opt_13) = self.e.as_ref() {
462                if spaced {
463                    tokens.push(PtxToken::Space);
464                }
465                opt_13.unparse_tokens_mode(tokens, spaced);
466            }
467            if self.f.is_some() {
468                tokens.push(PtxToken::Comma);
469            }
470            if let Some(opt_14) = self.f.as_ref() {
471                if spaced {
472                    tokens.push(PtxToken::Space);
473                }
474                opt_14.unparse_tokens_mode(tokens, spaced);
475            }
476            tokens.push(PtxToken::Semicolon);
477            if spaced {
478                tokens.push(PtxToken::Newline);
479            }
480        }
481    }
482
483    impl PtxUnparser for TexLevelGeomV4DtypeCtype {
484        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
485            self.unparse_tokens_mode(tokens, false);
486        }
487        fn unparse_tokens_mode(&self, tokens: &mut ::std::vec::Vec<PtxToken>, spaced: bool) {
488            push_opcode(tokens, "tex");
489            push_directive(tokens, "level");
490            match &self.geom {
491                Geom::Acube => {
492                    push_directive(tokens, "acube");
493                }
494                Geom::A2dms => {
495                    push_directive(tokens, "a2dms");
496                }
497                Geom::Cube => {
498                    push_directive(tokens, "cube");
499                }
500                Geom::_2dms => {
501                    push_directive(tokens, "2dms");
502                }
503                Geom::A1d => {
504                    push_directive(tokens, "a1d");
505                }
506                Geom::A2d => {
507                    push_directive(tokens, "a2d");
508                }
509                Geom::_1d => {
510                    push_directive(tokens, "1d");
511                }
512                Geom::_2d => {
513                    push_directive(tokens, "2d");
514                }
515                Geom::_3d => {
516                    push_directive(tokens, "3d");
517                }
518            }
519            push_directive(tokens, "v4");
520            match &self.dtype {
521                Dtype::U32 => {
522                    push_directive(tokens, "u32");
523                }
524                Dtype::S32 => {
525                    push_directive(tokens, "s32");
526                }
527                Dtype::F16 => {
528                    push_directive(tokens, "f16");
529                }
530                Dtype::F32 => {
531                    push_directive(tokens, "f32");
532                }
533            }
534            match &self.ctype {
535                Ctype::S32 => {
536                    push_directive(tokens, "s32");
537                }
538                Ctype::F32 => {
539                    push_directive(tokens, "f32");
540                }
541            }
542            if spaced {
543                tokens.push(PtxToken::Space);
544            }
545            self.d.unparse_tokens_mode(tokens, spaced);
546            if let Some(p_15) = self.p.as_ref() {
547                tokens.push(PtxToken::Pipe);
548                p_15.unparse_tokens_mode(tokens, spaced);
549            }
550            tokens.push(PtxToken::Comma);
551            if spaced {
552                tokens.push(PtxToken::Space);
553            }
554            self.a.unparse_tokens_mode(tokens, spaced);
555            tokens.push(PtxToken::Comma);
556            if spaced {
557                tokens.push(PtxToken::Space);
558            }
559            self.lod.unparse_tokens_mode(tokens, spaced);
560            if self.e.is_some() {
561                tokens.push(PtxToken::Comma);
562            }
563            if let Some(opt_16) = self.e.as_ref() {
564                if spaced {
565                    tokens.push(PtxToken::Space);
566                }
567                opt_16.unparse_tokens_mode(tokens, spaced);
568            }
569            if self.f.is_some() {
570                tokens.push(PtxToken::Comma);
571            }
572            if let Some(opt_17) = self.f.as_ref() {
573                if spaced {
574                    tokens.push(PtxToken::Space);
575                }
576                opt_17.unparse_tokens_mode(tokens, spaced);
577            }
578            tokens.push(PtxToken::Semicolon);
579            if spaced {
580                tokens.push(PtxToken::Newline);
581            }
582        }
583    }
584
585    impl PtxUnparser for TexGradGeomV4DtypeCtype {
586        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
587            self.unparse_tokens_mode(tokens, false);
588        }
589        fn unparse_tokens_mode(&self, tokens: &mut ::std::vec::Vec<PtxToken>, spaced: bool) {
590            push_opcode(tokens, "tex");
591            push_directive(tokens, "grad");
592            match &self.geom {
593                Geom::Acube => {
594                    push_directive(tokens, "acube");
595                }
596                Geom::A2dms => {
597                    push_directive(tokens, "a2dms");
598                }
599                Geom::Cube => {
600                    push_directive(tokens, "cube");
601                }
602                Geom::_2dms => {
603                    push_directive(tokens, "2dms");
604                }
605                Geom::A1d => {
606                    push_directive(tokens, "a1d");
607                }
608                Geom::A2d => {
609                    push_directive(tokens, "a2d");
610                }
611                Geom::_1d => {
612                    push_directive(tokens, "1d");
613                }
614                Geom::_2d => {
615                    push_directive(tokens, "2d");
616                }
617                Geom::_3d => {
618                    push_directive(tokens, "3d");
619                }
620            }
621            push_directive(tokens, "v4");
622            match &self.dtype {
623                Dtype::U32 => {
624                    push_directive(tokens, "u32");
625                }
626                Dtype::S32 => {
627                    push_directive(tokens, "s32");
628                }
629                Dtype::F16 => {
630                    push_directive(tokens, "f16");
631                }
632                Dtype::F32 => {
633                    push_directive(tokens, "f32");
634                }
635            }
636            match &self.ctype {
637                Ctype::S32 => {
638                    push_directive(tokens, "s32");
639                }
640                Ctype::F32 => {
641                    push_directive(tokens, "f32");
642                }
643            }
644            if spaced {
645                tokens.push(PtxToken::Space);
646            }
647            self.d.unparse_tokens_mode(tokens, spaced);
648            if let Some(p_18) = self.p.as_ref() {
649                tokens.push(PtxToken::Pipe);
650                p_18.unparse_tokens_mode(tokens, spaced);
651            }
652            tokens.push(PtxToken::Comma);
653            if spaced {
654                tokens.push(PtxToken::Space);
655            }
656            self.a.unparse_tokens_mode(tokens, spaced);
657            tokens.push(PtxToken::Comma);
658            if spaced {
659                tokens.push(PtxToken::Space);
660            }
661            self.dpdx.unparse_tokens_mode(tokens, spaced);
662            tokens.push(PtxToken::Comma);
663            if spaced {
664                tokens.push(PtxToken::Space);
665            }
666            self.dpdy.unparse_tokens_mode(tokens, spaced);
667            if self.e.is_some() {
668                tokens.push(PtxToken::Comma);
669            }
670            if let Some(opt_19) = self.e.as_ref() {
671                if spaced {
672                    tokens.push(PtxToken::Space);
673                }
674                opt_19.unparse_tokens_mode(tokens, spaced);
675            }
676            if self.f.is_some() {
677                tokens.push(PtxToken::Comma);
678            }
679            if let Some(opt_20) = self.f.as_ref() {
680                if spaced {
681                    tokens.push(PtxToken::Space);
682                }
683                opt_20.unparse_tokens_mode(tokens, spaced);
684            }
685            tokens.push(PtxToken::Semicolon);
686            if spaced {
687                tokens.push(PtxToken::Newline);
688            }
689        }
690    }
691
692    impl PtxUnparser for TexBaseGeomV2F16x2Ctype {
693        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
694            self.unparse_tokens_mode(tokens, false);
695        }
696        fn unparse_tokens_mode(&self, tokens: &mut ::std::vec::Vec<PtxToken>, spaced: bool) {
697            push_opcode(tokens, "tex");
698            push_directive(tokens, "base");
699            match &self.geom {
700                Geom::Acube => {
701                    push_directive(tokens, "acube");
702                }
703                Geom::A2dms => {
704                    push_directive(tokens, "a2dms");
705                }
706                Geom::Cube => {
707                    push_directive(tokens, "cube");
708                }
709                Geom::_2dms => {
710                    push_directive(tokens, "2dms");
711                }
712                Geom::A1d => {
713                    push_directive(tokens, "a1d");
714                }
715                Geom::A2d => {
716                    push_directive(tokens, "a2d");
717                }
718                Geom::_1d => {
719                    push_directive(tokens, "1d");
720                }
721                Geom::_2d => {
722                    push_directive(tokens, "2d");
723                }
724                Geom::_3d => {
725                    push_directive(tokens, "3d");
726                }
727            }
728            push_directive(tokens, "v2");
729            push_directive(tokens, "f16x2");
730            match &self.ctype {
731                Ctype::S32 => {
732                    push_directive(tokens, "s32");
733                }
734                Ctype::F32 => {
735                    push_directive(tokens, "f32");
736                }
737            }
738            if spaced {
739                tokens.push(PtxToken::Space);
740            }
741            self.d.unparse_tokens_mode(tokens, spaced);
742            if let Some(p_21) = self.p.as_ref() {
743                tokens.push(PtxToken::Pipe);
744                p_21.unparse_tokens_mode(tokens, spaced);
745            }
746            tokens.push(PtxToken::Comma);
747            if spaced {
748                tokens.push(PtxToken::Space);
749            }
750            self.a.unparse_tokens_mode(tokens, spaced);
751            if self.e.is_some() {
752                tokens.push(PtxToken::Comma);
753            }
754            if let Some(opt_22) = self.e.as_ref() {
755                if spaced {
756                    tokens.push(PtxToken::Space);
757                }
758                opt_22.unparse_tokens_mode(tokens, spaced);
759            }
760            if self.f.is_some() {
761                tokens.push(PtxToken::Comma);
762            }
763            if let Some(opt_23) = self.f.as_ref() {
764                if spaced {
765                    tokens.push(PtxToken::Space);
766                }
767                opt_23.unparse_tokens_mode(tokens, spaced);
768            }
769            tokens.push(PtxToken::Semicolon);
770            if spaced {
771                tokens.push(PtxToken::Newline);
772            }
773        }
774    }
775
776    impl PtxUnparser for TexLevelGeomV2F16x2Ctype {
777        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
778            self.unparse_tokens_mode(tokens, false);
779        }
780        fn unparse_tokens_mode(&self, tokens: &mut ::std::vec::Vec<PtxToken>, spaced: bool) {
781            push_opcode(tokens, "tex");
782            push_directive(tokens, "level");
783            match &self.geom {
784                Geom::Acube => {
785                    push_directive(tokens, "acube");
786                }
787                Geom::A2dms => {
788                    push_directive(tokens, "a2dms");
789                }
790                Geom::Cube => {
791                    push_directive(tokens, "cube");
792                }
793                Geom::_2dms => {
794                    push_directive(tokens, "2dms");
795                }
796                Geom::A1d => {
797                    push_directive(tokens, "a1d");
798                }
799                Geom::A2d => {
800                    push_directive(tokens, "a2d");
801                }
802                Geom::_1d => {
803                    push_directive(tokens, "1d");
804                }
805                Geom::_2d => {
806                    push_directive(tokens, "2d");
807                }
808                Geom::_3d => {
809                    push_directive(tokens, "3d");
810                }
811            }
812            push_directive(tokens, "v2");
813            push_directive(tokens, "f16x2");
814            match &self.ctype {
815                Ctype::S32 => {
816                    push_directive(tokens, "s32");
817                }
818                Ctype::F32 => {
819                    push_directive(tokens, "f32");
820                }
821            }
822            if spaced {
823                tokens.push(PtxToken::Space);
824            }
825            self.d.unparse_tokens_mode(tokens, spaced);
826            if let Some(p_24) = self.p.as_ref() {
827                tokens.push(PtxToken::Pipe);
828                p_24.unparse_tokens_mode(tokens, spaced);
829            }
830            tokens.push(PtxToken::Comma);
831            if spaced {
832                tokens.push(PtxToken::Space);
833            }
834            self.a.unparse_tokens_mode(tokens, spaced);
835            tokens.push(PtxToken::Comma);
836            if spaced {
837                tokens.push(PtxToken::Space);
838            }
839            self.lod.unparse_tokens_mode(tokens, spaced);
840            if self.e.is_some() {
841                tokens.push(PtxToken::Comma);
842            }
843            if let Some(opt_25) = self.e.as_ref() {
844                if spaced {
845                    tokens.push(PtxToken::Space);
846                }
847                opt_25.unparse_tokens_mode(tokens, spaced);
848            }
849            if self.f.is_some() {
850                tokens.push(PtxToken::Comma);
851            }
852            if let Some(opt_26) = self.f.as_ref() {
853                if spaced {
854                    tokens.push(PtxToken::Space);
855                }
856                opt_26.unparse_tokens_mode(tokens, spaced);
857            }
858            tokens.push(PtxToken::Semicolon);
859            if spaced {
860                tokens.push(PtxToken::Newline);
861            }
862        }
863    }
864
865    impl PtxUnparser for TexGradGeomV2F16x2Ctype {
866        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
867            self.unparse_tokens_mode(tokens, false);
868        }
869        fn unparse_tokens_mode(&self, tokens: &mut ::std::vec::Vec<PtxToken>, spaced: bool) {
870            push_opcode(tokens, "tex");
871            push_directive(tokens, "grad");
872            match &self.geom {
873                Geom::Acube => {
874                    push_directive(tokens, "acube");
875                }
876                Geom::A2dms => {
877                    push_directive(tokens, "a2dms");
878                }
879                Geom::Cube => {
880                    push_directive(tokens, "cube");
881                }
882                Geom::_2dms => {
883                    push_directive(tokens, "2dms");
884                }
885                Geom::A1d => {
886                    push_directive(tokens, "a1d");
887                }
888                Geom::A2d => {
889                    push_directive(tokens, "a2d");
890                }
891                Geom::_1d => {
892                    push_directive(tokens, "1d");
893                }
894                Geom::_2d => {
895                    push_directive(tokens, "2d");
896                }
897                Geom::_3d => {
898                    push_directive(tokens, "3d");
899                }
900            }
901            push_directive(tokens, "v2");
902            push_directive(tokens, "f16x2");
903            match &self.ctype {
904                Ctype::S32 => {
905                    push_directive(tokens, "s32");
906                }
907                Ctype::F32 => {
908                    push_directive(tokens, "f32");
909                }
910            }
911            if spaced {
912                tokens.push(PtxToken::Space);
913            }
914            self.d.unparse_tokens_mode(tokens, spaced);
915            if let Some(p_27) = self.p.as_ref() {
916                tokens.push(PtxToken::Pipe);
917                p_27.unparse_tokens_mode(tokens, spaced);
918            }
919            tokens.push(PtxToken::Comma);
920            if spaced {
921                tokens.push(PtxToken::Space);
922            }
923            self.a.unparse_tokens_mode(tokens, spaced);
924            tokens.push(PtxToken::Comma);
925            if spaced {
926                tokens.push(PtxToken::Space);
927            }
928            self.dpdx.unparse_tokens_mode(tokens, spaced);
929            tokens.push(PtxToken::Comma);
930            if spaced {
931                tokens.push(PtxToken::Space);
932            }
933            self.dpdy.unparse_tokens_mode(tokens, spaced);
934            if self.e.is_some() {
935                tokens.push(PtxToken::Comma);
936            }
937            if let Some(opt_28) = self.e.as_ref() {
938                if spaced {
939                    tokens.push(PtxToken::Space);
940                }
941                opt_28.unparse_tokens_mode(tokens, spaced);
942            }
943            if self.f.is_some() {
944                tokens.push(PtxToken::Comma);
945            }
946            if let Some(opt_29) = self.f.as_ref() {
947                if spaced {
948                    tokens.push(PtxToken::Space);
949                }
950                opt_29.unparse_tokens_mode(tokens, spaced);
951            }
952            tokens.push(PtxToken::Semicolon);
953            if spaced {
954                tokens.push(PtxToken::Newline);
955            }
956        }
957    }
958}
ptx_parser/unparser/instruction/tex.rs

ptx_parser/unparser/instruction/
tex.rs
