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

ptx_parser/parser/instruction/
set.rs
