ptx_parser/parser/instruction/
set.rs

1//! Original PTX specification:
2//!
3//! set.CmpOp{.ftz}.dtype.stype         d, a, b;
4//! set.CmpOp.BoolOp{.ftz}.dtype.stype  d, a, b, {!}c;
5//! .CmpOp  = { .eq, .ne, .lt, .le, .gt, .ge, .lo, .ls, .hi, .hs,
6//! .equ, .neu, .ltu, .leu, .gtu, .geu, .num, .nan };
7//! .BoolOp = { .and, .or, .xor };
8//! .dtype  = { .u32, .s32, .f32 };
9//! .stype  = { .b16, .b32, .b64,
10//! .u16, .u32, .u64,
11//! .s16, .s32, .s64,
12//! .f32, .f64 };
13//! -------------------------------------------------------------
14//! set.CmpOp{.ftz}.f16.stype            d, a, b;
15//! set.CmpOp.BoolOp{.ftz}.f16.stype     d, a, b, {!}c;
16//! set.CmpOp.bf16.stype                 d, a, b;
17//! set.CmpOp.BoolOp.bf16.stype          d, a, b, {!}c;
18//! set.CmpOp{.ftz}.dtype.f16            d, a, b;
19//! set.CmpOp.BoolOp{.ftz}.dtype.f16     d, a, b, {!}c;
20//! .dtype  = { .u16, .s16, .u32, .s32};
21//! ----------------------------------------------------
22//! // Alternate floating point type:
23//! set.CmpOp.dtype.bf16                 d, a, b;
24//! set.CmpOp.BoolOp.dtype.bf16          d, a, b, {!}c;
25//! .dtype  = { .u16, .s16, .u32, .s32};
26//! ----------------------------------------------------
27//! // Alternate floating point type:
28//! set.CmpOp{.ftz}.dtype.f16x2          d, a, b;
29//! set.CmpOp.BoolOp{.ftz}.dtype.f16x2   d, a, b, {!}c;
30//! .dtype  = { .f16x2, .u32, .s32};
31//! ----------------------------------------------------
32//! // Alternate floating point type:
33//! set.CmpOp.dtype.bf16x2               d, a, b;
34//! set.CmpOp.BoolOp.dtype.bf16x2        d, a, b, {!}c;
35//! .dtype  = { .bf16x2, .u32, .s32};
36//! .CmpOp  = { .eq, .ne, .lt, .le, .gt, .ge,
37//! .equ, .neu, .ltu, .leu, .gtu, .geu, .num, .nan };
38//! .BoolOp = { .and, .or, .xor };
39//! .stype  = { .b16, .b32, .b64,
40//! .u16, .u32, .u64,
41//! .s16, .s32, .s64,
42//! .f16, .f32, .f64};
43
44#![allow(unused)]
45
46use crate::lexer::PtxToken;
47use crate::parser::{PtxParseError, PtxParser, PtxTokenStream, Span};
48use crate::r#type::common::*;
49
50pub mod section_0 {
51    use super::*;
52    use crate::r#type::instruction::set::section_0::*;
53
54    // ============================================================================
55    // Generated enum parsers
56    // ============================================================================
57
58    impl PtxParser for Boolop {
59        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
60            // Try And
61            {
62                let saved_pos = stream.position();
63                if stream.expect_string(".and").is_ok() {
64                    return Ok(Boolop::And);
65                }
66                stream.set_position(saved_pos);
67            }
68            let saved_pos = stream.position();
69            // Try Xor
70            {
71                let saved_pos = stream.position();
72                if stream.expect_string(".xor").is_ok() {
73                    return Ok(Boolop::Xor);
74                }
75                stream.set_position(saved_pos);
76            }
77            stream.set_position(saved_pos);
78            let saved_pos = stream.position();
79            // Try Or
80            {
81                let saved_pos = stream.position();
82                if stream.expect_string(".or").is_ok() {
83                    return Ok(Boolop::Or);
84                }
85                stream.set_position(saved_pos);
86            }
87            stream.set_position(saved_pos);
88            let span = stream
89                .peek()
90                .map(|(_, s)| s.clone())
91                .unwrap_or(Span { start: 0, end: 0 });
92            let expected = &[".and", ".xor", ".or"];
93            let found = stream
94                .peek()
95                .map(|(t, _)| format!("{:?}", t))
96                .unwrap_or_else(|_| "<end of input>".to_string());
97            Err(crate::parser::unexpected_value(span, expected, found))
98        }
99    }
100
101    impl PtxParser for Cmpop {
102        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
103            // Try Equ
104            {
105                let saved_pos = stream.position();
106                if stream.expect_string(".equ").is_ok() {
107                    return Ok(Cmpop::Equ);
108                }
109                stream.set_position(saved_pos);
110            }
111            let saved_pos = stream.position();
112            // Try Neu
113            {
114                let saved_pos = stream.position();
115                if stream.expect_string(".neu").is_ok() {
116                    return Ok(Cmpop::Neu);
117                }
118                stream.set_position(saved_pos);
119            }
120            stream.set_position(saved_pos);
121            let saved_pos = stream.position();
122            // Try Ltu
123            {
124                let saved_pos = stream.position();
125                if stream.expect_string(".ltu").is_ok() {
126                    return Ok(Cmpop::Ltu);
127                }
128                stream.set_position(saved_pos);
129            }
130            stream.set_position(saved_pos);
131            let saved_pos = stream.position();
132            // Try Leu
133            {
134                let saved_pos = stream.position();
135                if stream.expect_string(".leu").is_ok() {
136                    return Ok(Cmpop::Leu);
137                }
138                stream.set_position(saved_pos);
139            }
140            stream.set_position(saved_pos);
141            let saved_pos = stream.position();
142            // Try Gtu
143            {
144                let saved_pos = stream.position();
145                if stream.expect_string(".gtu").is_ok() {
146                    return Ok(Cmpop::Gtu);
147                }
148                stream.set_position(saved_pos);
149            }
150            stream.set_position(saved_pos);
151            let saved_pos = stream.position();
152            // Try Geu
153            {
154                let saved_pos = stream.position();
155                if stream.expect_string(".geu").is_ok() {
156                    return Ok(Cmpop::Geu);
157                }
158                stream.set_position(saved_pos);
159            }
160            stream.set_position(saved_pos);
161            let saved_pos = stream.position();
162            // Try Num
163            {
164                let saved_pos = stream.position();
165                if stream.expect_string(".num").is_ok() {
166                    return Ok(Cmpop::Num);
167                }
168                stream.set_position(saved_pos);
169            }
170            stream.set_position(saved_pos);
171            let saved_pos = stream.position();
172            // Try Nan
173            {
174                let saved_pos = stream.position();
175                if stream.expect_string(".nan").is_ok() {
176                    return Ok(Cmpop::Nan);
177                }
178                stream.set_position(saved_pos);
179            }
180            stream.set_position(saved_pos);
181            let saved_pos = stream.position();
182            // Try Eq
183            {
184                let saved_pos = stream.position();
185                if stream.expect_string(".eq").is_ok() {
186                    return Ok(Cmpop::Eq);
187                }
188                stream.set_position(saved_pos);
189            }
190            stream.set_position(saved_pos);
191            let saved_pos = stream.position();
192            // Try Ne
193            {
194                let saved_pos = stream.position();
195                if stream.expect_string(".ne").is_ok() {
196                    return Ok(Cmpop::Ne);
197                }
198                stream.set_position(saved_pos);
199            }
200            stream.set_position(saved_pos);
201            let saved_pos = stream.position();
202            // Try Lt
203            {
204                let saved_pos = stream.position();
205                if stream.expect_string(".lt").is_ok() {
206                    return Ok(Cmpop::Lt);
207                }
208                stream.set_position(saved_pos);
209            }
210            stream.set_position(saved_pos);
211            let saved_pos = stream.position();
212            // Try Le
213            {
214                let saved_pos = stream.position();
215                if stream.expect_string(".le").is_ok() {
216                    return Ok(Cmpop::Le);
217                }
218                stream.set_position(saved_pos);
219            }
220            stream.set_position(saved_pos);
221            let saved_pos = stream.position();
222            // Try Gt
223            {
224                let saved_pos = stream.position();
225                if stream.expect_string(".gt").is_ok() {
226                    return Ok(Cmpop::Gt);
227                }
228                stream.set_position(saved_pos);
229            }
230            stream.set_position(saved_pos);
231            let saved_pos = stream.position();
232            // Try Ge
233            {
234                let saved_pos = stream.position();
235                if stream.expect_string(".ge").is_ok() {
236                    return Ok(Cmpop::Ge);
237                }
238                stream.set_position(saved_pos);
239            }
240            stream.set_position(saved_pos);
241            let saved_pos = stream.position();
242            // Try Lo
243            {
244                let saved_pos = stream.position();
245                if stream.expect_string(".lo").is_ok() {
246                    return Ok(Cmpop::Lo);
247                }
248                stream.set_position(saved_pos);
249            }
250            stream.set_position(saved_pos);
251            let saved_pos = stream.position();
252            // Try Ls
253            {
254                let saved_pos = stream.position();
255                if stream.expect_string(".ls").is_ok() {
256                    return Ok(Cmpop::Ls);
257                }
258                stream.set_position(saved_pos);
259            }
260            stream.set_position(saved_pos);
261            let saved_pos = stream.position();
262            // Try Hi
263            {
264                let saved_pos = stream.position();
265                if stream.expect_string(".hi").is_ok() {
266                    return Ok(Cmpop::Hi);
267                }
268                stream.set_position(saved_pos);
269            }
270            stream.set_position(saved_pos);
271            let saved_pos = stream.position();
272            // Try Hs
273            {
274                let saved_pos = stream.position();
275                if stream.expect_string(".hs").is_ok() {
276                    return Ok(Cmpop::Hs);
277                }
278                stream.set_position(saved_pos);
279            }
280            stream.set_position(saved_pos);
281            let span = stream
282                .peek()
283                .map(|(_, s)| s.clone())
284                .unwrap_or(Span { start: 0, end: 0 });
285            let expected = &[
286                ".equ", ".neu", ".ltu", ".leu", ".gtu", ".geu", ".num", ".nan", ".eq", ".ne",
287                ".lt", ".le", ".gt", ".ge", ".lo", ".ls", ".hi", ".hs",
288            ];
289            let found = stream
290                .peek()
291                .map(|(t, _)| format!("{:?}", t))
292                .unwrap_or_else(|_| "<end of input>".to_string());
293            Err(crate::parser::unexpected_value(span, expected, found))
294        }
295    }
296
297    impl PtxParser for Dtype {
298        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
299            // Try U32
300            {
301                let saved_pos = stream.position();
302                if stream.expect_string(".u32").is_ok() {
303                    return Ok(Dtype::U32);
304                }
305                stream.set_position(saved_pos);
306            }
307            let saved_pos = stream.position();
308            // Try S32
309            {
310                let saved_pos = stream.position();
311                if stream.expect_string(".s32").is_ok() {
312                    return Ok(Dtype::S32);
313                }
314                stream.set_position(saved_pos);
315            }
316            stream.set_position(saved_pos);
317            let saved_pos = stream.position();
318            // Try F32
319            {
320                let saved_pos = stream.position();
321                if stream.expect_string(".f32").is_ok() {
322                    return Ok(Dtype::F32);
323                }
324                stream.set_position(saved_pos);
325            }
326            stream.set_position(saved_pos);
327            let span = stream
328                .peek()
329                .map(|(_, s)| s.clone())
330                .unwrap_or(Span { start: 0, end: 0 });
331            let expected = &[".u32", ".s32", ".f32"];
332            let found = stream
333                .peek()
334                .map(|(t, _)| format!("{:?}", t))
335                .unwrap_or_else(|_| "<end of input>".to_string());
336            Err(crate::parser::unexpected_value(span, expected, found))
337        }
338    }
339
340    impl PtxParser for Stype {
341        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
342            // Try B16
343            {
344                let saved_pos = stream.position();
345                if stream.expect_string(".b16").is_ok() {
346                    return Ok(Stype::B16);
347                }
348                stream.set_position(saved_pos);
349            }
350            let saved_pos = stream.position();
351            // Try B32
352            {
353                let saved_pos = stream.position();
354                if stream.expect_string(".b32").is_ok() {
355                    return Ok(Stype::B32);
356                }
357                stream.set_position(saved_pos);
358            }
359            stream.set_position(saved_pos);
360            let saved_pos = stream.position();
361            // Try B64
362            {
363                let saved_pos = stream.position();
364                if stream.expect_string(".b64").is_ok() {
365                    return Ok(Stype::B64);
366                }
367                stream.set_position(saved_pos);
368            }
369            stream.set_position(saved_pos);
370            let saved_pos = stream.position();
371            // Try U16
372            {
373                let saved_pos = stream.position();
374                if stream.expect_string(".u16").is_ok() {
375                    return Ok(Stype::U16);
376                }
377                stream.set_position(saved_pos);
378            }
379            stream.set_position(saved_pos);
380            let saved_pos = stream.position();
381            // Try U32
382            {
383                let saved_pos = stream.position();
384                if stream.expect_string(".u32").is_ok() {
385                    return Ok(Stype::U32);
386                }
387                stream.set_position(saved_pos);
388            }
389            stream.set_position(saved_pos);
390            let saved_pos = stream.position();
391            // Try U64
392            {
393                let saved_pos = stream.position();
394                if stream.expect_string(".u64").is_ok() {
395                    return Ok(Stype::U64);
396                }
397                stream.set_position(saved_pos);
398            }
399            stream.set_position(saved_pos);
400            let saved_pos = stream.position();
401            // Try S16
402            {
403                let saved_pos = stream.position();
404                if stream.expect_string(".s16").is_ok() {
405                    return Ok(Stype::S16);
406                }
407                stream.set_position(saved_pos);
408            }
409            stream.set_position(saved_pos);
410            let saved_pos = stream.position();
411            // Try S32
412            {
413                let saved_pos = stream.position();
414                if stream.expect_string(".s32").is_ok() {
415                    return Ok(Stype::S32);
416                }
417                stream.set_position(saved_pos);
418            }
419            stream.set_position(saved_pos);
420            let saved_pos = stream.position();
421            // Try S64
422            {
423                let saved_pos = stream.position();
424                if stream.expect_string(".s64").is_ok() {
425                    return Ok(Stype::S64);
426                }
427                stream.set_position(saved_pos);
428            }
429            stream.set_position(saved_pos);
430            let saved_pos = stream.position();
431            // Try F32
432            {
433                let saved_pos = stream.position();
434                if stream.expect_string(".f32").is_ok() {
435                    return Ok(Stype::F32);
436                }
437                stream.set_position(saved_pos);
438            }
439            stream.set_position(saved_pos);
440            let saved_pos = stream.position();
441            // Try F64
442            {
443                let saved_pos = stream.position();
444                if stream.expect_string(".f64").is_ok() {
445                    return Ok(Stype::F64);
446                }
447                stream.set_position(saved_pos);
448            }
449            stream.set_position(saved_pos);
450            let span = stream
451                .peek()
452                .map(|(_, s)| s.clone())
453                .unwrap_or(Span { start: 0, end: 0 });
454            let expected = &[
455                ".b16", ".b32", ".b64", ".u16", ".u32", ".u64", ".s16", ".s32", ".s64", ".f32",
456                ".f64",
457            ];
458            let found = stream
459                .peek()
460                .map(|(t, _)| format!("{:?}", t))
461                .unwrap_or_else(|_| "<end of input>".to_string());
462            Err(crate::parser::unexpected_value(span, expected, found))
463        }
464    }
465
466    impl PtxParser for SetCmpopFtzDtypeStype {
467        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
468            stream.expect_string("set")?;
469            let cmpop = Cmpop::parse(stream)?;
470            stream.expect_complete()?;
471            let saved_pos = stream.position();
472            let ftz = stream.expect_string(".ftz").is_ok();
473            if !ftz {
474                stream.set_position(saved_pos);
475            }
476            stream.expect_complete()?;
477            let dtype = Dtype::parse(stream)?;
478            stream.expect_complete()?;
479            let stype = Stype::parse(stream)?;
480            stream.expect_complete()?;
481            let d = GeneralOperand::parse(stream)?;
482            stream.expect_complete()?;
483            stream.expect(&PtxToken::Comma)?;
484            let a = GeneralOperand::parse(stream)?;
485            stream.expect_complete()?;
486            stream.expect(&PtxToken::Comma)?;
487            let b = GeneralOperand::parse(stream)?;
488            stream.expect_complete()?;
489            stream.expect_complete()?;
490            stream.expect(&PtxToken::Semicolon)?;
491            Ok(SetCmpopFtzDtypeStype {
492                cmpop,
493                ftz,
494                dtype,
495                stype,
496                d,
497                a,
498                b,
499            })
500        }
501    }
502
503    impl PtxParser for SetCmpopBoolopFtzDtypeStype {
504        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
505            stream.expect_string("set")?;
506            let cmpop = Cmpop::parse(stream)?;
507            stream.expect_complete()?;
508            let boolop = Boolop::parse(stream)?;
509            stream.expect_complete()?;
510            let saved_pos = stream.position();
511            let ftz = stream.expect_string(".ftz").is_ok();
512            if !ftz {
513                stream.set_position(saved_pos);
514            }
515            stream.expect_complete()?;
516            let dtype = Dtype::parse(stream)?;
517            stream.expect_complete()?;
518            let stype = Stype::parse(stream)?;
519            stream.expect_complete()?;
520            let d = GeneralOperand::parse(stream)?;
521            stream.expect_complete()?;
522            stream.expect(&PtxToken::Comma)?;
523            let a = GeneralOperand::parse(stream)?;
524            stream.expect_complete()?;
525            stream.expect(&PtxToken::Comma)?;
526            let b = GeneralOperand::parse(stream)?;
527            stream.expect_complete()?;
528            stream.expect(&PtxToken::Comma)?;
529            let c_op = stream
530                .consume_if(|t| matches!(t, PtxToken::Exclaim))
531                .is_some();
532            let c = GeneralOperand::parse(stream)?;
533            stream.expect_complete()?;
534            stream.expect_complete()?;
535            stream.expect(&PtxToken::Semicolon)?;
536            Ok(SetCmpopBoolopFtzDtypeStype {
537                cmpop,
538                boolop,
539                ftz,
540                dtype,
541                stype,
542                d,
543                a,
544                b,
545                c_op,
546                c,
547            })
548        }
549    }
550}
551
552pub mod section_1 {
553    use super::*;
554    use crate::r#type::instruction::set::section_1::*;
555
556    // ============================================================================
557    // Generated enum parsers
558    // ============================================================================
559
560    impl PtxParser for Boolop {
561        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
562            // Try And
563            {
564                let saved_pos = stream.position();
565                if stream.expect_string(".and").is_ok() {
566                    return Ok(Boolop::And);
567                }
568                stream.set_position(saved_pos);
569            }
570            let saved_pos = stream.position();
571            // Try Xor
572            {
573                let saved_pos = stream.position();
574                if stream.expect_string(".xor").is_ok() {
575                    return Ok(Boolop::Xor);
576                }
577                stream.set_position(saved_pos);
578            }
579            stream.set_position(saved_pos);
580            let saved_pos = stream.position();
581            // Try Or
582            {
583                let saved_pos = stream.position();
584                if stream.expect_string(".or").is_ok() {
585                    return Ok(Boolop::Or);
586                }
587                stream.set_position(saved_pos);
588            }
589            stream.set_position(saved_pos);
590            let span = stream
591                .peek()
592                .map(|(_, s)| s.clone())
593                .unwrap_or(Span { start: 0, end: 0 });
594            let expected = &[".and", ".xor", ".or"];
595            let found = stream
596                .peek()
597                .map(|(t, _)| format!("{:?}", t))
598                .unwrap_or_else(|_| "<end of input>".to_string());
599            Err(crate::parser::unexpected_value(span, expected, found))
600        }
601    }
602
603    impl PtxParser for Cmpop {
604        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
605            // Try Equ
606            {
607                let saved_pos = stream.position();
608                if stream.expect_string(".equ").is_ok() {
609                    return Ok(Cmpop::Equ);
610                }
611                stream.set_position(saved_pos);
612            }
613            let saved_pos = stream.position();
614            // Try Neu
615            {
616                let saved_pos = stream.position();
617                if stream.expect_string(".neu").is_ok() {
618                    return Ok(Cmpop::Neu);
619                }
620                stream.set_position(saved_pos);
621            }
622            stream.set_position(saved_pos);
623            let saved_pos = stream.position();
624            // Try Ltu
625            {
626                let saved_pos = stream.position();
627                if stream.expect_string(".ltu").is_ok() {
628                    return Ok(Cmpop::Ltu);
629                }
630                stream.set_position(saved_pos);
631            }
632            stream.set_position(saved_pos);
633            let saved_pos = stream.position();
634            // Try Leu
635            {
636                let saved_pos = stream.position();
637                if stream.expect_string(".leu").is_ok() {
638                    return Ok(Cmpop::Leu);
639                }
640                stream.set_position(saved_pos);
641            }
642            stream.set_position(saved_pos);
643            let saved_pos = stream.position();
644            // Try Gtu
645            {
646                let saved_pos = stream.position();
647                if stream.expect_string(".gtu").is_ok() {
648                    return Ok(Cmpop::Gtu);
649                }
650                stream.set_position(saved_pos);
651            }
652            stream.set_position(saved_pos);
653            let saved_pos = stream.position();
654            // Try Geu
655            {
656                let saved_pos = stream.position();
657                if stream.expect_string(".geu").is_ok() {
658                    return Ok(Cmpop::Geu);
659                }
660                stream.set_position(saved_pos);
661            }
662            stream.set_position(saved_pos);
663            let saved_pos = stream.position();
664            // Try Num
665            {
666                let saved_pos = stream.position();
667                if stream.expect_string(".num").is_ok() {
668                    return Ok(Cmpop::Num);
669                }
670                stream.set_position(saved_pos);
671            }
672            stream.set_position(saved_pos);
673            let saved_pos = stream.position();
674            // Try Nan
675            {
676                let saved_pos = stream.position();
677                if stream.expect_string(".nan").is_ok() {
678                    return Ok(Cmpop::Nan);
679                }
680                stream.set_position(saved_pos);
681            }
682            stream.set_position(saved_pos);
683            let saved_pos = stream.position();
684            // Try Eq
685            {
686                let saved_pos = stream.position();
687                if stream.expect_string(".eq").is_ok() {
688                    return Ok(Cmpop::Eq);
689                }
690                stream.set_position(saved_pos);
691            }
692            stream.set_position(saved_pos);
693            let saved_pos = stream.position();
694            // Try Ne
695            {
696                let saved_pos = stream.position();
697                if stream.expect_string(".ne").is_ok() {
698                    return Ok(Cmpop::Ne);
699                }
700                stream.set_position(saved_pos);
701            }
702            stream.set_position(saved_pos);
703            let saved_pos = stream.position();
704            // Try Lt
705            {
706                let saved_pos = stream.position();
707                if stream.expect_string(".lt").is_ok() {
708                    return Ok(Cmpop::Lt);
709                }
710                stream.set_position(saved_pos);
711            }
712            stream.set_position(saved_pos);
713            let saved_pos = stream.position();
714            // Try Le
715            {
716                let saved_pos = stream.position();
717                if stream.expect_string(".le").is_ok() {
718                    return Ok(Cmpop::Le);
719                }
720                stream.set_position(saved_pos);
721            }
722            stream.set_position(saved_pos);
723            let saved_pos = stream.position();
724            // Try Gt
725            {
726                let saved_pos = stream.position();
727                if stream.expect_string(".gt").is_ok() {
728                    return Ok(Cmpop::Gt);
729                }
730                stream.set_position(saved_pos);
731            }
732            stream.set_position(saved_pos);
733            let saved_pos = stream.position();
734            // Try Ge
735            {
736                let saved_pos = stream.position();
737                if stream.expect_string(".ge").is_ok() {
738                    return Ok(Cmpop::Ge);
739                }
740                stream.set_position(saved_pos);
741            }
742            stream.set_position(saved_pos);
743            let saved_pos = stream.position();
744            // Try Lo
745            {
746                let saved_pos = stream.position();
747                if stream.expect_string(".lo").is_ok() {
748                    return Ok(Cmpop::Lo);
749                }
750                stream.set_position(saved_pos);
751            }
752            stream.set_position(saved_pos);
753            let saved_pos = stream.position();
754            // Try Ls
755            {
756                let saved_pos = stream.position();
757                if stream.expect_string(".ls").is_ok() {
758                    return Ok(Cmpop::Ls);
759                }
760                stream.set_position(saved_pos);
761            }
762            stream.set_position(saved_pos);
763            let saved_pos = stream.position();
764            // Try Hi
765            {
766                let saved_pos = stream.position();
767                if stream.expect_string(".hi").is_ok() {
768                    return Ok(Cmpop::Hi);
769                }
770                stream.set_position(saved_pos);
771            }
772            stream.set_position(saved_pos);
773            let saved_pos = stream.position();
774            // Try Hs
775            {
776                let saved_pos = stream.position();
777                if stream.expect_string(".hs").is_ok() {
778                    return Ok(Cmpop::Hs);
779                }
780                stream.set_position(saved_pos);
781            }
782            stream.set_position(saved_pos);
783            let span = stream
784                .peek()
785                .map(|(_, s)| s.clone())
786                .unwrap_or(Span { start: 0, end: 0 });
787            let expected = &[
788                ".equ", ".neu", ".ltu", ".leu", ".gtu", ".geu", ".num", ".nan", ".eq", ".ne",
789                ".lt", ".le", ".gt", ".ge", ".lo", ".ls", ".hi", ".hs",
790            ];
791            let found = stream
792                .peek()
793                .map(|(t, _)| format!("{:?}", t))
794                .unwrap_or_else(|_| "<end of input>".to_string());
795            Err(crate::parser::unexpected_value(span, expected, found))
796        }
797    }
798
799    impl PtxParser for Dtype {
800        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
801            // Try U16
802            {
803                let saved_pos = stream.position();
804                if stream.expect_string(".u16").is_ok() {
805                    return Ok(Dtype::U16);
806                }
807                stream.set_position(saved_pos);
808            }
809            let saved_pos = stream.position();
810            // Try S16
811            {
812                let saved_pos = stream.position();
813                if stream.expect_string(".s16").is_ok() {
814                    return Ok(Dtype::S16);
815                }
816                stream.set_position(saved_pos);
817            }
818            stream.set_position(saved_pos);
819            let saved_pos = stream.position();
820            // Try U32
821            {
822                let saved_pos = stream.position();
823                if stream.expect_string(".u32").is_ok() {
824                    return Ok(Dtype::U32);
825                }
826                stream.set_position(saved_pos);
827            }
828            stream.set_position(saved_pos);
829            let saved_pos = stream.position();
830            // Try S32
831            {
832                let saved_pos = stream.position();
833                if stream.expect_string(".s32").is_ok() {
834                    return Ok(Dtype::S32);
835                }
836                stream.set_position(saved_pos);
837            }
838            stream.set_position(saved_pos);
839            let span = stream
840                .peek()
841                .map(|(_, s)| s.clone())
842                .unwrap_or(Span { start: 0, end: 0 });
843            let expected = &[".u16", ".s16", ".u32", ".s32"];
844            let found = stream
845                .peek()
846                .map(|(t, _)| format!("{:?}", t))
847                .unwrap_or_else(|_| "<end of input>".to_string());
848            Err(crate::parser::unexpected_value(span, expected, found))
849        }
850    }
851
852    impl PtxParser for Stype {
853        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
854            // Try B16
855            {
856                let saved_pos = stream.position();
857                if stream.expect_string(".b16").is_ok() {
858                    return Ok(Stype::B16);
859                }
860                stream.set_position(saved_pos);
861            }
862            let saved_pos = stream.position();
863            // Try B32
864            {
865                let saved_pos = stream.position();
866                if stream.expect_string(".b32").is_ok() {
867                    return Ok(Stype::B32);
868                }
869                stream.set_position(saved_pos);
870            }
871            stream.set_position(saved_pos);
872            let saved_pos = stream.position();
873            // Try B64
874            {
875                let saved_pos = stream.position();
876                if stream.expect_string(".b64").is_ok() {
877                    return Ok(Stype::B64);
878                }
879                stream.set_position(saved_pos);
880            }
881            stream.set_position(saved_pos);
882            let saved_pos = stream.position();
883            // Try U16
884            {
885                let saved_pos = stream.position();
886                if stream.expect_string(".u16").is_ok() {
887                    return Ok(Stype::U16);
888                }
889                stream.set_position(saved_pos);
890            }
891            stream.set_position(saved_pos);
892            let saved_pos = stream.position();
893            // Try U32
894            {
895                let saved_pos = stream.position();
896                if stream.expect_string(".u32").is_ok() {
897                    return Ok(Stype::U32);
898                }
899                stream.set_position(saved_pos);
900            }
901            stream.set_position(saved_pos);
902            let saved_pos = stream.position();
903            // Try U64
904            {
905                let saved_pos = stream.position();
906                if stream.expect_string(".u64").is_ok() {
907                    return Ok(Stype::U64);
908                }
909                stream.set_position(saved_pos);
910            }
911            stream.set_position(saved_pos);
912            let saved_pos = stream.position();
913            // Try S16
914            {
915                let saved_pos = stream.position();
916                if stream.expect_string(".s16").is_ok() {
917                    return Ok(Stype::S16);
918                }
919                stream.set_position(saved_pos);
920            }
921            stream.set_position(saved_pos);
922            let saved_pos = stream.position();
923            // Try S32
924            {
925                let saved_pos = stream.position();
926                if stream.expect_string(".s32").is_ok() {
927                    return Ok(Stype::S32);
928                }
929                stream.set_position(saved_pos);
930            }
931            stream.set_position(saved_pos);
932            let saved_pos = stream.position();
933            // Try S64
934            {
935                let saved_pos = stream.position();
936                if stream.expect_string(".s64").is_ok() {
937                    return Ok(Stype::S64);
938                }
939                stream.set_position(saved_pos);
940            }
941            stream.set_position(saved_pos);
942            let saved_pos = stream.position();
943            // Try F32
944            {
945                let saved_pos = stream.position();
946                if stream.expect_string(".f32").is_ok() {
947                    return Ok(Stype::F32);
948                }
949                stream.set_position(saved_pos);
950            }
951            stream.set_position(saved_pos);
952            let saved_pos = stream.position();
953            // Try F64
954            {
955                let saved_pos = stream.position();
956                if stream.expect_string(".f64").is_ok() {
957                    return Ok(Stype::F64);
958                }
959                stream.set_position(saved_pos);
960            }
961            stream.set_position(saved_pos);
962            let span = stream
963                .peek()
964                .map(|(_, s)| s.clone())
965                .unwrap_or(Span { start: 0, end: 0 });
966            let expected = &[
967                ".b16", ".b32", ".b64", ".u16", ".u32", ".u64", ".s16", ".s32", ".s64", ".f32",
968                ".f64",
969            ];
970            let found = stream
971                .peek()
972                .map(|(t, _)| format!("{:?}", t))
973                .unwrap_or_else(|_| "<end of input>".to_string());
974            Err(crate::parser::unexpected_value(span, expected, found))
975        }
976    }
977
978    impl PtxParser for SetCmpopFtzF16Stype {
979        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
980            stream.expect_string("set")?;
981            let cmpop = Cmpop::parse(stream)?;
982            stream.expect_complete()?;
983            let saved_pos = stream.position();
984            let ftz = stream.expect_string(".ftz").is_ok();
985            if !ftz {
986                stream.set_position(saved_pos);
987            }
988            stream.expect_complete()?;
989            stream.expect_string(".f16")?;
990            let f16 = ();
991            stream.expect_complete()?;
992            let stype = Stype::parse(stream)?;
993            stream.expect_complete()?;
994            let d = GeneralOperand::parse(stream)?;
995            stream.expect_complete()?;
996            stream.expect(&PtxToken::Comma)?;
997            let a = GeneralOperand::parse(stream)?;
998            stream.expect_complete()?;
999            stream.expect(&PtxToken::Comma)?;
1000            let b = GeneralOperand::parse(stream)?;
1001            stream.expect_complete()?;
1002            stream.expect_complete()?;
1003            stream.expect(&PtxToken::Semicolon)?;
1004            Ok(SetCmpopFtzF16Stype {
1005                cmpop,
1006                ftz,
1007                f16,
1008                stype,
1009                d,
1010                a,
1011                b,
1012            })
1013        }
1014    }
1015
1016    impl PtxParser for SetCmpopBoolopFtzF16Stype {
1017        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
1018            stream.expect_string("set")?;
1019            let cmpop = Cmpop::parse(stream)?;
1020            stream.expect_complete()?;
1021            let boolop = Boolop::parse(stream)?;
1022            stream.expect_complete()?;
1023            let saved_pos = stream.position();
1024            let ftz = stream.expect_string(".ftz").is_ok();
1025            if !ftz {
1026                stream.set_position(saved_pos);
1027            }
1028            stream.expect_complete()?;
1029            stream.expect_string(".f16")?;
1030            let f16 = ();
1031            stream.expect_complete()?;
1032            let stype = Stype::parse(stream)?;
1033            stream.expect_complete()?;
1034            let d = GeneralOperand::parse(stream)?;
1035            stream.expect_complete()?;
1036            stream.expect(&PtxToken::Comma)?;
1037            let a = GeneralOperand::parse(stream)?;
1038            stream.expect_complete()?;
1039            stream.expect(&PtxToken::Comma)?;
1040            let b = GeneralOperand::parse(stream)?;
1041            stream.expect_complete()?;
1042            stream.expect(&PtxToken::Comma)?;
1043            let c_op = stream
1044                .consume_if(|t| matches!(t, PtxToken::Exclaim))
1045                .is_some();
1046            let c = GeneralOperand::parse(stream)?;
1047            stream.expect_complete()?;
1048            stream.expect_complete()?;
1049            stream.expect(&PtxToken::Semicolon)?;
1050            Ok(SetCmpopBoolopFtzF16Stype {
1051                cmpop,
1052                boolop,
1053                ftz,
1054                f16,
1055                stype,
1056                d,
1057                a,
1058                b,
1059                c_op,
1060                c,
1061            })
1062        }
1063    }
1064
1065    impl PtxParser for SetCmpopBf16Stype {
1066        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
1067            stream.expect_string("set")?;
1068            let cmpop = Cmpop::parse(stream)?;
1069            stream.expect_complete()?;
1070            stream.expect_string(".bf16")?;
1071            let bf16 = ();
1072            stream.expect_complete()?;
1073            let stype = Stype::parse(stream)?;
1074            stream.expect_complete()?;
1075            let d = GeneralOperand::parse(stream)?;
1076            stream.expect_complete()?;
1077            stream.expect(&PtxToken::Comma)?;
1078            let a = GeneralOperand::parse(stream)?;
1079            stream.expect_complete()?;
1080            stream.expect(&PtxToken::Comma)?;
1081            let b = GeneralOperand::parse(stream)?;
1082            stream.expect_complete()?;
1083            stream.expect_complete()?;
1084            stream.expect(&PtxToken::Semicolon)?;
1085            Ok(SetCmpopBf16Stype {
1086                cmpop,
1087                bf16,
1088                stype,
1089                d,
1090                a,
1091                b,
1092            })
1093        }
1094    }
1095
1096    impl PtxParser for SetCmpopBoolopBf16Stype {
1097        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
1098            stream.expect_string("set")?;
1099            let cmpop = Cmpop::parse(stream)?;
1100            stream.expect_complete()?;
1101            let boolop = Boolop::parse(stream)?;
1102            stream.expect_complete()?;
1103            stream.expect_string(".bf16")?;
1104            let bf16 = ();
1105            stream.expect_complete()?;
1106            let stype = Stype::parse(stream)?;
1107            stream.expect_complete()?;
1108            let d = GeneralOperand::parse(stream)?;
1109            stream.expect_complete()?;
1110            stream.expect(&PtxToken::Comma)?;
1111            let a = GeneralOperand::parse(stream)?;
1112            stream.expect_complete()?;
1113            stream.expect(&PtxToken::Comma)?;
1114            let b = GeneralOperand::parse(stream)?;
1115            stream.expect_complete()?;
1116            stream.expect(&PtxToken::Comma)?;
1117            let c_op = stream
1118                .consume_if(|t| matches!(t, PtxToken::Exclaim))
1119                .is_some();
1120            let c = GeneralOperand::parse(stream)?;
1121            stream.expect_complete()?;
1122            stream.expect_complete()?;
1123            stream.expect(&PtxToken::Semicolon)?;
1124            Ok(SetCmpopBoolopBf16Stype {
1125                cmpop,
1126                boolop,
1127                bf16,
1128                stype,
1129                d,
1130                a,
1131                b,
1132                c_op,
1133                c,
1134            })
1135        }
1136    }
1137
1138    impl PtxParser for SetCmpopFtzDtypeF16 {
1139        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
1140            stream.expect_string("set")?;
1141            let cmpop = Cmpop::parse(stream)?;
1142            stream.expect_complete()?;
1143            let saved_pos = stream.position();
1144            let ftz = stream.expect_string(".ftz").is_ok();
1145            if !ftz {
1146                stream.set_position(saved_pos);
1147            }
1148            stream.expect_complete()?;
1149            let dtype = Dtype::parse(stream)?;
1150            stream.expect_complete()?;
1151            stream.expect_string(".f16")?;
1152            let f16 = ();
1153            stream.expect_complete()?;
1154            let d = GeneralOperand::parse(stream)?;
1155            stream.expect_complete()?;
1156            stream.expect(&PtxToken::Comma)?;
1157            let a = GeneralOperand::parse(stream)?;
1158            stream.expect_complete()?;
1159            stream.expect(&PtxToken::Comma)?;
1160            let b = GeneralOperand::parse(stream)?;
1161            stream.expect_complete()?;
1162            stream.expect_complete()?;
1163            stream.expect(&PtxToken::Semicolon)?;
1164            Ok(SetCmpopFtzDtypeF16 {
1165                cmpop,
1166                ftz,
1167                dtype,
1168                f16,
1169                d,
1170                a,
1171                b,
1172            })
1173        }
1174    }
1175
1176    impl PtxParser for SetCmpopBoolopFtzDtypeF16 {
1177        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
1178            stream.expect_string("set")?;
1179            let cmpop = Cmpop::parse(stream)?;
1180            stream.expect_complete()?;
1181            let boolop = Boolop::parse(stream)?;
1182            stream.expect_complete()?;
1183            let saved_pos = stream.position();
1184            let ftz = stream.expect_string(".ftz").is_ok();
1185            if !ftz {
1186                stream.set_position(saved_pos);
1187            }
1188            stream.expect_complete()?;
1189            let dtype = Dtype::parse(stream)?;
1190            stream.expect_complete()?;
1191            stream.expect_string(".f16")?;
1192            let f16 = ();
1193            stream.expect_complete()?;
1194            let d = GeneralOperand::parse(stream)?;
1195            stream.expect_complete()?;
1196            stream.expect(&PtxToken::Comma)?;
1197            let a = GeneralOperand::parse(stream)?;
1198            stream.expect_complete()?;
1199            stream.expect(&PtxToken::Comma)?;
1200            let b = GeneralOperand::parse(stream)?;
1201            stream.expect_complete()?;
1202            stream.expect(&PtxToken::Comma)?;
1203            let c_op = stream
1204                .consume_if(|t| matches!(t, PtxToken::Exclaim))
1205                .is_some();
1206            let c = GeneralOperand::parse(stream)?;
1207            stream.expect_complete()?;
1208            stream.expect_complete()?;
1209            stream.expect(&PtxToken::Semicolon)?;
1210            Ok(SetCmpopBoolopFtzDtypeF16 {
1211                cmpop,
1212                boolop,
1213                ftz,
1214                dtype,
1215                f16,
1216                d,
1217                a,
1218                b,
1219                c_op,
1220                c,
1221            })
1222        }
1223    }
1224}
1225
1226pub mod section_2 {
1227    use super::*;
1228    use crate::r#type::instruction::set::section_2::*;
1229
1230    // ============================================================================
1231    // Generated enum parsers
1232    // ============================================================================
1233
1234    impl PtxParser for Boolop {
1235        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
1236            // Try And
1237            {
1238                let saved_pos = stream.position();
1239                if stream.expect_string(".and").is_ok() {
1240                    return Ok(Boolop::And);
1241                }
1242                stream.set_position(saved_pos);
1243            }
1244            let saved_pos = stream.position();
1245            // Try Xor
1246            {
1247                let saved_pos = stream.position();
1248                if stream.expect_string(".xor").is_ok() {
1249                    return Ok(Boolop::Xor);
1250                }
1251                stream.set_position(saved_pos);
1252            }
1253            stream.set_position(saved_pos);
1254            let saved_pos = stream.position();
1255            // Try Or
1256            {
1257                let saved_pos = stream.position();
1258                if stream.expect_string(".or").is_ok() {
1259                    return Ok(Boolop::Or);
1260                }
1261                stream.set_position(saved_pos);
1262            }
1263            stream.set_position(saved_pos);
1264            let span = stream
1265                .peek()
1266                .map(|(_, s)| s.clone())
1267                .unwrap_or(Span { start: 0, end: 0 });
1268            let expected = &[".and", ".xor", ".or"];
1269            let found = stream
1270                .peek()
1271                .map(|(t, _)| format!("{:?}", t))
1272                .unwrap_or_else(|_| "<end of input>".to_string());
1273            Err(crate::parser::unexpected_value(span, expected, found))
1274        }
1275    }
1276
1277    impl PtxParser for Cmpop {
1278        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
1279            // Try Equ
1280            {
1281                let saved_pos = stream.position();
1282                if stream.expect_string(".equ").is_ok() {
1283                    return Ok(Cmpop::Equ);
1284                }
1285                stream.set_position(saved_pos);
1286            }
1287            let saved_pos = stream.position();
1288            // Try Neu
1289            {
1290                let saved_pos = stream.position();
1291                if stream.expect_string(".neu").is_ok() {
1292                    return Ok(Cmpop::Neu);
1293                }
1294                stream.set_position(saved_pos);
1295            }
1296            stream.set_position(saved_pos);
1297            let saved_pos = stream.position();
1298            // Try Ltu
1299            {
1300                let saved_pos = stream.position();
1301                if stream.expect_string(".ltu").is_ok() {
1302                    return Ok(Cmpop::Ltu);
1303                }
1304                stream.set_position(saved_pos);
1305            }
1306            stream.set_position(saved_pos);
1307            let saved_pos = stream.position();
1308            // Try Leu
1309            {
1310                let saved_pos = stream.position();
1311                if stream.expect_string(".leu").is_ok() {
1312                    return Ok(Cmpop::Leu);
1313                }
1314                stream.set_position(saved_pos);
1315            }
1316            stream.set_position(saved_pos);
1317            let saved_pos = stream.position();
1318            // Try Gtu
1319            {
1320                let saved_pos = stream.position();
1321                if stream.expect_string(".gtu").is_ok() {
1322                    return Ok(Cmpop::Gtu);
1323                }
1324                stream.set_position(saved_pos);
1325            }
1326            stream.set_position(saved_pos);
1327            let saved_pos = stream.position();
1328            // Try Geu
1329            {
1330                let saved_pos = stream.position();
1331                if stream.expect_string(".geu").is_ok() {
1332                    return Ok(Cmpop::Geu);
1333                }
1334                stream.set_position(saved_pos);
1335            }
1336            stream.set_position(saved_pos);
1337            let saved_pos = stream.position();
1338            // Try Num
1339            {
1340                let saved_pos = stream.position();
1341                if stream.expect_string(".num").is_ok() {
1342                    return Ok(Cmpop::Num);
1343                }
1344                stream.set_position(saved_pos);
1345            }
1346            stream.set_position(saved_pos);
1347            let saved_pos = stream.position();
1348            // Try Nan
1349            {
1350                let saved_pos = stream.position();
1351                if stream.expect_string(".nan").is_ok() {
1352                    return Ok(Cmpop::Nan);
1353                }
1354                stream.set_position(saved_pos);
1355            }
1356            stream.set_position(saved_pos);
1357            let saved_pos = stream.position();
1358            // Try Eq
1359            {
1360                let saved_pos = stream.position();
1361                if stream.expect_string(".eq").is_ok() {
1362                    return Ok(Cmpop::Eq);
1363                }
1364                stream.set_position(saved_pos);
1365            }
1366            stream.set_position(saved_pos);
1367            let saved_pos = stream.position();
1368            // Try Ne
1369            {
1370                let saved_pos = stream.position();
1371                if stream.expect_string(".ne").is_ok() {
1372                    return Ok(Cmpop::Ne);
1373                }
1374                stream.set_position(saved_pos);
1375            }
1376            stream.set_position(saved_pos);
1377            let saved_pos = stream.position();
1378            // Try Lt
1379            {
1380                let saved_pos = stream.position();
1381                if stream.expect_string(".lt").is_ok() {
1382                    return Ok(Cmpop::Lt);
1383                }
1384                stream.set_position(saved_pos);
1385            }
1386            stream.set_position(saved_pos);
1387            let saved_pos = stream.position();
1388            // Try Le
1389            {
1390                let saved_pos = stream.position();
1391                if stream.expect_string(".le").is_ok() {
1392                    return Ok(Cmpop::Le);
1393                }
1394                stream.set_position(saved_pos);
1395            }
1396            stream.set_position(saved_pos);
1397            let saved_pos = stream.position();
1398            // Try Gt
1399            {
1400                let saved_pos = stream.position();
1401                if stream.expect_string(".gt").is_ok() {
1402                    return Ok(Cmpop::Gt);
1403                }
1404                stream.set_position(saved_pos);
1405            }
1406            stream.set_position(saved_pos);
1407            let saved_pos = stream.position();
1408            // Try Ge
1409            {
1410                let saved_pos = stream.position();
1411                if stream.expect_string(".ge").is_ok() {
1412                    return Ok(Cmpop::Ge);
1413                }
1414                stream.set_position(saved_pos);
1415            }
1416            stream.set_position(saved_pos);
1417            let saved_pos = stream.position();
1418            // Try Lo
1419            {
1420                let saved_pos = stream.position();
1421                if stream.expect_string(".lo").is_ok() {
1422                    return Ok(Cmpop::Lo);
1423                }
1424                stream.set_position(saved_pos);
1425            }
1426            stream.set_position(saved_pos);
1427            let saved_pos = stream.position();
1428            // Try Ls
1429            {
1430                let saved_pos = stream.position();
1431                if stream.expect_string(".ls").is_ok() {
1432                    return Ok(Cmpop::Ls);
1433                }
1434                stream.set_position(saved_pos);
1435            }
1436            stream.set_position(saved_pos);
1437            let saved_pos = stream.position();
1438            // Try Hi
1439            {
1440                let saved_pos = stream.position();
1441                if stream.expect_string(".hi").is_ok() {
1442                    return Ok(Cmpop::Hi);
1443                }
1444                stream.set_position(saved_pos);
1445            }
1446            stream.set_position(saved_pos);
1447            let saved_pos = stream.position();
1448            // Try Hs
1449            {
1450                let saved_pos = stream.position();
1451                if stream.expect_string(".hs").is_ok() {
1452                    return Ok(Cmpop::Hs);
1453                }
1454                stream.set_position(saved_pos);
1455            }
1456            stream.set_position(saved_pos);
1457            let span = stream
1458                .peek()
1459                .map(|(_, s)| s.clone())
1460                .unwrap_or(Span { start: 0, end: 0 });
1461            let expected = &[
1462                ".equ", ".neu", ".ltu", ".leu", ".gtu", ".geu", ".num", ".nan", ".eq", ".ne",
1463                ".lt", ".le", ".gt", ".ge", ".lo", ".ls", ".hi", ".hs",
1464            ];
1465            let found = stream
1466                .peek()
1467                .map(|(t, _)| format!("{:?}", t))
1468                .unwrap_or_else(|_| "<end of input>".to_string());
1469            Err(crate::parser::unexpected_value(span, expected, found))
1470        }
1471    }
1472
1473    impl PtxParser for Dtype {
1474        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
1475            // Try U16
1476            {
1477                let saved_pos = stream.position();
1478                if stream.expect_string(".u16").is_ok() {
1479                    return Ok(Dtype::U16);
1480                }
1481                stream.set_position(saved_pos);
1482            }
1483            let saved_pos = stream.position();
1484            // Try S16
1485            {
1486                let saved_pos = stream.position();
1487                if stream.expect_string(".s16").is_ok() {
1488                    return Ok(Dtype::S16);
1489                }
1490                stream.set_position(saved_pos);
1491            }
1492            stream.set_position(saved_pos);
1493            let saved_pos = stream.position();
1494            // Try U32
1495            {
1496                let saved_pos = stream.position();
1497                if stream.expect_string(".u32").is_ok() {
1498                    return Ok(Dtype::U32);
1499                }
1500                stream.set_position(saved_pos);
1501            }
1502            stream.set_position(saved_pos);
1503            let saved_pos = stream.position();
1504            // Try S32
1505            {
1506                let saved_pos = stream.position();
1507                if stream.expect_string(".s32").is_ok() {
1508                    return Ok(Dtype::S32);
1509                }
1510                stream.set_position(saved_pos);
1511            }
1512            stream.set_position(saved_pos);
1513            let span = stream
1514                .peek()
1515                .map(|(_, s)| s.clone())
1516                .unwrap_or(Span { start: 0, end: 0 });
1517            let expected = &[".u16", ".s16", ".u32", ".s32"];
1518            let found = stream
1519                .peek()
1520                .map(|(t, _)| format!("{:?}", t))
1521                .unwrap_or_else(|_| "<end of input>".to_string());
1522            Err(crate::parser::unexpected_value(span, expected, found))
1523        }
1524    }
1525
1526    impl PtxParser for SetCmpopDtypeBf16 {
1527        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
1528            stream.expect_string("set")?;
1529            let cmpop = Cmpop::parse(stream)?;
1530            stream.expect_complete()?;
1531            let dtype = Dtype::parse(stream)?;
1532            stream.expect_complete()?;
1533            stream.expect_string(".bf16")?;
1534            let bf16 = ();
1535            stream.expect_complete()?;
1536            let d = GeneralOperand::parse(stream)?;
1537            stream.expect_complete()?;
1538            stream.expect(&PtxToken::Comma)?;
1539            let a = GeneralOperand::parse(stream)?;
1540            stream.expect_complete()?;
1541            stream.expect(&PtxToken::Comma)?;
1542            let b = GeneralOperand::parse(stream)?;
1543            stream.expect_complete()?;
1544            stream.expect_complete()?;
1545            stream.expect(&PtxToken::Semicolon)?;
1546            Ok(SetCmpopDtypeBf16 {
1547                cmpop,
1548                dtype,
1549                bf16,
1550                d,
1551                a,
1552                b,
1553            })
1554        }
1555    }
1556
1557    impl PtxParser for SetCmpopBoolopDtypeBf16 {
1558        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
1559            stream.expect_string("set")?;
1560            let cmpop = Cmpop::parse(stream)?;
1561            stream.expect_complete()?;
1562            let boolop = Boolop::parse(stream)?;
1563            stream.expect_complete()?;
1564            let dtype = Dtype::parse(stream)?;
1565            stream.expect_complete()?;
1566            stream.expect_string(".bf16")?;
1567            let bf16 = ();
1568            stream.expect_complete()?;
1569            let d = GeneralOperand::parse(stream)?;
1570            stream.expect_complete()?;
1571            stream.expect(&PtxToken::Comma)?;
1572            let a = GeneralOperand::parse(stream)?;
1573            stream.expect_complete()?;
1574            stream.expect(&PtxToken::Comma)?;
1575            let b = GeneralOperand::parse(stream)?;
1576            stream.expect_complete()?;
1577            stream.expect(&PtxToken::Comma)?;
1578            let c_op = stream
1579                .consume_if(|t| matches!(t, PtxToken::Exclaim))
1580                .is_some();
1581            let c = GeneralOperand::parse(stream)?;
1582            stream.expect_complete()?;
1583            stream.expect_complete()?;
1584            stream.expect(&PtxToken::Semicolon)?;
1585            Ok(SetCmpopBoolopDtypeBf16 {
1586                cmpop,
1587                boolop,
1588                dtype,
1589                bf16,
1590                d,
1591                a,
1592                b,
1593                c_op,
1594                c,
1595            })
1596        }
1597    }
1598}
1599
1600pub mod section_3 {
1601    use super::*;
1602    use crate::r#type::instruction::set::section_3::*;
1603
1604    // ============================================================================
1605    // Generated enum parsers
1606    // ============================================================================
1607
1608    impl PtxParser for Boolop {
1609        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
1610            // Try And
1611            {
1612                let saved_pos = stream.position();
1613                if stream.expect_string(".and").is_ok() {
1614                    return Ok(Boolop::And);
1615                }
1616                stream.set_position(saved_pos);
1617            }
1618            let saved_pos = stream.position();
1619            // Try Xor
1620            {
1621                let saved_pos = stream.position();
1622                if stream.expect_string(".xor").is_ok() {
1623                    return Ok(Boolop::Xor);
1624                }
1625                stream.set_position(saved_pos);
1626            }
1627            stream.set_position(saved_pos);
1628            let saved_pos = stream.position();
1629            // Try Or
1630            {
1631                let saved_pos = stream.position();
1632                if stream.expect_string(".or").is_ok() {
1633                    return Ok(Boolop::Or);
1634                }
1635                stream.set_position(saved_pos);
1636            }
1637            stream.set_position(saved_pos);
1638            let span = stream
1639                .peek()
1640                .map(|(_, s)| s.clone())
1641                .unwrap_or(Span { start: 0, end: 0 });
1642            let expected = &[".and", ".xor", ".or"];
1643            let found = stream
1644                .peek()
1645                .map(|(t, _)| format!("{:?}", t))
1646                .unwrap_or_else(|_| "<end of input>".to_string());
1647            Err(crate::parser::unexpected_value(span, expected, found))
1648        }
1649    }
1650
1651    impl PtxParser for Cmpop {
1652        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
1653            // Try Equ
1654            {
1655                let saved_pos = stream.position();
1656                if stream.expect_string(".equ").is_ok() {
1657                    return Ok(Cmpop::Equ);
1658                }
1659                stream.set_position(saved_pos);
1660            }
1661            let saved_pos = stream.position();
1662            // Try Neu
1663            {
1664                let saved_pos = stream.position();
1665                if stream.expect_string(".neu").is_ok() {
1666                    return Ok(Cmpop::Neu);
1667                }
1668                stream.set_position(saved_pos);
1669            }
1670            stream.set_position(saved_pos);
1671            let saved_pos = stream.position();
1672            // Try Ltu
1673            {
1674                let saved_pos = stream.position();
1675                if stream.expect_string(".ltu").is_ok() {
1676                    return Ok(Cmpop::Ltu);
1677                }
1678                stream.set_position(saved_pos);
1679            }
1680            stream.set_position(saved_pos);
1681            let saved_pos = stream.position();
1682            // Try Leu
1683            {
1684                let saved_pos = stream.position();
1685                if stream.expect_string(".leu").is_ok() {
1686                    return Ok(Cmpop::Leu);
1687                }
1688                stream.set_position(saved_pos);
1689            }
1690            stream.set_position(saved_pos);
1691            let saved_pos = stream.position();
1692            // Try Gtu
1693            {
1694                let saved_pos = stream.position();
1695                if stream.expect_string(".gtu").is_ok() {
1696                    return Ok(Cmpop::Gtu);
1697                }
1698                stream.set_position(saved_pos);
1699            }
1700            stream.set_position(saved_pos);
1701            let saved_pos = stream.position();
1702            // Try Geu
1703            {
1704                let saved_pos = stream.position();
1705                if stream.expect_string(".geu").is_ok() {
1706                    return Ok(Cmpop::Geu);
1707                }
1708                stream.set_position(saved_pos);
1709            }
1710            stream.set_position(saved_pos);
1711            let saved_pos = stream.position();
1712            // Try Num
1713            {
1714                let saved_pos = stream.position();
1715                if stream.expect_string(".num").is_ok() {
1716                    return Ok(Cmpop::Num);
1717                }
1718                stream.set_position(saved_pos);
1719            }
1720            stream.set_position(saved_pos);
1721            let saved_pos = stream.position();
1722            // Try Nan
1723            {
1724                let saved_pos = stream.position();
1725                if stream.expect_string(".nan").is_ok() {
1726                    return Ok(Cmpop::Nan);
1727                }
1728                stream.set_position(saved_pos);
1729            }
1730            stream.set_position(saved_pos);
1731            let saved_pos = stream.position();
1732            // Try Eq
1733            {
1734                let saved_pos = stream.position();
1735                if stream.expect_string(".eq").is_ok() {
1736                    return Ok(Cmpop::Eq);
1737                }
1738                stream.set_position(saved_pos);
1739            }
1740            stream.set_position(saved_pos);
1741            let saved_pos = stream.position();
1742            // Try Ne
1743            {
1744                let saved_pos = stream.position();
1745                if stream.expect_string(".ne").is_ok() {
1746                    return Ok(Cmpop::Ne);
1747                }
1748                stream.set_position(saved_pos);
1749            }
1750            stream.set_position(saved_pos);
1751            let saved_pos = stream.position();
1752            // Try Lt
1753            {
1754                let saved_pos = stream.position();
1755                if stream.expect_string(".lt").is_ok() {
1756                    return Ok(Cmpop::Lt);
1757                }
1758                stream.set_position(saved_pos);
1759            }
1760            stream.set_position(saved_pos);
1761            let saved_pos = stream.position();
1762            // Try Le
1763            {
1764                let saved_pos = stream.position();
1765                if stream.expect_string(".le").is_ok() {
1766                    return Ok(Cmpop::Le);
1767                }
1768                stream.set_position(saved_pos);
1769            }
1770            stream.set_position(saved_pos);
1771            let saved_pos = stream.position();
1772            // Try Gt
1773            {
1774                let saved_pos = stream.position();
1775                if stream.expect_string(".gt").is_ok() {
1776                    return Ok(Cmpop::Gt);
1777                }
1778                stream.set_position(saved_pos);
1779            }
1780            stream.set_position(saved_pos);
1781            let saved_pos = stream.position();
1782            // Try Ge
1783            {
1784                let saved_pos = stream.position();
1785                if stream.expect_string(".ge").is_ok() {
1786                    return Ok(Cmpop::Ge);
1787                }
1788                stream.set_position(saved_pos);
1789            }
1790            stream.set_position(saved_pos);
1791            let saved_pos = stream.position();
1792            // Try Lo
1793            {
1794                let saved_pos = stream.position();
1795                if stream.expect_string(".lo").is_ok() {
1796                    return Ok(Cmpop::Lo);
1797                }
1798                stream.set_position(saved_pos);
1799            }
1800            stream.set_position(saved_pos);
1801            let saved_pos = stream.position();
1802            // Try Ls
1803            {
1804                let saved_pos = stream.position();
1805                if stream.expect_string(".ls").is_ok() {
1806                    return Ok(Cmpop::Ls);
1807                }
1808                stream.set_position(saved_pos);
1809            }
1810            stream.set_position(saved_pos);
1811            let saved_pos = stream.position();
1812            // Try Hi
1813            {
1814                let saved_pos = stream.position();
1815                if stream.expect_string(".hi").is_ok() {
1816                    return Ok(Cmpop::Hi);
1817                }
1818                stream.set_position(saved_pos);
1819            }
1820            stream.set_position(saved_pos);
1821            let saved_pos = stream.position();
1822            // Try Hs
1823            {
1824                let saved_pos = stream.position();
1825                if stream.expect_string(".hs").is_ok() {
1826                    return Ok(Cmpop::Hs);
1827                }
1828                stream.set_position(saved_pos);
1829            }
1830            stream.set_position(saved_pos);
1831            let span = stream
1832                .peek()
1833                .map(|(_, s)| s.clone())
1834                .unwrap_or(Span { start: 0, end: 0 });
1835            let expected = &[
1836                ".equ", ".neu", ".ltu", ".leu", ".gtu", ".geu", ".num", ".nan", ".eq", ".ne",
1837                ".lt", ".le", ".gt", ".ge", ".lo", ".ls", ".hi", ".hs",
1838            ];
1839            let found = stream
1840                .peek()
1841                .map(|(t, _)| format!("{:?}", t))
1842                .unwrap_or_else(|_| "<end of input>".to_string());
1843            Err(crate::parser::unexpected_value(span, expected, found))
1844        }
1845    }
1846
1847    impl PtxParser for Dtype {
1848        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
1849            // Try F16x2
1850            {
1851                let saved_pos = stream.position();
1852                if stream.expect_string(".f16x2").is_ok() {
1853                    return Ok(Dtype::F16x2);
1854                }
1855                stream.set_position(saved_pos);
1856            }
1857            let saved_pos = stream.position();
1858            // Try U32
1859            {
1860                let saved_pos = stream.position();
1861                if stream.expect_string(".u32").is_ok() {
1862                    return Ok(Dtype::U32);
1863                }
1864                stream.set_position(saved_pos);
1865            }
1866            stream.set_position(saved_pos);
1867            let saved_pos = stream.position();
1868            // Try S32
1869            {
1870                let saved_pos = stream.position();
1871                if stream.expect_string(".s32").is_ok() {
1872                    return Ok(Dtype::S32);
1873                }
1874                stream.set_position(saved_pos);
1875            }
1876            stream.set_position(saved_pos);
1877            let span = stream
1878                .peek()
1879                .map(|(_, s)| s.clone())
1880                .unwrap_or(Span { start: 0, end: 0 });
1881            let expected = &[".f16x2", ".u32", ".s32"];
1882            let found = stream
1883                .peek()
1884                .map(|(t, _)| format!("{:?}", t))
1885                .unwrap_or_else(|_| "<end of input>".to_string());
1886            Err(crate::parser::unexpected_value(span, expected, found))
1887        }
1888    }
1889
1890    impl PtxParser for SetCmpopFtzDtypeF16x2 {
1891        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
1892            stream.expect_string("set")?;
1893            let cmpop = Cmpop::parse(stream)?;
1894            stream.expect_complete()?;
1895            let saved_pos = stream.position();
1896            let ftz = stream.expect_string(".ftz").is_ok();
1897            if !ftz {
1898                stream.set_position(saved_pos);
1899            }
1900            stream.expect_complete()?;
1901            let dtype = Dtype::parse(stream)?;
1902            stream.expect_complete()?;
1903            stream.expect_string(".f16x2")?;
1904            let f16x2 = ();
1905            stream.expect_complete()?;
1906            let d = GeneralOperand::parse(stream)?;
1907            stream.expect_complete()?;
1908            stream.expect(&PtxToken::Comma)?;
1909            let a = GeneralOperand::parse(stream)?;
1910            stream.expect_complete()?;
1911            stream.expect(&PtxToken::Comma)?;
1912            let b = GeneralOperand::parse(stream)?;
1913            stream.expect_complete()?;
1914            stream.expect_complete()?;
1915            stream.expect(&PtxToken::Semicolon)?;
1916            Ok(SetCmpopFtzDtypeF16x2 {
1917                cmpop,
1918                ftz,
1919                dtype,
1920                f16x2,
1921                d,
1922                a,
1923                b,
1924            })
1925        }
1926    }
1927
1928    impl PtxParser for SetCmpopBoolopFtzDtypeF16x2 {
1929        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
1930            stream.expect_string("set")?;
1931            let cmpop = Cmpop::parse(stream)?;
1932            stream.expect_complete()?;
1933            let boolop = Boolop::parse(stream)?;
1934            stream.expect_complete()?;
1935            let saved_pos = stream.position();
1936            let ftz = stream.expect_string(".ftz").is_ok();
1937            if !ftz {
1938                stream.set_position(saved_pos);
1939            }
1940            stream.expect_complete()?;
1941            let dtype = Dtype::parse(stream)?;
1942            stream.expect_complete()?;
1943            stream.expect_string(".f16x2")?;
1944            let f16x2 = ();
1945            stream.expect_complete()?;
1946            let d = GeneralOperand::parse(stream)?;
1947            stream.expect_complete()?;
1948            stream.expect(&PtxToken::Comma)?;
1949            let a = GeneralOperand::parse(stream)?;
1950            stream.expect_complete()?;
1951            stream.expect(&PtxToken::Comma)?;
1952            let b = GeneralOperand::parse(stream)?;
1953            stream.expect_complete()?;
1954            stream.expect(&PtxToken::Comma)?;
1955            let c_op = stream
1956                .consume_if(|t| matches!(t, PtxToken::Exclaim))
1957                .is_some();
1958            let c = GeneralOperand::parse(stream)?;
1959            stream.expect_complete()?;
1960            stream.expect_complete()?;
1961            stream.expect(&PtxToken::Semicolon)?;
1962            Ok(SetCmpopBoolopFtzDtypeF16x2 {
1963                cmpop,
1964                boolop,
1965                ftz,
1966                dtype,
1967                f16x2,
1968                d,
1969                a,
1970                b,
1971                c_op,
1972                c,
1973            })
1974        }
1975    }
1976}
1977
1978pub mod section_4 {
1979    use super::*;
1980    use crate::r#type::instruction::set::section_4::*;
1981
1982    // ============================================================================
1983    // Generated enum parsers
1984    // ============================================================================
1985
1986    impl PtxParser for Boolop {
1987        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
1988            // Try And
1989            {
1990                let saved_pos = stream.position();
1991                if stream.expect_string(".and").is_ok() {
1992                    return Ok(Boolop::And);
1993                }
1994                stream.set_position(saved_pos);
1995            }
1996            let saved_pos = stream.position();
1997            // Try Xor
1998            {
1999                let saved_pos = stream.position();
2000                if stream.expect_string(".xor").is_ok() {
2001                    return Ok(Boolop::Xor);
2002                }
2003                stream.set_position(saved_pos);
2004            }
2005            stream.set_position(saved_pos);
2006            let saved_pos = stream.position();
2007            // Try Or
2008            {
2009                let saved_pos = stream.position();
2010                if stream.expect_string(".or").is_ok() {
2011                    return Ok(Boolop::Or);
2012                }
2013                stream.set_position(saved_pos);
2014            }
2015            stream.set_position(saved_pos);
2016            let span = stream
2017                .peek()
2018                .map(|(_, s)| s.clone())
2019                .unwrap_or(Span { start: 0, end: 0 });
2020            let expected = &[".and", ".xor", ".or"];
2021            let found = stream
2022                .peek()
2023                .map(|(t, _)| format!("{:?}", t))
2024                .unwrap_or_else(|_| "<end of input>".to_string());
2025            Err(crate::parser::unexpected_value(span, expected, found))
2026        }
2027    }
2028
2029    impl PtxParser for Cmpop {
2030        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
2031            // Try Equ
2032            {
2033                let saved_pos = stream.position();
2034                if stream.expect_string(".equ").is_ok() {
2035                    return Ok(Cmpop::Equ);
2036                }
2037                stream.set_position(saved_pos);
2038            }
2039            let saved_pos = stream.position();
2040            // Try Neu
2041            {
2042                let saved_pos = stream.position();
2043                if stream.expect_string(".neu").is_ok() {
2044                    return Ok(Cmpop::Neu);
2045                }
2046                stream.set_position(saved_pos);
2047            }
2048            stream.set_position(saved_pos);
2049            let saved_pos = stream.position();
2050            // Try Ltu
2051            {
2052                let saved_pos = stream.position();
2053                if stream.expect_string(".ltu").is_ok() {
2054                    return Ok(Cmpop::Ltu);
2055                }
2056                stream.set_position(saved_pos);
2057            }
2058            stream.set_position(saved_pos);
2059            let saved_pos = stream.position();
2060            // Try Leu
2061            {
2062                let saved_pos = stream.position();
2063                if stream.expect_string(".leu").is_ok() {
2064                    return Ok(Cmpop::Leu);
2065                }
2066                stream.set_position(saved_pos);
2067            }
2068            stream.set_position(saved_pos);
2069            let saved_pos = stream.position();
2070            // Try Gtu
2071            {
2072                let saved_pos = stream.position();
2073                if stream.expect_string(".gtu").is_ok() {
2074                    return Ok(Cmpop::Gtu);
2075                }
2076                stream.set_position(saved_pos);
2077            }
2078            stream.set_position(saved_pos);
2079            let saved_pos = stream.position();
2080            // Try Geu
2081            {
2082                let saved_pos = stream.position();
2083                if stream.expect_string(".geu").is_ok() {
2084                    return Ok(Cmpop::Geu);
2085                }
2086                stream.set_position(saved_pos);
2087            }
2088            stream.set_position(saved_pos);
2089            let saved_pos = stream.position();
2090            // Try Num
2091            {
2092                let saved_pos = stream.position();
2093                if stream.expect_string(".num").is_ok() {
2094                    return Ok(Cmpop::Num);
2095                }
2096                stream.set_position(saved_pos);
2097            }
2098            stream.set_position(saved_pos);
2099            let saved_pos = stream.position();
2100            // Try Nan
2101            {
2102                let saved_pos = stream.position();
2103                if stream.expect_string(".nan").is_ok() {
2104                    return Ok(Cmpop::Nan);
2105                }
2106                stream.set_position(saved_pos);
2107            }
2108            stream.set_position(saved_pos);
2109            let saved_pos = stream.position();
2110            // Try Eq
2111            {
2112                let saved_pos = stream.position();
2113                if stream.expect_string(".eq").is_ok() {
2114                    return Ok(Cmpop::Eq);
2115                }
2116                stream.set_position(saved_pos);
2117            }
2118            stream.set_position(saved_pos);
2119            let saved_pos = stream.position();
2120            // Try Ne
2121            {
2122                let saved_pos = stream.position();
2123                if stream.expect_string(".ne").is_ok() {
2124                    return Ok(Cmpop::Ne);
2125                }
2126                stream.set_position(saved_pos);
2127            }
2128            stream.set_position(saved_pos);
2129            let saved_pos = stream.position();
2130            // Try Lt
2131            {
2132                let saved_pos = stream.position();
2133                if stream.expect_string(".lt").is_ok() {
2134                    return Ok(Cmpop::Lt);
2135                }
2136                stream.set_position(saved_pos);
2137            }
2138            stream.set_position(saved_pos);
2139            let saved_pos = stream.position();
2140            // Try Le
2141            {
2142                let saved_pos = stream.position();
2143                if stream.expect_string(".le").is_ok() {
2144                    return Ok(Cmpop::Le);
2145                }
2146                stream.set_position(saved_pos);
2147            }
2148            stream.set_position(saved_pos);
2149            let saved_pos = stream.position();
2150            // Try Gt
2151            {
2152                let saved_pos = stream.position();
2153                if stream.expect_string(".gt").is_ok() {
2154                    return Ok(Cmpop::Gt);
2155                }
2156                stream.set_position(saved_pos);
2157            }
2158            stream.set_position(saved_pos);
2159            let saved_pos = stream.position();
2160            // Try Ge
2161            {
2162                let saved_pos = stream.position();
2163                if stream.expect_string(".ge").is_ok() {
2164                    return Ok(Cmpop::Ge);
2165                }
2166                stream.set_position(saved_pos);
2167            }
2168            stream.set_position(saved_pos);
2169            let span = stream
2170                .peek()
2171                .map(|(_, s)| s.clone())
2172                .unwrap_or(Span { start: 0, end: 0 });
2173            let expected = &[
2174                ".equ", ".neu", ".ltu", ".leu", ".gtu", ".geu", ".num", ".nan", ".eq", ".ne",
2175                ".lt", ".le", ".gt", ".ge",
2176            ];
2177            let found = stream
2178                .peek()
2179                .map(|(t, _)| format!("{:?}", t))
2180                .unwrap_or_else(|_| "<end of input>".to_string());
2181            Err(crate::parser::unexpected_value(span, expected, found))
2182        }
2183    }
2184
2185    impl PtxParser for Dtype {
2186        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
2187            // Try Bf16x2
2188            {
2189                let saved_pos = stream.position();
2190                if stream.expect_string(".bf16x2").is_ok() {
2191                    return Ok(Dtype::Bf16x2);
2192                }
2193                stream.set_position(saved_pos);
2194            }
2195            let saved_pos = stream.position();
2196            // Try U32
2197            {
2198                let saved_pos = stream.position();
2199                if stream.expect_string(".u32").is_ok() {
2200                    return Ok(Dtype::U32);
2201                }
2202                stream.set_position(saved_pos);
2203            }
2204            stream.set_position(saved_pos);
2205            let saved_pos = stream.position();
2206            // Try S32
2207            {
2208                let saved_pos = stream.position();
2209                if stream.expect_string(".s32").is_ok() {
2210                    return Ok(Dtype::S32);
2211                }
2212                stream.set_position(saved_pos);
2213            }
2214            stream.set_position(saved_pos);
2215            let span = stream
2216                .peek()
2217                .map(|(_, s)| s.clone())
2218                .unwrap_or(Span { start: 0, end: 0 });
2219            let expected = &[".bf16x2", ".u32", ".s32"];
2220            let found = stream
2221                .peek()
2222                .map(|(t, _)| format!("{:?}", t))
2223                .unwrap_or_else(|_| "<end of input>".to_string());
2224            Err(crate::parser::unexpected_value(span, expected, found))
2225        }
2226    }
2227
2228    impl PtxParser for SetCmpopDtypeBf16x2 {
2229        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
2230            stream.expect_string("set")?;
2231            let cmpop = Cmpop::parse(stream)?;
2232            stream.expect_complete()?;
2233            let dtype = Dtype::parse(stream)?;
2234            stream.expect_complete()?;
2235            stream.expect_string(".bf16x2")?;
2236            let bf16x2 = ();
2237            stream.expect_complete()?;
2238            let d = GeneralOperand::parse(stream)?;
2239            stream.expect_complete()?;
2240            stream.expect(&PtxToken::Comma)?;
2241            let a = GeneralOperand::parse(stream)?;
2242            stream.expect_complete()?;
2243            stream.expect(&PtxToken::Comma)?;
2244            let b = GeneralOperand::parse(stream)?;
2245            stream.expect_complete()?;
2246            stream.expect_complete()?;
2247            stream.expect(&PtxToken::Semicolon)?;
2248            Ok(SetCmpopDtypeBf16x2 {
2249                cmpop,
2250                dtype,
2251                bf16x2,
2252                d,
2253                a,
2254                b,
2255            })
2256        }
2257    }
2258
2259    impl PtxParser for SetCmpopBoolopDtypeBf16x2 {
2260        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
2261            stream.expect_string("set")?;
2262            let cmpop = Cmpop::parse(stream)?;
2263            stream.expect_complete()?;
2264            let boolop = Boolop::parse(stream)?;
2265            stream.expect_complete()?;
2266            let dtype = Dtype::parse(stream)?;
2267            stream.expect_complete()?;
2268            stream.expect_string(".bf16x2")?;
2269            let bf16x2 = ();
2270            stream.expect_complete()?;
2271            let d = GeneralOperand::parse(stream)?;
2272            stream.expect_complete()?;
2273            stream.expect(&PtxToken::Comma)?;
2274            let a = GeneralOperand::parse(stream)?;
2275            stream.expect_complete()?;
2276            stream.expect(&PtxToken::Comma)?;
2277            let b = GeneralOperand::parse(stream)?;
2278            stream.expect_complete()?;
2279            stream.expect(&PtxToken::Comma)?;
2280            let c_op = stream
2281                .consume_if(|t| matches!(t, PtxToken::Exclaim))
2282                .is_some();
2283            let c = GeneralOperand::parse(stream)?;
2284            stream.expect_complete()?;
2285            stream.expect_complete()?;
2286            stream.expect(&PtxToken::Semicolon)?;
2287            Ok(SetCmpopBoolopDtypeBf16x2 {
2288                cmpop,
2289                boolop,
2290                dtype,
2291                bf16x2,
2292                d,
2293                a,
2294                b,
2295                c_op,
2296                c,
2297            })
2298        }
2299    }
2300}
ptx_parser/parser/instruction/set.rs

ptx_parser/parser/instruction/
set.rs
