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

ptx_parser/parser/instruction/
vset4.rs
