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

ptx_parser/parser/instruction/
setp.rs
