ptx_parser/parser/instruction/
setp.rs

1//! Original PTX specification:
2//!
3//! setp.CmpOp{.ftz}.type         p{|q}, a, b;
4//! setp.CmpOp.BoolOp{.ftz}.type  p{|q}, a, b, {!}c;
5//! .CmpOp  = { .eq, .ne, .lt, .le, .gt, .ge, .lo, .ls, .hi, .hs, .equ, .neu, .ltu, .leu, .gtu, .geu, .num, .nan };
6//! .BoolOp = { .and, .or, .xor };
7//! .type   = { .b16, .b32, .b64, .u16, .u32, .u64, .s16, .s32, .s64, .f32, .f64 };
8//! --------------------------------------------------------------
9//! setp.CmpOp{.ftz}.f16           p, a, b;
10//! setp.CmpOp.BoolOp{.ftz}.f16    p, a, b, {!}c;
11//! setp.CmpOp{.ftz}.f16x2         p|q, a, b;
12//! setp.CmpOp.BoolOp{.ftz}.f16x2  p|q, a, b, {!}c;
13//! setp.CmpOp.bf16                p, a, b;
14//! setp.CmpOp.BoolOp.bf16         p, a, b, {!}c;
15//! setp.CmpOp.bf16x2              p|q, a, b;
16//! setp.CmpOp.BoolOp.bf16x2       p|q, a, b, {!}c;
17//! .CmpOp  = { .eq, .ne, .lt, .le, .gt, .ge, .equ, .neu, .ltu, .leu, .gtu, .geu, .num, .nan };
18//! .BoolOp = { .and, .or, .xor };
19
20#![allow(unused)]
21
22use crate::lexer::PtxToken;
23use crate::parser::{PtxParseError, PtxParser, PtxTokenStream, Span};
24use crate::r#type::common::*;
25
26pub mod section_0 {
27    use super::*;
28    use crate::r#type::instruction::setp::section_0::*;
29
30    // ============================================================================
31    // Generated enum parsers
32    // ============================================================================
33
34    impl PtxParser for Boolop {
35        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
36            // Try And
37            {
38                let saved_pos = stream.position();
39                if stream.expect_string(".and").is_ok() {
40                    return Ok(Boolop::And);
41                }
42                stream.set_position(saved_pos);
43            }
44            let saved_pos = stream.position();
45            // Try Xor
46            {
47                let saved_pos = stream.position();
48                if stream.expect_string(".xor").is_ok() {
49                    return Ok(Boolop::Xor);
50                }
51                stream.set_position(saved_pos);
52            }
53            stream.set_position(saved_pos);
54            let saved_pos = stream.position();
55            // Try Or
56            {
57                let saved_pos = stream.position();
58                if stream.expect_string(".or").is_ok() {
59                    return Ok(Boolop::Or);
60                }
61                stream.set_position(saved_pos);
62            }
63            stream.set_position(saved_pos);
64            let span = stream
65                .peek()
66                .map(|(_, s)| s.clone())
67                .unwrap_or(Span { start: 0, end: 0 });
68            let expected = &[".and", ".xor", ".or"];
69            let found = stream
70                .peek()
71                .map(|(t, _)| format!("{:?}", t))
72                .unwrap_or_else(|_| "<end of input>".to_string());
73            Err(crate::parser::unexpected_value(span, expected, found))
74        }
75    }
76
77    impl PtxParser for Cmpop {
78        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
79            // Try Equ
80            {
81                let saved_pos = stream.position();
82                if stream.expect_string(".equ").is_ok() {
83                    return Ok(Cmpop::Equ);
84                }
85                stream.set_position(saved_pos);
86            }
87            let saved_pos = stream.position();
88            // Try Neu
89            {
90                let saved_pos = stream.position();
91                if stream.expect_string(".neu").is_ok() {
92                    return Ok(Cmpop::Neu);
93                }
94                stream.set_position(saved_pos);
95            }
96            stream.set_position(saved_pos);
97            let saved_pos = stream.position();
98            // Try Ltu
99            {
100                let saved_pos = stream.position();
101                if stream.expect_string(".ltu").is_ok() {
102                    return Ok(Cmpop::Ltu);
103                }
104                stream.set_position(saved_pos);
105            }
106            stream.set_position(saved_pos);
107            let saved_pos = stream.position();
108            // Try Leu
109            {
110                let saved_pos = stream.position();
111                if stream.expect_string(".leu").is_ok() {
112                    return Ok(Cmpop::Leu);
113                }
114                stream.set_position(saved_pos);
115            }
116            stream.set_position(saved_pos);
117            let saved_pos = stream.position();
118            // Try Gtu
119            {
120                let saved_pos = stream.position();
121                if stream.expect_string(".gtu").is_ok() {
122                    return Ok(Cmpop::Gtu);
123                }
124                stream.set_position(saved_pos);
125            }
126            stream.set_position(saved_pos);
127            let saved_pos = stream.position();
128            // Try Geu
129            {
130                let saved_pos = stream.position();
131                if stream.expect_string(".geu").is_ok() {
132                    return Ok(Cmpop::Geu);
133                }
134                stream.set_position(saved_pos);
135            }
136            stream.set_position(saved_pos);
137            let saved_pos = stream.position();
138            // Try Num
139            {
140                let saved_pos = stream.position();
141                if stream.expect_string(".num").is_ok() {
142                    return Ok(Cmpop::Num);
143                }
144                stream.set_position(saved_pos);
145            }
146            stream.set_position(saved_pos);
147            let saved_pos = stream.position();
148            // Try Nan
149            {
150                let saved_pos = stream.position();
151                if stream.expect_string(".nan").is_ok() {
152                    return Ok(Cmpop::Nan);
153                }
154                stream.set_position(saved_pos);
155            }
156            stream.set_position(saved_pos);
157            let saved_pos = stream.position();
158            // Try Eq
159            {
160                let saved_pos = stream.position();
161                if stream.expect_string(".eq").is_ok() {
162                    return Ok(Cmpop::Eq);
163                }
164                stream.set_position(saved_pos);
165            }
166            stream.set_position(saved_pos);
167            let saved_pos = stream.position();
168            // Try Ne
169            {
170                let saved_pos = stream.position();
171                if stream.expect_string(".ne").is_ok() {
172                    return Ok(Cmpop::Ne);
173                }
174                stream.set_position(saved_pos);
175            }
176            stream.set_position(saved_pos);
177            let saved_pos = stream.position();
178            // Try Lt
179            {
180                let saved_pos = stream.position();
181                if stream.expect_string(".lt").is_ok() {
182                    return Ok(Cmpop::Lt);
183                }
184                stream.set_position(saved_pos);
185            }
186            stream.set_position(saved_pos);
187            let saved_pos = stream.position();
188            // Try Le
189            {
190                let saved_pos = stream.position();
191                if stream.expect_string(".le").is_ok() {
192                    return Ok(Cmpop::Le);
193                }
194                stream.set_position(saved_pos);
195            }
196            stream.set_position(saved_pos);
197            let saved_pos = stream.position();
198            // Try Gt
199            {
200                let saved_pos = stream.position();
201                if stream.expect_string(".gt").is_ok() {
202                    return Ok(Cmpop::Gt);
203                }
204                stream.set_position(saved_pos);
205            }
206            stream.set_position(saved_pos);
207            let saved_pos = stream.position();
208            // Try Ge
209            {
210                let saved_pos = stream.position();
211                if stream.expect_string(".ge").is_ok() {
212                    return Ok(Cmpop::Ge);
213                }
214                stream.set_position(saved_pos);
215            }
216            stream.set_position(saved_pos);
217            let saved_pos = stream.position();
218            // Try Lo
219            {
220                let saved_pos = stream.position();
221                if stream.expect_string(".lo").is_ok() {
222                    return Ok(Cmpop::Lo);
223                }
224                stream.set_position(saved_pos);
225            }
226            stream.set_position(saved_pos);
227            let saved_pos = stream.position();
228            // Try Ls
229            {
230                let saved_pos = stream.position();
231                if stream.expect_string(".ls").is_ok() {
232                    return Ok(Cmpop::Ls);
233                }
234                stream.set_position(saved_pos);
235            }
236            stream.set_position(saved_pos);
237            let saved_pos = stream.position();
238            // Try Hi
239            {
240                let saved_pos = stream.position();
241                if stream.expect_string(".hi").is_ok() {
242                    return Ok(Cmpop::Hi);
243                }
244                stream.set_position(saved_pos);
245            }
246            stream.set_position(saved_pos);
247            let saved_pos = stream.position();
248            // Try Hs
249            {
250                let saved_pos = stream.position();
251                if stream.expect_string(".hs").is_ok() {
252                    return Ok(Cmpop::Hs);
253                }
254                stream.set_position(saved_pos);
255            }
256            stream.set_position(saved_pos);
257            let span = stream
258                .peek()
259                .map(|(_, s)| s.clone())
260                .unwrap_or(Span { start: 0, end: 0 });
261            let expected = &[
262                ".equ", ".neu", ".ltu", ".leu", ".gtu", ".geu", ".num", ".nan", ".eq", ".ne",
263                ".lt", ".le", ".gt", ".ge", ".lo", ".ls", ".hi", ".hs",
264            ];
265            let found = stream
266                .peek()
267                .map(|(t, _)| format!("{:?}", t))
268                .unwrap_or_else(|_| "<end of input>".to_string());
269            Err(crate::parser::unexpected_value(span, expected, found))
270        }
271    }
272
273    impl PtxParser for Type {
274        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
275            // Try B16
276            {
277                let saved_pos = stream.position();
278                if stream.expect_string(".b16").is_ok() {
279                    return Ok(Type::B16);
280                }
281                stream.set_position(saved_pos);
282            }
283            let saved_pos = stream.position();
284            // Try B32
285            {
286                let saved_pos = stream.position();
287                if stream.expect_string(".b32").is_ok() {
288                    return Ok(Type::B32);
289                }
290                stream.set_position(saved_pos);
291            }
292            stream.set_position(saved_pos);
293            let saved_pos = stream.position();
294            // Try B64
295            {
296                let saved_pos = stream.position();
297                if stream.expect_string(".b64").is_ok() {
298                    return Ok(Type::B64);
299                }
300                stream.set_position(saved_pos);
301            }
302            stream.set_position(saved_pos);
303            let saved_pos = stream.position();
304            // Try U16
305            {
306                let saved_pos = stream.position();
307                if stream.expect_string(".u16").is_ok() {
308                    return Ok(Type::U16);
309                }
310                stream.set_position(saved_pos);
311            }
312            stream.set_position(saved_pos);
313            let saved_pos = stream.position();
314            // Try U32
315            {
316                let saved_pos = stream.position();
317                if stream.expect_string(".u32").is_ok() {
318                    return Ok(Type::U32);
319                }
320                stream.set_position(saved_pos);
321            }
322            stream.set_position(saved_pos);
323            let saved_pos = stream.position();
324            // Try U64
325            {
326                let saved_pos = stream.position();
327                if stream.expect_string(".u64").is_ok() {
328                    return Ok(Type::U64);
329                }
330                stream.set_position(saved_pos);
331            }
332            stream.set_position(saved_pos);
333            let saved_pos = stream.position();
334            // Try S16
335            {
336                let saved_pos = stream.position();
337                if stream.expect_string(".s16").is_ok() {
338                    return Ok(Type::S16);
339                }
340                stream.set_position(saved_pos);
341            }
342            stream.set_position(saved_pos);
343            let saved_pos = stream.position();
344            // Try S32
345            {
346                let saved_pos = stream.position();
347                if stream.expect_string(".s32").is_ok() {
348                    return Ok(Type::S32);
349                }
350                stream.set_position(saved_pos);
351            }
352            stream.set_position(saved_pos);
353            let saved_pos = stream.position();
354            // Try S64
355            {
356                let saved_pos = stream.position();
357                if stream.expect_string(".s64").is_ok() {
358                    return Ok(Type::S64);
359                }
360                stream.set_position(saved_pos);
361            }
362            stream.set_position(saved_pos);
363            let saved_pos = stream.position();
364            // Try F32
365            {
366                let saved_pos = stream.position();
367                if stream.expect_string(".f32").is_ok() {
368                    return Ok(Type::F32);
369                }
370                stream.set_position(saved_pos);
371            }
372            stream.set_position(saved_pos);
373            let saved_pos = stream.position();
374            // Try F64
375            {
376                let saved_pos = stream.position();
377                if stream.expect_string(".f64").is_ok() {
378                    return Ok(Type::F64);
379                }
380                stream.set_position(saved_pos);
381            }
382            stream.set_position(saved_pos);
383            let span = stream
384                .peek()
385                .map(|(_, s)| s.clone())
386                .unwrap_or(Span { start: 0, end: 0 });
387            let expected = &[
388                ".b16", ".b32", ".b64", ".u16", ".u32", ".u64", ".s16", ".s32", ".s64", ".f32",
389                ".f64",
390            ];
391            let found = stream
392                .peek()
393                .map(|(t, _)| format!("{:?}", t))
394                .unwrap_or_else(|_| "<end of input>".to_string());
395            Err(crate::parser::unexpected_value(span, expected, found))
396        }
397    }
398
399    impl PtxParser for SetpCmpopFtzType {
400        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
401            stream.expect_string("setp")?;
402            let cmpop = Cmpop::parse(stream)?;
403            stream.expect_complete()?;
404            let saved_pos = stream.position();
405            let ftz = stream.expect_string(".ftz").is_ok();
406            if !ftz {
407                stream.set_position(saved_pos);
408            }
409            stream.expect_complete()?;
410            let type_ = Type::parse(stream)?;
411            stream.expect_complete()?;
412            let p = GeneralOperand::parse(stream)?;
413            let saved_pos = stream.position();
414            let q = if stream.consume_if(|t| matches!(t, PtxToken::Pipe)).is_some() {
415                Some(GeneralOperand::parse(stream)?)
416            } else {
417                stream.set_position(saved_pos);
418                None
419            };
420            stream.expect_complete()?;
421            stream.expect(&PtxToken::Comma)?;
422            let a = GeneralOperand::parse(stream)?;
423            stream.expect_complete()?;
424            stream.expect(&PtxToken::Comma)?;
425            let b = GeneralOperand::parse(stream)?;
426            stream.expect_complete()?;
427            stream.expect_complete()?;
428            stream.expect(&PtxToken::Semicolon)?;
429            Ok(SetpCmpopFtzType {
430                cmpop,
431                ftz,
432                type_,
433                p,
434                q,
435                a,
436                b,
437            })
438        }
439    }
440
441    impl PtxParser for SetpCmpopBoolopFtzType {
442        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
443            stream.expect_string("setp")?;
444            let cmpop = Cmpop::parse(stream)?;
445            stream.expect_complete()?;
446            let boolop = Boolop::parse(stream)?;
447            stream.expect_complete()?;
448            let saved_pos = stream.position();
449            let ftz = stream.expect_string(".ftz").is_ok();
450            if !ftz {
451                stream.set_position(saved_pos);
452            }
453            stream.expect_complete()?;
454            let type_ = Type::parse(stream)?;
455            stream.expect_complete()?;
456            let p = GeneralOperand::parse(stream)?;
457            let saved_pos = stream.position();
458            let q = if stream.consume_if(|t| matches!(t, PtxToken::Pipe)).is_some() {
459                Some(GeneralOperand::parse(stream)?)
460            } else {
461                stream.set_position(saved_pos);
462                None
463            };
464            stream.expect_complete()?;
465            stream.expect(&PtxToken::Comma)?;
466            let a = GeneralOperand::parse(stream)?;
467            stream.expect_complete()?;
468            stream.expect(&PtxToken::Comma)?;
469            let b = GeneralOperand::parse(stream)?;
470            stream.expect_complete()?;
471            stream.expect(&PtxToken::Comma)?;
472            let c_op = stream
473                .consume_if(|t| matches!(t, PtxToken::Exclaim))
474                .is_some();
475            let c = GeneralOperand::parse(stream)?;
476            stream.expect_complete()?;
477            stream.expect_complete()?;
478            stream.expect(&PtxToken::Semicolon)?;
479            Ok(SetpCmpopBoolopFtzType {
480                cmpop,
481                boolop,
482                ftz,
483                type_,
484                p,
485                q,
486                a,
487                b,
488                c_op,
489                c,
490            })
491        }
492    }
493}
494
495pub mod section_1 {
496    use super::*;
497    use crate::r#type::instruction::setp::section_1::*;
498
499    // ============================================================================
500    // Generated enum parsers
501    // ============================================================================
502
503    impl PtxParser for Boolop {
504        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
505            // Try And
506            {
507                let saved_pos = stream.position();
508                if stream.expect_string(".and").is_ok() {
509                    return Ok(Boolop::And);
510                }
511                stream.set_position(saved_pos);
512            }
513            let saved_pos = stream.position();
514            // Try Xor
515            {
516                let saved_pos = stream.position();
517                if stream.expect_string(".xor").is_ok() {
518                    return Ok(Boolop::Xor);
519                }
520                stream.set_position(saved_pos);
521            }
522            stream.set_position(saved_pos);
523            let saved_pos = stream.position();
524            // Try Or
525            {
526                let saved_pos = stream.position();
527                if stream.expect_string(".or").is_ok() {
528                    return Ok(Boolop::Or);
529                }
530                stream.set_position(saved_pos);
531            }
532            stream.set_position(saved_pos);
533            let span = stream
534                .peek()
535                .map(|(_, s)| s.clone())
536                .unwrap_or(Span { start: 0, end: 0 });
537            let expected = &[".and", ".xor", ".or"];
538            let found = stream
539                .peek()
540                .map(|(t, _)| format!("{:?}", t))
541                .unwrap_or_else(|_| "<end of input>".to_string());
542            Err(crate::parser::unexpected_value(span, expected, found))
543        }
544    }
545
546    impl PtxParser for Cmpop {
547        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
548            // Try Equ
549            {
550                let saved_pos = stream.position();
551                if stream.expect_string(".equ").is_ok() {
552                    return Ok(Cmpop::Equ);
553                }
554                stream.set_position(saved_pos);
555            }
556            let saved_pos = stream.position();
557            // Try Neu
558            {
559                let saved_pos = stream.position();
560                if stream.expect_string(".neu").is_ok() {
561                    return Ok(Cmpop::Neu);
562                }
563                stream.set_position(saved_pos);
564            }
565            stream.set_position(saved_pos);
566            let saved_pos = stream.position();
567            // Try Ltu
568            {
569                let saved_pos = stream.position();
570                if stream.expect_string(".ltu").is_ok() {
571                    return Ok(Cmpop::Ltu);
572                }
573                stream.set_position(saved_pos);
574            }
575            stream.set_position(saved_pos);
576            let saved_pos = stream.position();
577            // Try Leu
578            {
579                let saved_pos = stream.position();
580                if stream.expect_string(".leu").is_ok() {
581                    return Ok(Cmpop::Leu);
582                }
583                stream.set_position(saved_pos);
584            }
585            stream.set_position(saved_pos);
586            let saved_pos = stream.position();
587            // Try Gtu
588            {
589                let saved_pos = stream.position();
590                if stream.expect_string(".gtu").is_ok() {
591                    return Ok(Cmpop::Gtu);
592                }
593                stream.set_position(saved_pos);
594            }
595            stream.set_position(saved_pos);
596            let saved_pos = stream.position();
597            // Try Geu
598            {
599                let saved_pos = stream.position();
600                if stream.expect_string(".geu").is_ok() {
601                    return Ok(Cmpop::Geu);
602                }
603                stream.set_position(saved_pos);
604            }
605            stream.set_position(saved_pos);
606            let saved_pos = stream.position();
607            // Try Num
608            {
609                let saved_pos = stream.position();
610                if stream.expect_string(".num").is_ok() {
611                    return Ok(Cmpop::Num);
612                }
613                stream.set_position(saved_pos);
614            }
615            stream.set_position(saved_pos);
616            let saved_pos = stream.position();
617            // Try Nan
618            {
619                let saved_pos = stream.position();
620                if stream.expect_string(".nan").is_ok() {
621                    return Ok(Cmpop::Nan);
622                }
623                stream.set_position(saved_pos);
624            }
625            stream.set_position(saved_pos);
626            let saved_pos = stream.position();
627            // Try Eq
628            {
629                let saved_pos = stream.position();
630                if stream.expect_string(".eq").is_ok() {
631                    return Ok(Cmpop::Eq);
632                }
633                stream.set_position(saved_pos);
634            }
635            stream.set_position(saved_pos);
636            let saved_pos = stream.position();
637            // Try Ne
638            {
639                let saved_pos = stream.position();
640                if stream.expect_string(".ne").is_ok() {
641                    return Ok(Cmpop::Ne);
642                }
643                stream.set_position(saved_pos);
644            }
645            stream.set_position(saved_pos);
646            let saved_pos = stream.position();
647            // Try Lt
648            {
649                let saved_pos = stream.position();
650                if stream.expect_string(".lt").is_ok() {
651                    return Ok(Cmpop::Lt);
652                }
653                stream.set_position(saved_pos);
654            }
655            stream.set_position(saved_pos);
656            let saved_pos = stream.position();
657            // Try Le
658            {
659                let saved_pos = stream.position();
660                if stream.expect_string(".le").is_ok() {
661                    return Ok(Cmpop::Le);
662                }
663                stream.set_position(saved_pos);
664            }
665            stream.set_position(saved_pos);
666            let saved_pos = stream.position();
667            // Try Gt
668            {
669                let saved_pos = stream.position();
670                if stream.expect_string(".gt").is_ok() {
671                    return Ok(Cmpop::Gt);
672                }
673                stream.set_position(saved_pos);
674            }
675            stream.set_position(saved_pos);
676            let saved_pos = stream.position();
677            // Try Ge
678            {
679                let saved_pos = stream.position();
680                if stream.expect_string(".ge").is_ok() {
681                    return Ok(Cmpop::Ge);
682                }
683                stream.set_position(saved_pos);
684            }
685            stream.set_position(saved_pos);
686            let span = stream
687                .peek()
688                .map(|(_, s)| s.clone())
689                .unwrap_or(Span { start: 0, end: 0 });
690            let expected = &[
691                ".equ", ".neu", ".ltu", ".leu", ".gtu", ".geu", ".num", ".nan", ".eq", ".ne",
692                ".lt", ".le", ".gt", ".ge",
693            ];
694            let found = stream
695                .peek()
696                .map(|(t, _)| format!("{:?}", t))
697                .unwrap_or_else(|_| "<end of input>".to_string());
698            Err(crate::parser::unexpected_value(span, expected, found))
699        }
700    }
701
702    impl PtxParser for SetpCmpopFtzF16 {
703        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
704            stream.expect_string("setp")?;
705            let cmpop = Cmpop::parse(stream)?;
706            stream.expect_complete()?;
707            let saved_pos = stream.position();
708            let ftz = stream.expect_string(".ftz").is_ok();
709            if !ftz {
710                stream.set_position(saved_pos);
711            }
712            stream.expect_complete()?;
713            stream.expect_string(".f16")?;
714            let f16 = ();
715            stream.expect_complete()?;
716            let p = GeneralOperand::parse(stream)?;
717            stream.expect_complete()?;
718            stream.expect(&PtxToken::Comma)?;
719            let a = GeneralOperand::parse(stream)?;
720            stream.expect_complete()?;
721            stream.expect(&PtxToken::Comma)?;
722            let b = GeneralOperand::parse(stream)?;
723            stream.expect_complete()?;
724            stream.expect_complete()?;
725            stream.expect(&PtxToken::Semicolon)?;
726            Ok(SetpCmpopFtzF16 {
727                cmpop,
728                ftz,
729                f16,
730                p,
731                a,
732                b,
733            })
734        }
735    }
736
737    impl PtxParser for SetpCmpopBoolopFtzF16 {
738        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
739            stream.expect_string("setp")?;
740            let cmpop = Cmpop::parse(stream)?;
741            stream.expect_complete()?;
742            let boolop = Boolop::parse(stream)?;
743            stream.expect_complete()?;
744            let saved_pos = stream.position();
745            let ftz = stream.expect_string(".ftz").is_ok();
746            if !ftz {
747                stream.set_position(saved_pos);
748            }
749            stream.expect_complete()?;
750            stream.expect_string(".f16")?;
751            let f16 = ();
752            stream.expect_complete()?;
753            let p = GeneralOperand::parse(stream)?;
754            stream.expect_complete()?;
755            stream.expect(&PtxToken::Comma)?;
756            let a = GeneralOperand::parse(stream)?;
757            stream.expect_complete()?;
758            stream.expect(&PtxToken::Comma)?;
759            let b = GeneralOperand::parse(stream)?;
760            stream.expect_complete()?;
761            stream.expect(&PtxToken::Comma)?;
762            let c_op = stream
763                .consume_if(|t| matches!(t, PtxToken::Exclaim))
764                .is_some();
765            let c = GeneralOperand::parse(stream)?;
766            stream.expect_complete()?;
767            stream.expect_complete()?;
768            stream.expect(&PtxToken::Semicolon)?;
769            Ok(SetpCmpopBoolopFtzF16 {
770                cmpop,
771                boolop,
772                ftz,
773                f16,
774                p,
775                a,
776                b,
777                c_op,
778                c,
779            })
780        }
781    }
782
783    impl PtxParser for SetpCmpopFtzF16x2 {
784        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
785            stream.expect_string("setp")?;
786            let cmpop = Cmpop::parse(stream)?;
787            stream.expect_complete()?;
788            let saved_pos = stream.position();
789            let ftz = stream.expect_string(".ftz").is_ok();
790            if !ftz {
791                stream.set_position(saved_pos);
792            }
793            stream.expect_complete()?;
794            stream.expect_string(".f16x2")?;
795            let f16x2 = ();
796            stream.expect_complete()?;
797            let p = GeneralOperand::parse(stream)?;
798            stream.expect(&PtxToken::Pipe)?;
799            let q = GeneralOperand::parse(stream)?;
800            stream.expect_complete()?;
801            stream.expect(&PtxToken::Comma)?;
802            let a = GeneralOperand::parse(stream)?;
803            stream.expect_complete()?;
804            stream.expect(&PtxToken::Comma)?;
805            let b = GeneralOperand::parse(stream)?;
806            stream.expect_complete()?;
807            stream.expect_complete()?;
808            stream.expect(&PtxToken::Semicolon)?;
809            Ok(SetpCmpopFtzF16x2 {
810                cmpop,
811                ftz,
812                f16x2,
813                p,
814                q,
815                a,
816                b,
817            })
818        }
819    }
820
821    impl PtxParser for SetpCmpopBoolopFtzF16x2 {
822        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
823            stream.expect_string("setp")?;
824            let cmpop = Cmpop::parse(stream)?;
825            stream.expect_complete()?;
826            let boolop = Boolop::parse(stream)?;
827            stream.expect_complete()?;
828            let saved_pos = stream.position();
829            let ftz = stream.expect_string(".ftz").is_ok();
830            if !ftz {
831                stream.set_position(saved_pos);
832            }
833            stream.expect_complete()?;
834            stream.expect_string(".f16x2")?;
835            let f16x2 = ();
836            stream.expect_complete()?;
837            let p = GeneralOperand::parse(stream)?;
838            stream.expect(&PtxToken::Pipe)?;
839            let q = GeneralOperand::parse(stream)?;
840            stream.expect_complete()?;
841            stream.expect(&PtxToken::Comma)?;
842            let a = GeneralOperand::parse(stream)?;
843            stream.expect_complete()?;
844            stream.expect(&PtxToken::Comma)?;
845            let b = GeneralOperand::parse(stream)?;
846            stream.expect_complete()?;
847            stream.expect(&PtxToken::Comma)?;
848            let c_op = stream
849                .consume_if(|t| matches!(t, PtxToken::Exclaim))
850                .is_some();
851            let c = GeneralOperand::parse(stream)?;
852            stream.expect_complete()?;
853            stream.expect_complete()?;
854            stream.expect(&PtxToken::Semicolon)?;
855            Ok(SetpCmpopBoolopFtzF16x2 {
856                cmpop,
857                boolop,
858                ftz,
859                f16x2,
860                p,
861                q,
862                a,
863                b,
864                c_op,
865                c,
866            })
867        }
868    }
869
870    impl PtxParser for SetpCmpopBf16 {
871        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
872            stream.expect_string("setp")?;
873            let cmpop = Cmpop::parse(stream)?;
874            stream.expect_complete()?;
875            stream.expect_string(".bf16")?;
876            let bf16 = ();
877            stream.expect_complete()?;
878            let p = GeneralOperand::parse(stream)?;
879            stream.expect_complete()?;
880            stream.expect(&PtxToken::Comma)?;
881            let a = GeneralOperand::parse(stream)?;
882            stream.expect_complete()?;
883            stream.expect(&PtxToken::Comma)?;
884            let b = GeneralOperand::parse(stream)?;
885            stream.expect_complete()?;
886            stream.expect_complete()?;
887            stream.expect(&PtxToken::Semicolon)?;
888            Ok(SetpCmpopBf16 {
889                cmpop,
890                bf16,
891                p,
892                a,
893                b,
894            })
895        }
896    }
897
898    impl PtxParser for SetpCmpopBoolopBf16 {
899        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
900            stream.expect_string("setp")?;
901            let cmpop = Cmpop::parse(stream)?;
902            stream.expect_complete()?;
903            let boolop = Boolop::parse(stream)?;
904            stream.expect_complete()?;
905            stream.expect_string(".bf16")?;
906            let bf16 = ();
907            stream.expect_complete()?;
908            let p = GeneralOperand::parse(stream)?;
909            stream.expect_complete()?;
910            stream.expect(&PtxToken::Comma)?;
911            let a = GeneralOperand::parse(stream)?;
912            stream.expect_complete()?;
913            stream.expect(&PtxToken::Comma)?;
914            let b = GeneralOperand::parse(stream)?;
915            stream.expect_complete()?;
916            stream.expect(&PtxToken::Comma)?;
917            let c_op = stream
918                .consume_if(|t| matches!(t, PtxToken::Exclaim))
919                .is_some();
920            let c = GeneralOperand::parse(stream)?;
921            stream.expect_complete()?;
922            stream.expect_complete()?;
923            stream.expect(&PtxToken::Semicolon)?;
924            Ok(SetpCmpopBoolopBf16 {
925                cmpop,
926                boolop,
927                bf16,
928                p,
929                a,
930                b,
931                c_op,
932                c,
933            })
934        }
935    }
936
937    impl PtxParser for SetpCmpopBf16x2 {
938        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
939            stream.expect_string("setp")?;
940            let cmpop = Cmpop::parse(stream)?;
941            stream.expect_complete()?;
942            stream.expect_string(".bf16x2")?;
943            let bf16x2 = ();
944            stream.expect_complete()?;
945            let p = GeneralOperand::parse(stream)?;
946            stream.expect(&PtxToken::Pipe)?;
947            let q = GeneralOperand::parse(stream)?;
948            stream.expect_complete()?;
949            stream.expect(&PtxToken::Comma)?;
950            let a = GeneralOperand::parse(stream)?;
951            stream.expect_complete()?;
952            stream.expect(&PtxToken::Comma)?;
953            let b = GeneralOperand::parse(stream)?;
954            stream.expect_complete()?;
955            stream.expect_complete()?;
956            stream.expect(&PtxToken::Semicolon)?;
957            Ok(SetpCmpopBf16x2 {
958                cmpop,
959                bf16x2,
960                p,
961                q,
962                a,
963                b,
964            })
965        }
966    }
967
968    impl PtxParser for SetpCmpopBoolopBf16x2 {
969        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
970            stream.expect_string("setp")?;
971            let cmpop = Cmpop::parse(stream)?;
972            stream.expect_complete()?;
973            let boolop = Boolop::parse(stream)?;
974            stream.expect_complete()?;
975            stream.expect_string(".bf16x2")?;
976            let bf16x2 = ();
977            stream.expect_complete()?;
978            let p = GeneralOperand::parse(stream)?;
979            stream.expect(&PtxToken::Pipe)?;
980            let q = GeneralOperand::parse(stream)?;
981            stream.expect_complete()?;
982            stream.expect(&PtxToken::Comma)?;
983            let a = GeneralOperand::parse(stream)?;
984            stream.expect_complete()?;
985            stream.expect(&PtxToken::Comma)?;
986            let b = GeneralOperand::parse(stream)?;
987            stream.expect_complete()?;
988            stream.expect(&PtxToken::Comma)?;
989            let c_op = stream
990                .consume_if(|t| matches!(t, PtxToken::Exclaim))
991                .is_some();
992            let c = GeneralOperand::parse(stream)?;
993            stream.expect_complete()?;
994            stream.expect_complete()?;
995            stream.expect(&PtxToken::Semicolon)?;
996            Ok(SetpCmpopBoolopBf16x2 {
997                cmpop,
998                boolop,
999                bf16x2,
1000                p,
1001                q,
1002                a,
1003                b,
1004                c_op,
1005                c,
1006            })
1007        }
1008    }
1009}
ptx_parser/parser/instruction/setp.rs

ptx_parser/parser/instruction/
setp.rs
