ptx_parser/parser/instruction/
vset4.rs

1//! Original PTX specification:
2//!
3//! // SIMD instruction with secondary SIMD merge operation
4//! vset4.atype.btype.cmp  d{.mask}, a{.asel}, b{.bsel}, c;
5//! // SIMD instruction with secondary accumulate operation
6//! vset4.atype.btype.cmp.add  d{.mask}, a{.asel}, b{.bsel}, c;
7//! .atype = .btype = { .u32, .s32 };
8//! .cmp   = { .eq, .ne, .lt, .le, .gt, .ge };
9//! .mask  = { .b0,
10//! .b1, .b10
11//! .b2, .b20, .b21, .b210,
12//! .b3, .b30, .b31, .b310, .b32, .b320, .b321, .b3210 };
13//! defaults to .b3210
14//! .asel = .bsel = { .b00, .b01, .b02, .b03, .b04, .b05, .b06, .b07,
15//!                   .b10, .b11, .b12, .b13, .b14, .b15, .b16, .b17,
16//!                   .b20, .b21, .b22, .b23, .b24, .b25, .b26, .b27,
17//!                   .b30, .b31, .b32, .b33, .b34, .b35, .b36, .b37,
18//!                   .b40, .b41, .b42, .b43, .b44, .b45, .b46, .b47,
19//!                   .b50, .b51, .b52, .b53, .b54, .b55, .b56, .b57,
20//!                   .b60, .b61, .b62, .b63, .b64, .b65, .b66, .b67,
21//!                   .b70, .b71, .b72, .b73, .b74, .b75, .b76, .b77
22//!                   } //.bxyzw, where x,y,z,w are from { 0, ..., 7 };
23//! // .asel defaults to .b3210
24//! // .bsel defaults to .b7654
25
26#![allow(unused)]
27
28use crate::lexer::PtxToken;
29use crate::parser::{PtxParseError, PtxParser, PtxTokenStream, Span};
30use crate::r#type::common::*;
31
32pub mod section_0 {
33    use super::*;
34    use crate::r#type::instruction::vset4::section_0::*;
35
36    // ============================================================================
37    // Generated enum parsers
38    // ============================================================================
39
40    impl PtxParser for Atype {
41        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
42            // Try U32
43            {
44                let saved_pos = stream.position();
45                if stream.expect_string(".u32").is_ok() {
46                    return Ok(Atype::U32);
47                }
48                stream.set_position(saved_pos);
49            }
50            let saved_pos = stream.position();
51            // Try S32
52            {
53                let saved_pos = stream.position();
54                if stream.expect_string(".s32").is_ok() {
55                    return Ok(Atype::S32);
56                }
57                stream.set_position(saved_pos);
58            }
59            stream.set_position(saved_pos);
60            let span = stream
61                .peek()
62                .map(|(_, s)| s.clone())
63                .unwrap_or(Span { start: 0, end: 0 });
64            let expected = &[".u32", ".s32"];
65            let found = stream
66                .peek()
67                .map(|(t, _)| format!("{:?}", t))
68                .unwrap_or_else(|_| "<end of input>".to_string());
69            Err(crate::parser::unexpected_value(span, expected, found))
70        }
71    }
72
73    impl PtxParser for Bsel {
74        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
75            // Try B00
76            {
77                let saved_pos = stream.position();
78                if stream.expect_string(".b00").is_ok() {
79                    return Ok(Bsel::B00);
80                }
81                stream.set_position(saved_pos);
82            }
83            let saved_pos = stream.position();
84            // Try B01
85            {
86                let saved_pos = stream.position();
87                if stream.expect_string(".b01").is_ok() {
88                    return Ok(Bsel::B01);
89                }
90                stream.set_position(saved_pos);
91            }
92            stream.set_position(saved_pos);
93            let saved_pos = stream.position();
94            // Try B02
95            {
96                let saved_pos = stream.position();
97                if stream.expect_string(".b02").is_ok() {
98                    return Ok(Bsel::B02);
99                }
100                stream.set_position(saved_pos);
101            }
102            stream.set_position(saved_pos);
103            let saved_pos = stream.position();
104            // Try B03
105            {
106                let saved_pos = stream.position();
107                if stream.expect_string(".b03").is_ok() {
108                    return Ok(Bsel::B03);
109                }
110                stream.set_position(saved_pos);
111            }
112            stream.set_position(saved_pos);
113            let saved_pos = stream.position();
114            // Try B04
115            {
116                let saved_pos = stream.position();
117                if stream.expect_string(".b04").is_ok() {
118                    return Ok(Bsel::B04);
119                }
120                stream.set_position(saved_pos);
121            }
122            stream.set_position(saved_pos);
123            let saved_pos = stream.position();
124            // Try B05
125            {
126                let saved_pos = stream.position();
127                if stream.expect_string(".b05").is_ok() {
128                    return Ok(Bsel::B05);
129                }
130                stream.set_position(saved_pos);
131            }
132            stream.set_position(saved_pos);
133            let saved_pos = stream.position();
134            // Try B06
135            {
136                let saved_pos = stream.position();
137                if stream.expect_string(".b06").is_ok() {
138                    return Ok(Bsel::B06);
139                }
140                stream.set_position(saved_pos);
141            }
142            stream.set_position(saved_pos);
143            let saved_pos = stream.position();
144            // Try B07
145            {
146                let saved_pos = stream.position();
147                if stream.expect_string(".b07").is_ok() {
148                    return Ok(Bsel::B07);
149                }
150                stream.set_position(saved_pos);
151            }
152            stream.set_position(saved_pos);
153            let saved_pos = stream.position();
154            // Try B10
155            {
156                let saved_pos = stream.position();
157                if stream.expect_string(".b10").is_ok() {
158                    return Ok(Bsel::B10);
159                }
160                stream.set_position(saved_pos);
161            }
162            stream.set_position(saved_pos);
163            let saved_pos = stream.position();
164            // Try B11
165            {
166                let saved_pos = stream.position();
167                if stream.expect_string(".b11").is_ok() {
168                    return Ok(Bsel::B11);
169                }
170                stream.set_position(saved_pos);
171            }
172            stream.set_position(saved_pos);
173            let saved_pos = stream.position();
174            // Try B12
175            {
176                let saved_pos = stream.position();
177                if stream.expect_string(".b12").is_ok() {
178                    return Ok(Bsel::B12);
179                }
180                stream.set_position(saved_pos);
181            }
182            stream.set_position(saved_pos);
183            let saved_pos = stream.position();
184            // Try B13
185            {
186                let saved_pos = stream.position();
187                if stream.expect_string(".b13").is_ok() {
188                    return Ok(Bsel::B13);
189                }
190                stream.set_position(saved_pos);
191            }
192            stream.set_position(saved_pos);
193            let saved_pos = stream.position();
194            // Try B14
195            {
196                let saved_pos = stream.position();
197                if stream.expect_string(".b14").is_ok() {
198                    return Ok(Bsel::B14);
199                }
200                stream.set_position(saved_pos);
201            }
202            stream.set_position(saved_pos);
203            let saved_pos = stream.position();
204            // Try B15
205            {
206                let saved_pos = stream.position();
207                if stream.expect_string(".b15").is_ok() {
208                    return Ok(Bsel::B15);
209                }
210                stream.set_position(saved_pos);
211            }
212            stream.set_position(saved_pos);
213            let saved_pos = stream.position();
214            // Try B16
215            {
216                let saved_pos = stream.position();
217                if stream.expect_string(".b16").is_ok() {
218                    return Ok(Bsel::B16);
219                }
220                stream.set_position(saved_pos);
221            }
222            stream.set_position(saved_pos);
223            let saved_pos = stream.position();
224            // Try B17
225            {
226                let saved_pos = stream.position();
227                if stream.expect_string(".b17").is_ok() {
228                    return Ok(Bsel::B17);
229                }
230                stream.set_position(saved_pos);
231            }
232            stream.set_position(saved_pos);
233            let saved_pos = stream.position();
234            // Try B20
235            {
236                let saved_pos = stream.position();
237                if stream.expect_string(".b20").is_ok() {
238                    return Ok(Bsel::B20);
239                }
240                stream.set_position(saved_pos);
241            }
242            stream.set_position(saved_pos);
243            let saved_pos = stream.position();
244            // Try B21
245            {
246                let saved_pos = stream.position();
247                if stream.expect_string(".b21").is_ok() {
248                    return Ok(Bsel::B21);
249                }
250                stream.set_position(saved_pos);
251            }
252            stream.set_position(saved_pos);
253            let saved_pos = stream.position();
254            // Try B22
255            {
256                let saved_pos = stream.position();
257                if stream.expect_string(".b22").is_ok() {
258                    return Ok(Bsel::B22);
259                }
260                stream.set_position(saved_pos);
261            }
262            stream.set_position(saved_pos);
263            let saved_pos = stream.position();
264            // Try B23
265            {
266                let saved_pos = stream.position();
267                if stream.expect_string(".b23").is_ok() {
268                    return Ok(Bsel::B23);
269                }
270                stream.set_position(saved_pos);
271            }
272            stream.set_position(saved_pos);
273            let saved_pos = stream.position();
274            // Try B24
275            {
276                let saved_pos = stream.position();
277                if stream.expect_string(".b24").is_ok() {
278                    return Ok(Bsel::B24);
279                }
280                stream.set_position(saved_pos);
281            }
282            stream.set_position(saved_pos);
283            let saved_pos = stream.position();
284            // Try B25
285            {
286                let saved_pos = stream.position();
287                if stream.expect_string(".b25").is_ok() {
288                    return Ok(Bsel::B25);
289                }
290                stream.set_position(saved_pos);
291            }
292            stream.set_position(saved_pos);
293            let saved_pos = stream.position();
294            // Try B26
295            {
296                let saved_pos = stream.position();
297                if stream.expect_string(".b26").is_ok() {
298                    return Ok(Bsel::B26);
299                }
300                stream.set_position(saved_pos);
301            }
302            stream.set_position(saved_pos);
303            let saved_pos = stream.position();
304            // Try B27
305            {
306                let saved_pos = stream.position();
307                if stream.expect_string(".b27").is_ok() {
308                    return Ok(Bsel::B27);
309                }
310                stream.set_position(saved_pos);
311            }
312            stream.set_position(saved_pos);
313            let saved_pos = stream.position();
314            // Try B30
315            {
316                let saved_pos = stream.position();
317                if stream.expect_string(".b30").is_ok() {
318                    return Ok(Bsel::B30);
319                }
320                stream.set_position(saved_pos);
321            }
322            stream.set_position(saved_pos);
323            let saved_pos = stream.position();
324            // Try B31
325            {
326                let saved_pos = stream.position();
327                if stream.expect_string(".b31").is_ok() {
328                    return Ok(Bsel::B31);
329                }
330                stream.set_position(saved_pos);
331            }
332            stream.set_position(saved_pos);
333            let saved_pos = stream.position();
334            // Try B32
335            {
336                let saved_pos = stream.position();
337                if stream.expect_string(".b32").is_ok() {
338                    return Ok(Bsel::B32);
339                }
340                stream.set_position(saved_pos);
341            }
342            stream.set_position(saved_pos);
343            let saved_pos = stream.position();
344            // Try B33
345            {
346                let saved_pos = stream.position();
347                if stream.expect_string(".b33").is_ok() {
348                    return Ok(Bsel::B33);
349                }
350                stream.set_position(saved_pos);
351            }
352            stream.set_position(saved_pos);
353            let saved_pos = stream.position();
354            // Try B34
355            {
356                let saved_pos = stream.position();
357                if stream.expect_string(".b34").is_ok() {
358                    return Ok(Bsel::B34);
359                }
360                stream.set_position(saved_pos);
361            }
362            stream.set_position(saved_pos);
363            let saved_pos = stream.position();
364            // Try B35
365            {
366                let saved_pos = stream.position();
367                if stream.expect_string(".b35").is_ok() {
368                    return Ok(Bsel::B35);
369                }
370                stream.set_position(saved_pos);
371            }
372            stream.set_position(saved_pos);
373            let saved_pos = stream.position();
374            // Try B36
375            {
376                let saved_pos = stream.position();
377                if stream.expect_string(".b36").is_ok() {
378                    return Ok(Bsel::B36);
379                }
380                stream.set_position(saved_pos);
381            }
382            stream.set_position(saved_pos);
383            let saved_pos = stream.position();
384            // Try B37
385            {
386                let saved_pos = stream.position();
387                if stream.expect_string(".b37").is_ok() {
388                    return Ok(Bsel::B37);
389                }
390                stream.set_position(saved_pos);
391            }
392            stream.set_position(saved_pos);
393            let saved_pos = stream.position();
394            // Try B40
395            {
396                let saved_pos = stream.position();
397                if stream.expect_string(".b40").is_ok() {
398                    return Ok(Bsel::B40);
399                }
400                stream.set_position(saved_pos);
401            }
402            stream.set_position(saved_pos);
403            let saved_pos = stream.position();
404            // Try B41
405            {
406                let saved_pos = stream.position();
407                if stream.expect_string(".b41").is_ok() {
408                    return Ok(Bsel::B41);
409                }
410                stream.set_position(saved_pos);
411            }
412            stream.set_position(saved_pos);
413            let saved_pos = stream.position();
414            // Try B42
415            {
416                let saved_pos = stream.position();
417                if stream.expect_string(".b42").is_ok() {
418                    return Ok(Bsel::B42);
419                }
420                stream.set_position(saved_pos);
421            }
422            stream.set_position(saved_pos);
423            let saved_pos = stream.position();
424            // Try B43
425            {
426                let saved_pos = stream.position();
427                if stream.expect_string(".b43").is_ok() {
428                    return Ok(Bsel::B43);
429                }
430                stream.set_position(saved_pos);
431            }
432            stream.set_position(saved_pos);
433            let saved_pos = stream.position();
434            // Try B44
435            {
436                let saved_pos = stream.position();
437                if stream.expect_string(".b44").is_ok() {
438                    return Ok(Bsel::B44);
439                }
440                stream.set_position(saved_pos);
441            }
442            stream.set_position(saved_pos);
443            let saved_pos = stream.position();
444            // Try B45
445            {
446                let saved_pos = stream.position();
447                if stream.expect_string(".b45").is_ok() {
448                    return Ok(Bsel::B45);
449                }
450                stream.set_position(saved_pos);
451            }
452            stream.set_position(saved_pos);
453            let saved_pos = stream.position();
454            // Try B46
455            {
456                let saved_pos = stream.position();
457                if stream.expect_string(".b46").is_ok() {
458                    return Ok(Bsel::B46);
459                }
460                stream.set_position(saved_pos);
461            }
462            stream.set_position(saved_pos);
463            let saved_pos = stream.position();
464            // Try B47
465            {
466                let saved_pos = stream.position();
467                if stream.expect_string(".b47").is_ok() {
468                    return Ok(Bsel::B47);
469                }
470                stream.set_position(saved_pos);
471            }
472            stream.set_position(saved_pos);
473            let saved_pos = stream.position();
474            // Try B50
475            {
476                let saved_pos = stream.position();
477                if stream.expect_string(".b50").is_ok() {
478                    return Ok(Bsel::B50);
479                }
480                stream.set_position(saved_pos);
481            }
482            stream.set_position(saved_pos);
483            let saved_pos = stream.position();
484            // Try B51
485            {
486                let saved_pos = stream.position();
487                if stream.expect_string(".b51").is_ok() {
488                    return Ok(Bsel::B51);
489                }
490                stream.set_position(saved_pos);
491            }
492            stream.set_position(saved_pos);
493            let saved_pos = stream.position();
494            // Try B52
495            {
496                let saved_pos = stream.position();
497                if stream.expect_string(".b52").is_ok() {
498                    return Ok(Bsel::B52);
499                }
500                stream.set_position(saved_pos);
501            }
502            stream.set_position(saved_pos);
503            let saved_pos = stream.position();
504            // Try B53
505            {
506                let saved_pos = stream.position();
507                if stream.expect_string(".b53").is_ok() {
508                    return Ok(Bsel::B53);
509                }
510                stream.set_position(saved_pos);
511            }
512            stream.set_position(saved_pos);
513            let saved_pos = stream.position();
514            // Try B54
515            {
516                let saved_pos = stream.position();
517                if stream.expect_string(".b54").is_ok() {
518                    return Ok(Bsel::B54);
519                }
520                stream.set_position(saved_pos);
521            }
522            stream.set_position(saved_pos);
523            let saved_pos = stream.position();
524            // Try B55
525            {
526                let saved_pos = stream.position();
527                if stream.expect_string(".b55").is_ok() {
528                    return Ok(Bsel::B55);
529                }
530                stream.set_position(saved_pos);
531            }
532            stream.set_position(saved_pos);
533            let saved_pos = stream.position();
534            // Try B56
535            {
536                let saved_pos = stream.position();
537                if stream.expect_string(".b56").is_ok() {
538                    return Ok(Bsel::B56);
539                }
540                stream.set_position(saved_pos);
541            }
542            stream.set_position(saved_pos);
543            let saved_pos = stream.position();
544            // Try B57
545            {
546                let saved_pos = stream.position();
547                if stream.expect_string(".b57").is_ok() {
548                    return Ok(Bsel::B57);
549                }
550                stream.set_position(saved_pos);
551            }
552            stream.set_position(saved_pos);
553            let saved_pos = stream.position();
554            // Try B60
555            {
556                let saved_pos = stream.position();
557                if stream.expect_string(".b60").is_ok() {
558                    return Ok(Bsel::B60);
559                }
560                stream.set_position(saved_pos);
561            }
562            stream.set_position(saved_pos);
563            let saved_pos = stream.position();
564            // Try B61
565            {
566                let saved_pos = stream.position();
567                if stream.expect_string(".b61").is_ok() {
568                    return Ok(Bsel::B61);
569                }
570                stream.set_position(saved_pos);
571            }
572            stream.set_position(saved_pos);
573            let saved_pos = stream.position();
574            // Try B62
575            {
576                let saved_pos = stream.position();
577                if stream.expect_string(".b62").is_ok() {
578                    return Ok(Bsel::B62);
579                }
580                stream.set_position(saved_pos);
581            }
582            stream.set_position(saved_pos);
583            let saved_pos = stream.position();
584            // Try B63
585            {
586                let saved_pos = stream.position();
587                if stream.expect_string(".b63").is_ok() {
588                    return Ok(Bsel::B63);
589                }
590                stream.set_position(saved_pos);
591            }
592            stream.set_position(saved_pos);
593            let saved_pos = stream.position();
594            // Try B64
595            {
596                let saved_pos = stream.position();
597                if stream.expect_string(".b64").is_ok() {
598                    return Ok(Bsel::B64);
599                }
600                stream.set_position(saved_pos);
601            }
602            stream.set_position(saved_pos);
603            let saved_pos = stream.position();
604            // Try B65
605            {
606                let saved_pos = stream.position();
607                if stream.expect_string(".b65").is_ok() {
608                    return Ok(Bsel::B65);
609                }
610                stream.set_position(saved_pos);
611            }
612            stream.set_position(saved_pos);
613            let saved_pos = stream.position();
614            // Try B66
615            {
616                let saved_pos = stream.position();
617                if stream.expect_string(".b66").is_ok() {
618                    return Ok(Bsel::B66);
619                }
620                stream.set_position(saved_pos);
621            }
622            stream.set_position(saved_pos);
623            let saved_pos = stream.position();
624            // Try B67
625            {
626                let saved_pos = stream.position();
627                if stream.expect_string(".b67").is_ok() {
628                    return Ok(Bsel::B67);
629                }
630                stream.set_position(saved_pos);
631            }
632            stream.set_position(saved_pos);
633            let saved_pos = stream.position();
634            // Try B70
635            {
636                let saved_pos = stream.position();
637                if stream.expect_string(".b70").is_ok() {
638                    return Ok(Bsel::B70);
639                }
640                stream.set_position(saved_pos);
641            }
642            stream.set_position(saved_pos);
643            let saved_pos = stream.position();
644            // Try B71
645            {
646                let saved_pos = stream.position();
647                if stream.expect_string(".b71").is_ok() {
648                    return Ok(Bsel::B71);
649                }
650                stream.set_position(saved_pos);
651            }
652            stream.set_position(saved_pos);
653            let saved_pos = stream.position();
654            // Try B72
655            {
656                let saved_pos = stream.position();
657                if stream.expect_string(".b72").is_ok() {
658                    return Ok(Bsel::B72);
659                }
660                stream.set_position(saved_pos);
661            }
662            stream.set_position(saved_pos);
663            let saved_pos = stream.position();
664            // Try B73
665            {
666                let saved_pos = stream.position();
667                if stream.expect_string(".b73").is_ok() {
668                    return Ok(Bsel::B73);
669                }
670                stream.set_position(saved_pos);
671            }
672            stream.set_position(saved_pos);
673            let saved_pos = stream.position();
674            // Try B74
675            {
676                let saved_pos = stream.position();
677                if stream.expect_string(".b74").is_ok() {
678                    return Ok(Bsel::B74);
679                }
680                stream.set_position(saved_pos);
681            }
682            stream.set_position(saved_pos);
683            let saved_pos = stream.position();
684            // Try B75
685            {
686                let saved_pos = stream.position();
687                if stream.expect_string(".b75").is_ok() {
688                    return Ok(Bsel::B75);
689                }
690                stream.set_position(saved_pos);
691            }
692            stream.set_position(saved_pos);
693            let saved_pos = stream.position();
694            // Try B76
695            {
696                let saved_pos = stream.position();
697                if stream.expect_string(".b76").is_ok() {
698                    return Ok(Bsel::B76);
699                }
700                stream.set_position(saved_pos);
701            }
702            stream.set_position(saved_pos);
703            let saved_pos = stream.position();
704            // Try B77
705            {
706                let saved_pos = stream.position();
707                if stream.expect_string(".b77").is_ok() {
708                    return Ok(Bsel::B77);
709                }
710                stream.set_position(saved_pos);
711            }
712            stream.set_position(saved_pos);
713            let span = stream
714                .peek()
715                .map(|(_, s)| s.clone())
716                .unwrap_or(Span { start: 0, end: 0 });
717            let expected = &[
718                ".b00", ".b01", ".b02", ".b03", ".b04", ".b05", ".b06", ".b07", ".b10", ".b11",
719                ".b12", ".b13", ".b14", ".b15", ".b16", ".b17", ".b20", ".b21", ".b22", ".b23",
720                ".b24", ".b25", ".b26", ".b27", ".b30", ".b31", ".b32", ".b33", ".b34", ".b35",
721                ".b36", ".b37", ".b40", ".b41", ".b42", ".b43", ".b44", ".b45", ".b46", ".b47",
722                ".b50", ".b51", ".b52", ".b53", ".b54", ".b55", ".b56", ".b57", ".b60", ".b61",
723                ".b62", ".b63", ".b64", ".b65", ".b66", ".b67", ".b70", ".b71", ".b72", ".b73",
724                ".b74", ".b75", ".b76", ".b77",
725            ];
726            let found = stream
727                .peek()
728                .map(|(t, _)| format!("{:?}", t))
729                .unwrap_or_else(|_| "<end of input>".to_string());
730            Err(crate::parser::unexpected_value(span, expected, found))
731        }
732    }
733
734    impl PtxParser for Btype {
735        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
736            // Try U32
737            {
738                let saved_pos = stream.position();
739                if stream.expect_string(".u32").is_ok() {
740                    return Ok(Btype::U32);
741                }
742                stream.set_position(saved_pos);
743            }
744            let saved_pos = stream.position();
745            // Try S32
746            {
747                let saved_pos = stream.position();
748                if stream.expect_string(".s32").is_ok() {
749                    return Ok(Btype::S32);
750                }
751                stream.set_position(saved_pos);
752            }
753            stream.set_position(saved_pos);
754            let span = stream
755                .peek()
756                .map(|(_, s)| s.clone())
757                .unwrap_or(Span { start: 0, end: 0 });
758            let expected = &[".u32", ".s32"];
759            let found = stream
760                .peek()
761                .map(|(t, _)| format!("{:?}", t))
762                .unwrap_or_else(|_| "<end of input>".to_string());
763            Err(crate::parser::unexpected_value(span, expected, found))
764        }
765    }
766
767    impl PtxParser for Cmp {
768        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
769            // Try Eq
770            {
771                let saved_pos = stream.position();
772                if stream.expect_string(".eq").is_ok() {
773                    return Ok(Cmp::Eq);
774                }
775                stream.set_position(saved_pos);
776            }
777            let saved_pos = stream.position();
778            // Try Ne
779            {
780                let saved_pos = stream.position();
781                if stream.expect_string(".ne").is_ok() {
782                    return Ok(Cmp::Ne);
783                }
784                stream.set_position(saved_pos);
785            }
786            stream.set_position(saved_pos);
787            let saved_pos = stream.position();
788            // Try Lt
789            {
790                let saved_pos = stream.position();
791                if stream.expect_string(".lt").is_ok() {
792                    return Ok(Cmp::Lt);
793                }
794                stream.set_position(saved_pos);
795            }
796            stream.set_position(saved_pos);
797            let saved_pos = stream.position();
798            // Try Le
799            {
800                let saved_pos = stream.position();
801                if stream.expect_string(".le").is_ok() {
802                    return Ok(Cmp::Le);
803                }
804                stream.set_position(saved_pos);
805            }
806            stream.set_position(saved_pos);
807            let saved_pos = stream.position();
808            // Try Gt
809            {
810                let saved_pos = stream.position();
811                if stream.expect_string(".gt").is_ok() {
812                    return Ok(Cmp::Gt);
813                }
814                stream.set_position(saved_pos);
815            }
816            stream.set_position(saved_pos);
817            let saved_pos = stream.position();
818            // Try Ge
819            {
820                let saved_pos = stream.position();
821                if stream.expect_string(".ge").is_ok() {
822                    return Ok(Cmp::Ge);
823                }
824                stream.set_position(saved_pos);
825            }
826            stream.set_position(saved_pos);
827            let span = stream
828                .peek()
829                .map(|(_, s)| s.clone())
830                .unwrap_or(Span { start: 0, end: 0 });
831            let expected = &[".eq", ".ne", ".lt", ".le", ".gt", ".ge"];
832            let found = stream
833                .peek()
834                .map(|(t, _)| format!("{:?}", t))
835                .unwrap_or_else(|_| "<end of input>".to_string());
836            Err(crate::parser::unexpected_value(span, expected, found))
837        }
838    }
839
840    impl PtxParser for Mask {
841        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
842            // Try B10B2
843            {
844                let saved_pos = stream.position();
845                if stream.expect_string(".b10.b2").is_ok() {
846                    return Ok(Mask::B10B2);
847                }
848                stream.set_position(saved_pos);
849            }
850            let saved_pos = stream.position();
851            // Try B3210
852            {
853                let saved_pos = stream.position();
854                if stream.expect_string(".b3210").is_ok() {
855                    return Ok(Mask::B3210);
856                }
857                stream.set_position(saved_pos);
858            }
859            stream.set_position(saved_pos);
860            let saved_pos = stream.position();
861            // Try B210
862            {
863                let saved_pos = stream.position();
864                if stream.expect_string(".b210").is_ok() {
865                    return Ok(Mask::B210);
866                }
867                stream.set_position(saved_pos);
868            }
869            stream.set_position(saved_pos);
870            let saved_pos = stream.position();
871            // Try B310
872            {
873                let saved_pos = stream.position();
874                if stream.expect_string(".b310").is_ok() {
875                    return Ok(Mask::B310);
876                }
877                stream.set_position(saved_pos);
878            }
879            stream.set_position(saved_pos);
880            let saved_pos = stream.position();
881            // Try B320
882            {
883                let saved_pos = stream.position();
884                if stream.expect_string(".b320").is_ok() {
885                    return Ok(Mask::B320);
886                }
887                stream.set_position(saved_pos);
888            }
889            stream.set_position(saved_pos);
890            let saved_pos = stream.position();
891            // Try B321
892            {
893                let saved_pos = stream.position();
894                if stream.expect_string(".b321").is_ok() {
895                    return Ok(Mask::B321);
896                }
897                stream.set_position(saved_pos);
898            }
899            stream.set_position(saved_pos);
900            let saved_pos = stream.position();
901            // Try B20
902            {
903                let saved_pos = stream.position();
904                if stream.expect_string(".b20").is_ok() {
905                    return Ok(Mask::B20);
906                }
907                stream.set_position(saved_pos);
908            }
909            stream.set_position(saved_pos);
910            let saved_pos = stream.position();
911            // Try B21
912            {
913                let saved_pos = stream.position();
914                if stream.expect_string(".b21").is_ok() {
915                    return Ok(Mask::B21);
916                }
917                stream.set_position(saved_pos);
918            }
919            stream.set_position(saved_pos);
920            let saved_pos = stream.position();
921            // Try B30
922            {
923                let saved_pos = stream.position();
924                if stream.expect_string(".b30").is_ok() {
925                    return Ok(Mask::B30);
926                }
927                stream.set_position(saved_pos);
928            }
929            stream.set_position(saved_pos);
930            let saved_pos = stream.position();
931            // Try B31
932            {
933                let saved_pos = stream.position();
934                if stream.expect_string(".b31").is_ok() {
935                    return Ok(Mask::B31);
936                }
937                stream.set_position(saved_pos);
938            }
939            stream.set_position(saved_pos);
940            let saved_pos = stream.position();
941            // Try B32
942            {
943                let saved_pos = stream.position();
944                if stream.expect_string(".b32").is_ok() {
945                    return Ok(Mask::B32);
946                }
947                stream.set_position(saved_pos);
948            }
949            stream.set_position(saved_pos);
950            let saved_pos = stream.position();
951            // Try B0
952            {
953                let saved_pos = stream.position();
954                if stream.expect_string(".b0").is_ok() {
955                    return Ok(Mask::B0);
956                }
957                stream.set_position(saved_pos);
958            }
959            stream.set_position(saved_pos);
960            let saved_pos = stream.position();
961            // Try B1
962            {
963                let saved_pos = stream.position();
964                if stream.expect_string(".b1").is_ok() {
965                    return Ok(Mask::B1);
966                }
967                stream.set_position(saved_pos);
968            }
969            stream.set_position(saved_pos);
970            let saved_pos = stream.position();
971            // Try B3
972            {
973                let saved_pos = stream.position();
974                if stream.expect_string(".b3").is_ok() {
975                    return Ok(Mask::B3);
976                }
977                stream.set_position(saved_pos);
978            }
979            stream.set_position(saved_pos);
980            let span = stream
981                .peek()
982                .map(|(_, s)| s.clone())
983                .unwrap_or(Span { start: 0, end: 0 });
984            let expected = &[
985                ".b10.b2", ".b3210", ".b210", ".b310", ".b320", ".b321", ".b20", ".b21", ".b30",
986                ".b31", ".b32", ".b0", ".b1", ".b3",
987            ];
988            let found = stream
989                .peek()
990                .map(|(t, _)| format!("{:?}", t))
991                .unwrap_or_else(|_| "<end of input>".to_string());
992            Err(crate::parser::unexpected_value(span, expected, found))
993        }
994    }
995
996    impl PtxParser for Vset4AtypeBtypeCmp {
997        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
998            stream.expect_string("vset4")?;
999            let atype = Atype::parse(stream)?;
1000            stream.expect_complete()?;
1001            let btype = Btype::parse(stream)?;
1002            stream.expect_complete()?;
1003            let cmp = Cmp::parse(stream)?;
1004            stream.expect_complete()?;
1005            let d = GeneralOperand::parse(stream)?;
1006            let saved_pos = stream.position();
1007            let mask = match Mask::parse(stream) {
1008                Ok(val) => Some(val),
1009                Err(_) => {
1010                    stream.set_position(saved_pos);
1011                    None
1012                }
1013            };
1014            stream.expect_complete()?;
1015            stream.expect(&PtxToken::Comma)?;
1016            let a = GeneralOperand::parse(stream)?;
1017            let saved_pos = stream.position();
1018            let asel = stream.expect_string(".asel").is_ok();
1019            if !asel {
1020                stream.set_position(saved_pos);
1021            }
1022            stream.expect_complete()?;
1023            stream.expect(&PtxToken::Comma)?;
1024            let b = GeneralOperand::parse(stream)?;
1025            let saved_pos = stream.position();
1026            let bsel = match Bsel::parse(stream) {
1027                Ok(val) => Some(val),
1028                Err(_) => {
1029                    stream.set_position(saved_pos);
1030                    None
1031                }
1032            };
1033            stream.expect_complete()?;
1034            stream.expect(&PtxToken::Comma)?;
1035            let c = GeneralOperand::parse(stream)?;
1036            stream.expect_complete()?;
1037            stream.expect_complete()?;
1038            stream.expect(&PtxToken::Semicolon)?;
1039            Ok(Vset4AtypeBtypeCmp {
1040                atype,
1041                btype,
1042                cmp,
1043                d,
1044                mask,
1045                a,
1046                asel,
1047                b,
1048                bsel,
1049                c,
1050            })
1051        }
1052    }
1053
1054    impl PtxParser for Vset4AtypeBtypeCmpAdd {
1055        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
1056            stream.expect_string("vset4")?;
1057            let atype = Atype::parse(stream)?;
1058            stream.expect_complete()?;
1059            let btype = Btype::parse(stream)?;
1060            stream.expect_complete()?;
1061            let cmp = Cmp::parse(stream)?;
1062            stream.expect_complete()?;
1063            stream.expect_string(".add")?;
1064            let add = ();
1065            stream.expect_complete()?;
1066            let d = GeneralOperand::parse(stream)?;
1067            let saved_pos = stream.position();
1068            let mask = match Mask::parse(stream) {
1069                Ok(val) => Some(val),
1070                Err(_) => {
1071                    stream.set_position(saved_pos);
1072                    None
1073                }
1074            };
1075            stream.expect_complete()?;
1076            stream.expect(&PtxToken::Comma)?;
1077            let a = GeneralOperand::parse(stream)?;
1078            let saved_pos = stream.position();
1079            let asel = stream.expect_string(".asel").is_ok();
1080            if !asel {
1081                stream.set_position(saved_pos);
1082            }
1083            stream.expect_complete()?;
1084            stream.expect(&PtxToken::Comma)?;
1085            let b = GeneralOperand::parse(stream)?;
1086            let saved_pos = stream.position();
1087            let bsel = match Bsel::parse(stream) {
1088                Ok(val) => Some(val),
1089                Err(_) => {
1090                    stream.set_position(saved_pos);
1091                    None
1092                }
1093            };
1094            stream.expect_complete()?;
1095            stream.expect(&PtxToken::Comma)?;
1096            let c = GeneralOperand::parse(stream)?;
1097            stream.expect_complete()?;
1098            stream.expect_complete()?;
1099            stream.expect(&PtxToken::Semicolon)?;
1100            Ok(Vset4AtypeBtypeCmpAdd {
1101                atype,
1102                btype,
1103                cmp,
1104                add,
1105                d,
1106                mask,
1107                a,
1108                asel,
1109                b,
1110                bsel,
1111                c,
1112            })
1113        }
1114    }
1115}
ptx_parser/parser/instruction/vset4.rs

ptx_parser/parser/instruction/
vset4.rs
