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

ptx_parser/parser/instruction/
vop.rs
