ptx_parser/parser/instruction/
vop.rs

1//! Original PTX specification:
2//!
3//! // 32-bit scalar operation, with optional secondary operation
4//! vop.dtype.atype.btype{.sat}       d, a{.asel}, b{.bsel};
5//! vop.dtype.atype.btype{.sat}.op2   d, a{.asel}, b{.bsel}, c;
6//! // 32-bit scalar operation, with optional data merge
7//! vop.dtype.atype.btype{.sat}  d.dsel, a{.asel}, b{.bsel}, c;
8//! vop   = { vadd, vsub, vabsdiff, vmin, vmax };
9//! .dtype = .atype = .btype = { .u32, .s32 };
10//! .dsel  = .asel  = .bsel  = { .b0, .b1, .b2, .b3, .h0, .h1 };
11//! .op2   = { .add, .min, .max };
12
13#![allow(unused)]
14
15use crate::lexer::PtxToken;
16use crate::parser::{PtxParseError, PtxParser, PtxTokenStream, Span};
17use crate::r#type::common::*;
18
19pub mod section_0 {
20    use super::*;
21    use crate::r#type::instruction::vop::section_0::*;
22
23    // ============================================================================
24    // Generated enum parsers
25    // ============================================================================
26
27    impl PtxParser for Asel {
28        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
29            // Try B0
30            {
31                let saved_pos = stream.position();
32                if stream.expect_string(".b0").is_ok() {
33                    return Ok(Asel::B0);
34                }
35                stream.set_position(saved_pos);
36            }
37            let saved_pos = stream.position();
38            // Try B1
39            {
40                let saved_pos = stream.position();
41                if stream.expect_string(".b1").is_ok() {
42                    return Ok(Asel::B1);
43                }
44                stream.set_position(saved_pos);
45            }
46            stream.set_position(saved_pos);
47            let saved_pos = stream.position();
48            // Try B2
49            {
50                let saved_pos = stream.position();
51                if stream.expect_string(".b2").is_ok() {
52                    return Ok(Asel::B2);
53                }
54                stream.set_position(saved_pos);
55            }
56            stream.set_position(saved_pos);
57            let saved_pos = stream.position();
58            // Try B3
59            {
60                let saved_pos = stream.position();
61                if stream.expect_string(".b3").is_ok() {
62                    return Ok(Asel::B3);
63                }
64                stream.set_position(saved_pos);
65            }
66            stream.set_position(saved_pos);
67            let saved_pos = stream.position();
68            // Try H0
69            {
70                let saved_pos = stream.position();
71                if stream.expect_string(".h0").is_ok() {
72                    return Ok(Asel::H0);
73                }
74                stream.set_position(saved_pos);
75            }
76            stream.set_position(saved_pos);
77            let saved_pos = stream.position();
78            // Try H1
79            {
80                let saved_pos = stream.position();
81                if stream.expect_string(".h1").is_ok() {
82                    return Ok(Asel::H1);
83                }
84                stream.set_position(saved_pos);
85            }
86            stream.set_position(saved_pos);
87            let span = stream
88                .peek()
89                .map(|(_, s)| s.clone())
90                .unwrap_or(Span { start: 0, end: 0 });
91            let expected = &[".b0", ".b1", ".b2", ".b3", ".h0", ".h1"];
92            let found = stream
93                .peek()
94                .map(|(t, _)| format!("{:?}", t))
95                .unwrap_or_else(|_| "<end of input>".to_string());
96            Err(crate::parser::unexpected_value(span, expected, found))
97        }
98    }
99
100    impl PtxParser for Atype {
101        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
102            // Try U32
103            {
104                let saved_pos = stream.position();
105                if stream.expect_string(".u32").is_ok() {
106                    return Ok(Atype::U32);
107                }
108                stream.set_position(saved_pos);
109            }
110            let saved_pos = stream.position();
111            // Try S32
112            {
113                let saved_pos = stream.position();
114                if stream.expect_string(".s32").is_ok() {
115                    return Ok(Atype::S32);
116                }
117                stream.set_position(saved_pos);
118            }
119            stream.set_position(saved_pos);
120            let span = stream
121                .peek()
122                .map(|(_, s)| s.clone())
123                .unwrap_or(Span { start: 0, end: 0 });
124            let expected = &[".u32", ".s32"];
125            let found = stream
126                .peek()
127                .map(|(t, _)| format!("{:?}", t))
128                .unwrap_or_else(|_| "<end of input>".to_string());
129            Err(crate::parser::unexpected_value(span, expected, found))
130        }
131    }
132
133    impl PtxParser for Bsel {
134        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
135            // Try B0
136            {
137                let saved_pos = stream.position();
138                if stream.expect_string(".b0").is_ok() {
139                    return Ok(Bsel::B0);
140                }
141                stream.set_position(saved_pos);
142            }
143            let saved_pos = stream.position();
144            // Try B1
145            {
146                let saved_pos = stream.position();
147                if stream.expect_string(".b1").is_ok() {
148                    return Ok(Bsel::B1);
149                }
150                stream.set_position(saved_pos);
151            }
152            stream.set_position(saved_pos);
153            let saved_pos = stream.position();
154            // Try B2
155            {
156                let saved_pos = stream.position();
157                if stream.expect_string(".b2").is_ok() {
158                    return Ok(Bsel::B2);
159                }
160                stream.set_position(saved_pos);
161            }
162            stream.set_position(saved_pos);
163            let saved_pos = stream.position();
164            // Try B3
165            {
166                let saved_pos = stream.position();
167                if stream.expect_string(".b3").is_ok() {
168                    return Ok(Bsel::B3);
169                }
170                stream.set_position(saved_pos);
171            }
172            stream.set_position(saved_pos);
173            let saved_pos = stream.position();
174            // Try H0
175            {
176                let saved_pos = stream.position();
177                if stream.expect_string(".h0").is_ok() {
178                    return Ok(Bsel::H0);
179                }
180                stream.set_position(saved_pos);
181            }
182            stream.set_position(saved_pos);
183            let saved_pos = stream.position();
184            // Try H1
185            {
186                let saved_pos = stream.position();
187                if stream.expect_string(".h1").is_ok() {
188                    return Ok(Bsel::H1);
189                }
190                stream.set_position(saved_pos);
191            }
192            stream.set_position(saved_pos);
193            let span = stream
194                .peek()
195                .map(|(_, s)| s.clone())
196                .unwrap_or(Span { start: 0, end: 0 });
197            let expected = &[".b0", ".b1", ".b2", ".b3", ".h0", ".h1"];
198            let found = stream
199                .peek()
200                .map(|(t, _)| format!("{:?}", t))
201                .unwrap_or_else(|_| "<end of input>".to_string());
202            Err(crate::parser::unexpected_value(span, expected, found))
203        }
204    }
205
206    impl PtxParser for Btype {
207        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
208            // Try U32
209            {
210                let saved_pos = stream.position();
211                if stream.expect_string(".u32").is_ok() {
212                    return Ok(Btype::U32);
213                }
214                stream.set_position(saved_pos);
215            }
216            let saved_pos = stream.position();
217            // Try S32
218            {
219                let saved_pos = stream.position();
220                if stream.expect_string(".s32").is_ok() {
221                    return Ok(Btype::S32);
222                }
223                stream.set_position(saved_pos);
224            }
225            stream.set_position(saved_pos);
226            let span = stream
227                .peek()
228                .map(|(_, s)| s.clone())
229                .unwrap_or(Span { start: 0, end: 0 });
230            let expected = &[".u32", ".s32"];
231            let found = stream
232                .peek()
233                .map(|(t, _)| format!("{:?}", t))
234                .unwrap_or_else(|_| "<end of input>".to_string());
235            Err(crate::parser::unexpected_value(span, expected, found))
236        }
237    }
238
239    impl PtxParser for Dsel {
240        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
241            // Try B0
242            {
243                let saved_pos = stream.position();
244                if stream.expect_string(".b0").is_ok() {
245                    return Ok(Dsel::B0);
246                }
247                stream.set_position(saved_pos);
248            }
249            let saved_pos = stream.position();
250            // Try B1
251            {
252                let saved_pos = stream.position();
253                if stream.expect_string(".b1").is_ok() {
254                    return Ok(Dsel::B1);
255                }
256                stream.set_position(saved_pos);
257            }
258            stream.set_position(saved_pos);
259            let saved_pos = stream.position();
260            // Try B2
261            {
262                let saved_pos = stream.position();
263                if stream.expect_string(".b2").is_ok() {
264                    return Ok(Dsel::B2);
265                }
266                stream.set_position(saved_pos);
267            }
268            stream.set_position(saved_pos);
269            let saved_pos = stream.position();
270            // Try B3
271            {
272                let saved_pos = stream.position();
273                if stream.expect_string(".b3").is_ok() {
274                    return Ok(Dsel::B3);
275                }
276                stream.set_position(saved_pos);
277            }
278            stream.set_position(saved_pos);
279            let saved_pos = stream.position();
280            // Try H0
281            {
282                let saved_pos = stream.position();
283                if stream.expect_string(".h0").is_ok() {
284                    return Ok(Dsel::H0);
285                }
286                stream.set_position(saved_pos);
287            }
288            stream.set_position(saved_pos);
289            let saved_pos = stream.position();
290            // Try H1
291            {
292                let saved_pos = stream.position();
293                if stream.expect_string(".h1").is_ok() {
294                    return Ok(Dsel::H1);
295                }
296                stream.set_position(saved_pos);
297            }
298            stream.set_position(saved_pos);
299            let span = stream
300                .peek()
301                .map(|(_, s)| s.clone())
302                .unwrap_or(Span { start: 0, end: 0 });
303            let expected = &[".b0", ".b1", ".b2", ".b3", ".h0", ".h1"];
304            let found = stream
305                .peek()
306                .map(|(t, _)| format!("{:?}", t))
307                .unwrap_or_else(|_| "<end of input>".to_string());
308            Err(crate::parser::unexpected_value(span, expected, found))
309        }
310    }
311
312    impl PtxParser for Dtype {
313        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
314            // Try U32
315            {
316                let saved_pos = stream.position();
317                if stream.expect_string(".u32").is_ok() {
318                    return Ok(Dtype::U32);
319                }
320                stream.set_position(saved_pos);
321            }
322            let saved_pos = stream.position();
323            // Try S32
324            {
325                let saved_pos = stream.position();
326                if stream.expect_string(".s32").is_ok() {
327                    return Ok(Dtype::S32);
328                }
329                stream.set_position(saved_pos);
330            }
331            stream.set_position(saved_pos);
332            let span = stream
333                .peek()
334                .map(|(_, s)| s.clone())
335                .unwrap_or(Span { start: 0, end: 0 });
336            let expected = &[".u32", ".s32"];
337            let found = stream
338                .peek()
339                .map(|(t, _)| format!("{:?}", t))
340                .unwrap_or_else(|_| "<end of input>".to_string());
341            Err(crate::parser::unexpected_value(span, expected, found))
342        }
343    }
344
345    impl PtxParser for Op2 {
346        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
347            // Try Add
348            {
349                let saved_pos = stream.position();
350                if stream.expect_string(".add").is_ok() {
351                    return Ok(Op2::Add);
352                }
353                stream.set_position(saved_pos);
354            }
355            let saved_pos = stream.position();
356            // Try Min
357            {
358                let saved_pos = stream.position();
359                if stream.expect_string(".min").is_ok() {
360                    return Ok(Op2::Min);
361                }
362                stream.set_position(saved_pos);
363            }
364            stream.set_position(saved_pos);
365            let saved_pos = stream.position();
366            // Try Max
367            {
368                let saved_pos = stream.position();
369                if stream.expect_string(".max").is_ok() {
370                    return Ok(Op2::Max);
371                }
372                stream.set_position(saved_pos);
373            }
374            stream.set_position(saved_pos);
375            let span = stream
376                .peek()
377                .map(|(_, s)| s.clone())
378                .unwrap_or(Span { start: 0, end: 0 });
379            let expected = &[".add", ".min", ".max"];
380            let found = stream
381                .peek()
382                .map(|(t, _)| format!("{:?}", t))
383                .unwrap_or_else(|_| "<end of input>".to_string());
384            Err(crate::parser::unexpected_value(span, expected, found))
385        }
386    }
387
388    impl PtxParser for VaddDtypeAtypeBtypeSat {
389        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
390            stream.expect_string("vadd")?;
391            let dtype = Dtype::parse(stream)?;
392            stream.expect_complete()?;
393            let atype = Atype::parse(stream)?;
394            stream.expect_complete()?;
395            let btype = Btype::parse(stream)?;
396            stream.expect_complete()?;
397            let saved_pos = stream.position();
398            let sat = stream.expect_string(".sat").is_ok();
399            if !sat {
400                stream.set_position(saved_pos);
401            }
402            stream.expect_complete()?;
403            let d = GeneralOperand::parse(stream)?;
404            stream.expect_complete()?;
405            stream.expect(&PtxToken::Comma)?;
406            let a = GeneralOperand::parse(stream)?;
407            let saved_pos = stream.position();
408            let asel = match Asel::parse(stream) {
409                Ok(val) => Some(val),
410                Err(_) => {
411                    stream.set_position(saved_pos);
412                    None
413                }
414            };
415            stream.expect_complete()?;
416            stream.expect(&PtxToken::Comma)?;
417            let b = GeneralOperand::parse(stream)?;
418            let saved_pos = stream.position();
419            let bsel = match Bsel::parse(stream) {
420                Ok(val) => Some(val),
421                Err(_) => {
422                    stream.set_position(saved_pos);
423                    None
424                }
425            };
426            stream.expect_complete()?;
427            stream.expect_complete()?;
428            stream.expect(&PtxToken::Semicolon)?;
429            Ok(VaddDtypeAtypeBtypeSat {
430                dtype,
431                atype,
432                btype,
433                sat,
434                d,
435                a,
436                asel,
437                b,
438                bsel,
439            })
440        }
441    }
442
443    impl PtxParser for VsubDtypeAtypeBtypeSat {
444        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
445            stream.expect_string("vsub")?;
446            let dtype = Dtype::parse(stream)?;
447            stream.expect_complete()?;
448            let atype = Atype::parse(stream)?;
449            stream.expect_complete()?;
450            let btype = Btype::parse(stream)?;
451            stream.expect_complete()?;
452            let saved_pos = stream.position();
453            let sat = stream.expect_string(".sat").is_ok();
454            if !sat {
455                stream.set_position(saved_pos);
456            }
457            stream.expect_complete()?;
458            let d = GeneralOperand::parse(stream)?;
459            stream.expect_complete()?;
460            stream.expect(&PtxToken::Comma)?;
461            let a = GeneralOperand::parse(stream)?;
462            let saved_pos = stream.position();
463            let asel = match Asel::parse(stream) {
464                Ok(val) => Some(val),
465                Err(_) => {
466                    stream.set_position(saved_pos);
467                    None
468                }
469            };
470            stream.expect_complete()?;
471            stream.expect(&PtxToken::Comma)?;
472            let b = GeneralOperand::parse(stream)?;
473            let saved_pos = stream.position();
474            let bsel = match Bsel::parse(stream) {
475                Ok(val) => Some(val),
476                Err(_) => {
477                    stream.set_position(saved_pos);
478                    None
479                }
480            };
481            stream.expect_complete()?;
482            stream.expect_complete()?;
483            stream.expect(&PtxToken::Semicolon)?;
484            Ok(VsubDtypeAtypeBtypeSat {
485                dtype,
486                atype,
487                btype,
488                sat,
489                d,
490                a,
491                asel,
492                b,
493                bsel,
494            })
495        }
496    }
497
498    impl PtxParser for VabsdiffDtypeAtypeBtypeSat {
499        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
500            stream.expect_string("vabsdiff")?;
501            let dtype = Dtype::parse(stream)?;
502            stream.expect_complete()?;
503            let atype = Atype::parse(stream)?;
504            stream.expect_complete()?;
505            let btype = Btype::parse(stream)?;
506            stream.expect_complete()?;
507            let saved_pos = stream.position();
508            let sat = stream.expect_string(".sat").is_ok();
509            if !sat {
510                stream.set_position(saved_pos);
511            }
512            stream.expect_complete()?;
513            let d = GeneralOperand::parse(stream)?;
514            stream.expect_complete()?;
515            stream.expect(&PtxToken::Comma)?;
516            let a = GeneralOperand::parse(stream)?;
517            let saved_pos = stream.position();
518            let asel = match Asel::parse(stream) {
519                Ok(val) => Some(val),
520                Err(_) => {
521                    stream.set_position(saved_pos);
522                    None
523                }
524            };
525            stream.expect_complete()?;
526            stream.expect(&PtxToken::Comma)?;
527            let b = GeneralOperand::parse(stream)?;
528            let saved_pos = stream.position();
529            let bsel = match Bsel::parse(stream) {
530                Ok(val) => Some(val),
531                Err(_) => {
532                    stream.set_position(saved_pos);
533                    None
534                }
535            };
536            stream.expect_complete()?;
537            stream.expect_complete()?;
538            stream.expect(&PtxToken::Semicolon)?;
539            Ok(VabsdiffDtypeAtypeBtypeSat {
540                dtype,
541                atype,
542                btype,
543                sat,
544                d,
545                a,
546                asel,
547                b,
548                bsel,
549            })
550        }
551    }
552
553    impl PtxParser for VminDtypeAtypeBtypeSat {
554        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
555            stream.expect_string("vmin")?;
556            let dtype = Dtype::parse(stream)?;
557            stream.expect_complete()?;
558            let atype = Atype::parse(stream)?;
559            stream.expect_complete()?;
560            let btype = Btype::parse(stream)?;
561            stream.expect_complete()?;
562            let saved_pos = stream.position();
563            let sat = stream.expect_string(".sat").is_ok();
564            if !sat {
565                stream.set_position(saved_pos);
566            }
567            stream.expect_complete()?;
568            let d = GeneralOperand::parse(stream)?;
569            stream.expect_complete()?;
570            stream.expect(&PtxToken::Comma)?;
571            let a = GeneralOperand::parse(stream)?;
572            let saved_pos = stream.position();
573            let asel = match Asel::parse(stream) {
574                Ok(val) => Some(val),
575                Err(_) => {
576                    stream.set_position(saved_pos);
577                    None
578                }
579            };
580            stream.expect_complete()?;
581            stream.expect(&PtxToken::Comma)?;
582            let b = GeneralOperand::parse(stream)?;
583            let saved_pos = stream.position();
584            let bsel = match Bsel::parse(stream) {
585                Ok(val) => Some(val),
586                Err(_) => {
587                    stream.set_position(saved_pos);
588                    None
589                }
590            };
591            stream.expect_complete()?;
592            stream.expect_complete()?;
593            stream.expect(&PtxToken::Semicolon)?;
594            Ok(VminDtypeAtypeBtypeSat {
595                dtype,
596                atype,
597                btype,
598                sat,
599                d,
600                a,
601                asel,
602                b,
603                bsel,
604            })
605        }
606    }
607
608    impl PtxParser for VmaxDtypeAtypeBtypeSat {
609        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
610            stream.expect_string("vmax")?;
611            let dtype = Dtype::parse(stream)?;
612            stream.expect_complete()?;
613            let atype = Atype::parse(stream)?;
614            stream.expect_complete()?;
615            let btype = Btype::parse(stream)?;
616            stream.expect_complete()?;
617            let saved_pos = stream.position();
618            let sat = stream.expect_string(".sat").is_ok();
619            if !sat {
620                stream.set_position(saved_pos);
621            }
622            stream.expect_complete()?;
623            let d = GeneralOperand::parse(stream)?;
624            stream.expect_complete()?;
625            stream.expect(&PtxToken::Comma)?;
626            let a = GeneralOperand::parse(stream)?;
627            let saved_pos = stream.position();
628            let asel = match Asel::parse(stream) {
629                Ok(val) => Some(val),
630                Err(_) => {
631                    stream.set_position(saved_pos);
632                    None
633                }
634            };
635            stream.expect_complete()?;
636            stream.expect(&PtxToken::Comma)?;
637            let b = GeneralOperand::parse(stream)?;
638            let saved_pos = stream.position();
639            let bsel = match Bsel::parse(stream) {
640                Ok(val) => Some(val),
641                Err(_) => {
642                    stream.set_position(saved_pos);
643                    None
644                }
645            };
646            stream.expect_complete()?;
647            stream.expect_complete()?;
648            stream.expect(&PtxToken::Semicolon)?;
649            Ok(VmaxDtypeAtypeBtypeSat {
650                dtype,
651                atype,
652                btype,
653                sat,
654                d,
655                a,
656                asel,
657                b,
658                bsel,
659            })
660        }
661    }
662
663    impl PtxParser for VaddDtypeAtypeBtypeSatOp2 {
664        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
665            stream.expect_string("vadd")?;
666            let dtype = Dtype::parse(stream)?;
667            stream.expect_complete()?;
668            let atype = Atype::parse(stream)?;
669            stream.expect_complete()?;
670            let btype = Btype::parse(stream)?;
671            stream.expect_complete()?;
672            let saved_pos = stream.position();
673            let sat = stream.expect_string(".sat").is_ok();
674            if !sat {
675                stream.set_position(saved_pos);
676            }
677            stream.expect_complete()?;
678            let op2 = Op2::parse(stream)?;
679            stream.expect_complete()?;
680            let d = GeneralOperand::parse(stream)?;
681            stream.expect_complete()?;
682            stream.expect(&PtxToken::Comma)?;
683            let a = GeneralOperand::parse(stream)?;
684            let saved_pos = stream.position();
685            let asel = match Asel::parse(stream) {
686                Ok(val) => Some(val),
687                Err(_) => {
688                    stream.set_position(saved_pos);
689                    None
690                }
691            };
692            stream.expect_complete()?;
693            stream.expect(&PtxToken::Comma)?;
694            let b = GeneralOperand::parse(stream)?;
695            let saved_pos = stream.position();
696            let bsel = match Bsel::parse(stream) {
697                Ok(val) => Some(val),
698                Err(_) => {
699                    stream.set_position(saved_pos);
700                    None
701                }
702            };
703            stream.expect_complete()?;
704            stream.expect(&PtxToken::Comma)?;
705            let c = GeneralOperand::parse(stream)?;
706            stream.expect_complete()?;
707            stream.expect_complete()?;
708            stream.expect(&PtxToken::Semicolon)?;
709            Ok(VaddDtypeAtypeBtypeSatOp2 {
710                dtype,
711                atype,
712                btype,
713                sat,
714                op2,
715                d,
716                a,
717                asel,
718                b,
719                bsel,
720                c,
721            })
722        }
723    }
724
725    impl PtxParser for VsubDtypeAtypeBtypeSatOp2 {
726        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
727            stream.expect_string("vsub")?;
728            let dtype = Dtype::parse(stream)?;
729            stream.expect_complete()?;
730            let atype = Atype::parse(stream)?;
731            stream.expect_complete()?;
732            let btype = Btype::parse(stream)?;
733            stream.expect_complete()?;
734            let saved_pos = stream.position();
735            let sat = stream.expect_string(".sat").is_ok();
736            if !sat {
737                stream.set_position(saved_pos);
738            }
739            stream.expect_complete()?;
740            let op2 = Op2::parse(stream)?;
741            stream.expect_complete()?;
742            let d = GeneralOperand::parse(stream)?;
743            stream.expect_complete()?;
744            stream.expect(&PtxToken::Comma)?;
745            let a = GeneralOperand::parse(stream)?;
746            let saved_pos = stream.position();
747            let asel = match Asel::parse(stream) {
748                Ok(val) => Some(val),
749                Err(_) => {
750                    stream.set_position(saved_pos);
751                    None
752                }
753            };
754            stream.expect_complete()?;
755            stream.expect(&PtxToken::Comma)?;
756            let b = GeneralOperand::parse(stream)?;
757            let saved_pos = stream.position();
758            let bsel = match Bsel::parse(stream) {
759                Ok(val) => Some(val),
760                Err(_) => {
761                    stream.set_position(saved_pos);
762                    None
763                }
764            };
765            stream.expect_complete()?;
766            stream.expect(&PtxToken::Comma)?;
767            let c = GeneralOperand::parse(stream)?;
768            stream.expect_complete()?;
769            stream.expect_complete()?;
770            stream.expect(&PtxToken::Semicolon)?;
771            Ok(VsubDtypeAtypeBtypeSatOp2 {
772                dtype,
773                atype,
774                btype,
775                sat,
776                op2,
777                d,
778                a,
779                asel,
780                b,
781                bsel,
782                c,
783            })
784        }
785    }
786
787    impl PtxParser for VabsdiffDtypeAtypeBtypeSatOp2 {
788        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
789            stream.expect_string("vabsdiff")?;
790            let dtype = Dtype::parse(stream)?;
791            stream.expect_complete()?;
792            let atype = Atype::parse(stream)?;
793            stream.expect_complete()?;
794            let btype = Btype::parse(stream)?;
795            stream.expect_complete()?;
796            let saved_pos = stream.position();
797            let sat = stream.expect_string(".sat").is_ok();
798            if !sat {
799                stream.set_position(saved_pos);
800            }
801            stream.expect_complete()?;
802            let op2 = Op2::parse(stream)?;
803            stream.expect_complete()?;
804            let d = GeneralOperand::parse(stream)?;
805            stream.expect_complete()?;
806            stream.expect(&PtxToken::Comma)?;
807            let a = GeneralOperand::parse(stream)?;
808            let saved_pos = stream.position();
809            let asel = match Asel::parse(stream) {
810                Ok(val) => Some(val),
811                Err(_) => {
812                    stream.set_position(saved_pos);
813                    None
814                }
815            };
816            stream.expect_complete()?;
817            stream.expect(&PtxToken::Comma)?;
818            let b = GeneralOperand::parse(stream)?;
819            let saved_pos = stream.position();
820            let bsel = match Bsel::parse(stream) {
821                Ok(val) => Some(val),
822                Err(_) => {
823                    stream.set_position(saved_pos);
824                    None
825                }
826            };
827            stream.expect_complete()?;
828            stream.expect(&PtxToken::Comma)?;
829            let c = GeneralOperand::parse(stream)?;
830            stream.expect_complete()?;
831            stream.expect_complete()?;
832            stream.expect(&PtxToken::Semicolon)?;
833            Ok(VabsdiffDtypeAtypeBtypeSatOp2 {
834                dtype,
835                atype,
836                btype,
837                sat,
838                op2,
839                d,
840                a,
841                asel,
842                b,
843                bsel,
844                c,
845            })
846        }
847    }
848
849    impl PtxParser for VminDtypeAtypeBtypeSatOp2 {
850        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
851            stream.expect_string("vmin")?;
852            let dtype = Dtype::parse(stream)?;
853            stream.expect_complete()?;
854            let atype = Atype::parse(stream)?;
855            stream.expect_complete()?;
856            let btype = Btype::parse(stream)?;
857            stream.expect_complete()?;
858            let saved_pos = stream.position();
859            let sat = stream.expect_string(".sat").is_ok();
860            if !sat {
861                stream.set_position(saved_pos);
862            }
863            stream.expect_complete()?;
864            let op2 = Op2::parse(stream)?;
865            stream.expect_complete()?;
866            let d = GeneralOperand::parse(stream)?;
867            stream.expect_complete()?;
868            stream.expect(&PtxToken::Comma)?;
869            let a = GeneralOperand::parse(stream)?;
870            let saved_pos = stream.position();
871            let asel = match Asel::parse(stream) {
872                Ok(val) => Some(val),
873                Err(_) => {
874                    stream.set_position(saved_pos);
875                    None
876                }
877            };
878            stream.expect_complete()?;
879            stream.expect(&PtxToken::Comma)?;
880            let b = GeneralOperand::parse(stream)?;
881            let saved_pos = stream.position();
882            let bsel = match Bsel::parse(stream) {
883                Ok(val) => Some(val),
884                Err(_) => {
885                    stream.set_position(saved_pos);
886                    None
887                }
888            };
889            stream.expect_complete()?;
890            stream.expect(&PtxToken::Comma)?;
891            let c = GeneralOperand::parse(stream)?;
892            stream.expect_complete()?;
893            stream.expect_complete()?;
894            stream.expect(&PtxToken::Semicolon)?;
895            Ok(VminDtypeAtypeBtypeSatOp2 {
896                dtype,
897                atype,
898                btype,
899                sat,
900                op2,
901                d,
902                a,
903                asel,
904                b,
905                bsel,
906                c,
907            })
908        }
909    }
910
911    impl PtxParser for VmaxDtypeAtypeBtypeSatOp2 {
912        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
913            stream.expect_string("vmax")?;
914            let dtype = Dtype::parse(stream)?;
915            stream.expect_complete()?;
916            let atype = Atype::parse(stream)?;
917            stream.expect_complete()?;
918            let btype = Btype::parse(stream)?;
919            stream.expect_complete()?;
920            let saved_pos = stream.position();
921            let sat = stream.expect_string(".sat").is_ok();
922            if !sat {
923                stream.set_position(saved_pos);
924            }
925            stream.expect_complete()?;
926            let op2 = Op2::parse(stream)?;
927            stream.expect_complete()?;
928            let d = GeneralOperand::parse(stream)?;
929            stream.expect_complete()?;
930            stream.expect(&PtxToken::Comma)?;
931            let a = GeneralOperand::parse(stream)?;
932            let saved_pos = stream.position();
933            let asel = match Asel::parse(stream) {
934                Ok(val) => Some(val),
935                Err(_) => {
936                    stream.set_position(saved_pos);
937                    None
938                }
939            };
940            stream.expect_complete()?;
941            stream.expect(&PtxToken::Comma)?;
942            let b = GeneralOperand::parse(stream)?;
943            let saved_pos = stream.position();
944            let bsel = match Bsel::parse(stream) {
945                Ok(val) => Some(val),
946                Err(_) => {
947                    stream.set_position(saved_pos);
948                    None
949                }
950            };
951            stream.expect_complete()?;
952            stream.expect(&PtxToken::Comma)?;
953            let c = GeneralOperand::parse(stream)?;
954            stream.expect_complete()?;
955            stream.expect_complete()?;
956            stream.expect(&PtxToken::Semicolon)?;
957            Ok(VmaxDtypeAtypeBtypeSatOp2 {
958                dtype,
959                atype,
960                btype,
961                sat,
962                op2,
963                d,
964                a,
965                asel,
966                b,
967                bsel,
968                c,
969            })
970        }
971    }
972
973    impl PtxParser for VaddDtypeAtypeBtypeSat1 {
974        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
975            stream.expect_string("vadd")?;
976            let dtype = Dtype::parse(stream)?;
977            stream.expect_complete()?;
978            let atype = Atype::parse(stream)?;
979            stream.expect_complete()?;
980            let btype = Btype::parse(stream)?;
981            stream.expect_complete()?;
982            let saved_pos = stream.position();
983            let sat = stream.expect_string(".sat").is_ok();
984            if !sat {
985                stream.set_position(saved_pos);
986            }
987            stream.expect_complete()?;
988            let d = GeneralOperand::parse(stream)?;
989            let dsel = Dsel::parse(stream)?;
990            stream.expect_complete()?;
991            stream.expect(&PtxToken::Comma)?;
992            let a = GeneralOperand::parse(stream)?;
993            let saved_pos = stream.position();
994            let asel = match Asel::parse(stream) {
995                Ok(val) => Some(val),
996                Err(_) => {
997                    stream.set_position(saved_pos);
998                    None
999                }
1000            };
1001            stream.expect_complete()?;
1002            stream.expect(&PtxToken::Comma)?;
1003            let b = GeneralOperand::parse(stream)?;
1004            let saved_pos = stream.position();
1005            let bsel = match Bsel::parse(stream) {
1006                Ok(val) => Some(val),
1007                Err(_) => {
1008                    stream.set_position(saved_pos);
1009                    None
1010                }
1011            };
1012            stream.expect_complete()?;
1013            stream.expect(&PtxToken::Comma)?;
1014            let c = GeneralOperand::parse(stream)?;
1015            stream.expect_complete()?;
1016            stream.expect_complete()?;
1017            stream.expect(&PtxToken::Semicolon)?;
1018            Ok(VaddDtypeAtypeBtypeSat1 {
1019                dtype,
1020                atype,
1021                btype,
1022                sat,
1023                d,
1024                dsel,
1025                a,
1026                asel,
1027                b,
1028                bsel,
1029                c,
1030            })
1031        }
1032    }
1033
1034    impl PtxParser for VsubDtypeAtypeBtypeSat1 {
1035        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
1036            stream.expect_string("vsub")?;
1037            let dtype = Dtype::parse(stream)?;
1038            stream.expect_complete()?;
1039            let atype = Atype::parse(stream)?;
1040            stream.expect_complete()?;
1041            let btype = Btype::parse(stream)?;
1042            stream.expect_complete()?;
1043            let saved_pos = stream.position();
1044            let sat = stream.expect_string(".sat").is_ok();
1045            if !sat {
1046                stream.set_position(saved_pos);
1047            }
1048            stream.expect_complete()?;
1049            let d = GeneralOperand::parse(stream)?;
1050            let dsel = Dsel::parse(stream)?;
1051            stream.expect_complete()?;
1052            stream.expect(&PtxToken::Comma)?;
1053            let a = GeneralOperand::parse(stream)?;
1054            let saved_pos = stream.position();
1055            let asel = match Asel::parse(stream) {
1056                Ok(val) => Some(val),
1057                Err(_) => {
1058                    stream.set_position(saved_pos);
1059                    None
1060                }
1061            };
1062            stream.expect_complete()?;
1063            stream.expect(&PtxToken::Comma)?;
1064            let b = GeneralOperand::parse(stream)?;
1065            let saved_pos = stream.position();
1066            let bsel = match Bsel::parse(stream) {
1067                Ok(val) => Some(val),
1068                Err(_) => {
1069                    stream.set_position(saved_pos);
1070                    None
1071                }
1072            };
1073            stream.expect_complete()?;
1074            stream.expect(&PtxToken::Comma)?;
1075            let c = GeneralOperand::parse(stream)?;
1076            stream.expect_complete()?;
1077            stream.expect_complete()?;
1078            stream.expect(&PtxToken::Semicolon)?;
1079            Ok(VsubDtypeAtypeBtypeSat1 {
1080                dtype,
1081                atype,
1082                btype,
1083                sat,
1084                d,
1085                dsel,
1086                a,
1087                asel,
1088                b,
1089                bsel,
1090                c,
1091            })
1092        }
1093    }
1094
1095    impl PtxParser for VabsdiffDtypeAtypeBtypeSat1 {
1096        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
1097            stream.expect_string("vabsdiff")?;
1098            let dtype = Dtype::parse(stream)?;
1099            stream.expect_complete()?;
1100            let atype = Atype::parse(stream)?;
1101            stream.expect_complete()?;
1102            let btype = Btype::parse(stream)?;
1103            stream.expect_complete()?;
1104            let saved_pos = stream.position();
1105            let sat = stream.expect_string(".sat").is_ok();
1106            if !sat {
1107                stream.set_position(saved_pos);
1108            }
1109            stream.expect_complete()?;
1110            let d = GeneralOperand::parse(stream)?;
1111            let dsel = Dsel::parse(stream)?;
1112            stream.expect_complete()?;
1113            stream.expect(&PtxToken::Comma)?;
1114            let a = GeneralOperand::parse(stream)?;
1115            let saved_pos = stream.position();
1116            let asel = match Asel::parse(stream) {
1117                Ok(val) => Some(val),
1118                Err(_) => {
1119                    stream.set_position(saved_pos);
1120                    None
1121                }
1122            };
1123            stream.expect_complete()?;
1124            stream.expect(&PtxToken::Comma)?;
1125            let b = GeneralOperand::parse(stream)?;
1126            let saved_pos = stream.position();
1127            let bsel = match Bsel::parse(stream) {
1128                Ok(val) => Some(val),
1129                Err(_) => {
1130                    stream.set_position(saved_pos);
1131                    None
1132                }
1133            };
1134            stream.expect_complete()?;
1135            stream.expect(&PtxToken::Comma)?;
1136            let c = GeneralOperand::parse(stream)?;
1137            stream.expect_complete()?;
1138            stream.expect_complete()?;
1139            stream.expect(&PtxToken::Semicolon)?;
1140            Ok(VabsdiffDtypeAtypeBtypeSat1 {
1141                dtype,
1142                atype,
1143                btype,
1144                sat,
1145                d,
1146                dsel,
1147                a,
1148                asel,
1149                b,
1150                bsel,
1151                c,
1152            })
1153        }
1154    }
1155
1156    impl PtxParser for VminDtypeAtypeBtypeSat1 {
1157        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
1158            stream.expect_string("vmin")?;
1159            let dtype = Dtype::parse(stream)?;
1160            stream.expect_complete()?;
1161            let atype = Atype::parse(stream)?;
1162            stream.expect_complete()?;
1163            let btype = Btype::parse(stream)?;
1164            stream.expect_complete()?;
1165            let saved_pos = stream.position();
1166            let sat = stream.expect_string(".sat").is_ok();
1167            if !sat {
1168                stream.set_position(saved_pos);
1169            }
1170            stream.expect_complete()?;
1171            let d = GeneralOperand::parse(stream)?;
1172            let dsel = Dsel::parse(stream)?;
1173            stream.expect_complete()?;
1174            stream.expect(&PtxToken::Comma)?;
1175            let a = GeneralOperand::parse(stream)?;
1176            let saved_pos = stream.position();
1177            let asel = match Asel::parse(stream) {
1178                Ok(val) => Some(val),
1179                Err(_) => {
1180                    stream.set_position(saved_pos);
1181                    None
1182                }
1183            };
1184            stream.expect_complete()?;
1185            stream.expect(&PtxToken::Comma)?;
1186            let b = GeneralOperand::parse(stream)?;
1187            let saved_pos = stream.position();
1188            let bsel = match Bsel::parse(stream) {
1189                Ok(val) => Some(val),
1190                Err(_) => {
1191                    stream.set_position(saved_pos);
1192                    None
1193                }
1194            };
1195            stream.expect_complete()?;
1196            stream.expect(&PtxToken::Comma)?;
1197            let c = GeneralOperand::parse(stream)?;
1198            stream.expect_complete()?;
1199            stream.expect_complete()?;
1200            stream.expect(&PtxToken::Semicolon)?;
1201            Ok(VminDtypeAtypeBtypeSat1 {
1202                dtype,
1203                atype,
1204                btype,
1205                sat,
1206                d,
1207                dsel,
1208                a,
1209                asel,
1210                b,
1211                bsel,
1212                c,
1213            })
1214        }
1215    }
1216
1217    impl PtxParser for VmaxDtypeAtypeBtypeSat1 {
1218        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
1219            stream.expect_string("vmax")?;
1220            let dtype = Dtype::parse(stream)?;
1221            stream.expect_complete()?;
1222            let atype = Atype::parse(stream)?;
1223            stream.expect_complete()?;
1224            let btype = Btype::parse(stream)?;
1225            stream.expect_complete()?;
1226            let saved_pos = stream.position();
1227            let sat = stream.expect_string(".sat").is_ok();
1228            if !sat {
1229                stream.set_position(saved_pos);
1230            }
1231            stream.expect_complete()?;
1232            let d = GeneralOperand::parse(stream)?;
1233            let dsel = Dsel::parse(stream)?;
1234            stream.expect_complete()?;
1235            stream.expect(&PtxToken::Comma)?;
1236            let a = GeneralOperand::parse(stream)?;
1237            let saved_pos = stream.position();
1238            let asel = match Asel::parse(stream) {
1239                Ok(val) => Some(val),
1240                Err(_) => {
1241                    stream.set_position(saved_pos);
1242                    None
1243                }
1244            };
1245            stream.expect_complete()?;
1246            stream.expect(&PtxToken::Comma)?;
1247            let b = GeneralOperand::parse(stream)?;
1248            let saved_pos = stream.position();
1249            let bsel = match Bsel::parse(stream) {
1250                Ok(val) => Some(val),
1251                Err(_) => {
1252                    stream.set_position(saved_pos);
1253                    None
1254                }
1255            };
1256            stream.expect_complete()?;
1257            stream.expect(&PtxToken::Comma)?;
1258            let c = GeneralOperand::parse(stream)?;
1259            stream.expect_complete()?;
1260            stream.expect_complete()?;
1261            stream.expect(&PtxToken::Semicolon)?;
1262            Ok(VmaxDtypeAtypeBtypeSat1 {
1263                dtype,
1264                atype,
1265                btype,
1266                sat,
1267                d,
1268                dsel,
1269                a,
1270                asel,
1271                b,
1272                bsel,
1273                c,
1274            })
1275        }
1276    }
1277}
ptx_parser/parser/instruction/vop.rs

ptx_parser/parser/instruction/
vop.rs
