ptx_parser/parser/instruction/
vset.rs

1//! Original PTX specification:
2//!
3//! // 32-bit scalar operation, with optional secondary operation
4//! vset.atype.btype.cmp       d, a{.asel}, b{.bsel};
5//! vset.atype.btype.cmp.op2   d, a{.asel}, b{.bsel}, c;
6//! // 32-bit scalar operation, with optional data merge
7//! vset.atype.btype.cmp  d.dsel, a{.asel}, b{.bsel}, c;
8//! .atype = .btype = { .u32, .s32 };
9//! .cmp   = { .eq, .ne, .lt, .le, .gt, .ge };
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::vset::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 Cmp {
240        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
241            // Try Eq
242            {
243                let saved_pos = stream.position();
244                if stream.expect_string(".eq").is_ok() {
245                    return Ok(Cmp::Eq);
246                }
247                stream.set_position(saved_pos);
248            }
249            let saved_pos = stream.position();
250            // Try Ne
251            {
252                let saved_pos = stream.position();
253                if stream.expect_string(".ne").is_ok() {
254                    return Ok(Cmp::Ne);
255                }
256                stream.set_position(saved_pos);
257            }
258            stream.set_position(saved_pos);
259            let saved_pos = stream.position();
260            // Try Lt
261            {
262                let saved_pos = stream.position();
263                if stream.expect_string(".lt").is_ok() {
264                    return Ok(Cmp::Lt);
265                }
266                stream.set_position(saved_pos);
267            }
268            stream.set_position(saved_pos);
269            let saved_pos = stream.position();
270            // Try Le
271            {
272                let saved_pos = stream.position();
273                if stream.expect_string(".le").is_ok() {
274                    return Ok(Cmp::Le);
275                }
276                stream.set_position(saved_pos);
277            }
278            stream.set_position(saved_pos);
279            let saved_pos = stream.position();
280            // Try Gt
281            {
282                let saved_pos = stream.position();
283                if stream.expect_string(".gt").is_ok() {
284                    return Ok(Cmp::Gt);
285                }
286                stream.set_position(saved_pos);
287            }
288            stream.set_position(saved_pos);
289            let saved_pos = stream.position();
290            // Try Ge
291            {
292                let saved_pos = stream.position();
293                if stream.expect_string(".ge").is_ok() {
294                    return Ok(Cmp::Ge);
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 = &[".eq", ".ne", ".lt", ".le", ".gt", ".ge"];
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 Dsel {
313        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
314            // Try B0
315            {
316                let saved_pos = stream.position();
317                if stream.expect_string(".b0").is_ok() {
318                    return Ok(Dsel::B0);
319                }
320                stream.set_position(saved_pos);
321            }
322            let saved_pos = stream.position();
323            // Try B1
324            {
325                let saved_pos = stream.position();
326                if stream.expect_string(".b1").is_ok() {
327                    return Ok(Dsel::B1);
328                }
329                stream.set_position(saved_pos);
330            }
331            stream.set_position(saved_pos);
332            let saved_pos = stream.position();
333            // Try B2
334            {
335                let saved_pos = stream.position();
336                if stream.expect_string(".b2").is_ok() {
337                    return Ok(Dsel::B2);
338                }
339                stream.set_position(saved_pos);
340            }
341            stream.set_position(saved_pos);
342            let saved_pos = stream.position();
343            // Try B3
344            {
345                let saved_pos = stream.position();
346                if stream.expect_string(".b3").is_ok() {
347                    return Ok(Dsel::B3);
348                }
349                stream.set_position(saved_pos);
350            }
351            stream.set_position(saved_pos);
352            let saved_pos = stream.position();
353            // Try H0
354            {
355                let saved_pos = stream.position();
356                if stream.expect_string(".h0").is_ok() {
357                    return Ok(Dsel::H0);
358                }
359                stream.set_position(saved_pos);
360            }
361            stream.set_position(saved_pos);
362            let saved_pos = stream.position();
363            // Try H1
364            {
365                let saved_pos = stream.position();
366                if stream.expect_string(".h1").is_ok() {
367                    return Ok(Dsel::H1);
368                }
369                stream.set_position(saved_pos);
370            }
371            stream.set_position(saved_pos);
372            let span = stream
373                .peek()
374                .map(|(_, s)| s.clone())
375                .unwrap_or(Span { start: 0, end: 0 });
376            let expected = &[".b0", ".b1", ".b2", ".b3", ".h0", ".h1"];
377            let found = stream
378                .peek()
379                .map(|(t, _)| format!("{:?}", t))
380                .unwrap_or_else(|_| "<end of input>".to_string());
381            Err(crate::parser::unexpected_value(span, expected, found))
382        }
383    }
384
385    impl PtxParser for Op2 {
386        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
387            // Try Add
388            {
389                let saved_pos = stream.position();
390                if stream.expect_string(".add").is_ok() {
391                    return Ok(Op2::Add);
392                }
393                stream.set_position(saved_pos);
394            }
395            let saved_pos = stream.position();
396            // Try Min
397            {
398                let saved_pos = stream.position();
399                if stream.expect_string(".min").is_ok() {
400                    return Ok(Op2::Min);
401                }
402                stream.set_position(saved_pos);
403            }
404            stream.set_position(saved_pos);
405            let saved_pos = stream.position();
406            // Try Max
407            {
408                let saved_pos = stream.position();
409                if stream.expect_string(".max").is_ok() {
410                    return Ok(Op2::Max);
411                }
412                stream.set_position(saved_pos);
413            }
414            stream.set_position(saved_pos);
415            let span = stream
416                .peek()
417                .map(|(_, s)| s.clone())
418                .unwrap_or(Span { start: 0, end: 0 });
419            let expected = &[".add", ".min", ".max"];
420            let found = stream
421                .peek()
422                .map(|(t, _)| format!("{:?}", t))
423                .unwrap_or_else(|_| "<end of input>".to_string());
424            Err(crate::parser::unexpected_value(span, expected, found))
425        }
426    }
427
428    impl PtxParser for VsetAtypeBtypeCmp {
429        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
430            stream.expect_string("vset")?;
431            let atype = Atype::parse(stream)?;
432            stream.expect_complete()?;
433            let btype = Btype::parse(stream)?;
434            stream.expect_complete()?;
435            let cmp = Cmp::parse(stream)?;
436            stream.expect_complete()?;
437            let d = GeneralOperand::parse(stream)?;
438            stream.expect_complete()?;
439            stream.expect(&PtxToken::Comma)?;
440            let a = GeneralOperand::parse(stream)?;
441            let saved_pos = stream.position();
442            let asel = match Asel::parse(stream) {
443                Ok(val) => Some(val),
444                Err(_) => {
445                    stream.set_position(saved_pos);
446                    None
447                }
448            };
449            stream.expect_complete()?;
450            stream.expect(&PtxToken::Comma)?;
451            let b = GeneralOperand::parse(stream)?;
452            let saved_pos = stream.position();
453            let bsel = match Bsel::parse(stream) {
454                Ok(val) => Some(val),
455                Err(_) => {
456                    stream.set_position(saved_pos);
457                    None
458                }
459            };
460            stream.expect_complete()?;
461            stream.expect_complete()?;
462            stream.expect(&PtxToken::Semicolon)?;
463            Ok(VsetAtypeBtypeCmp {
464                atype,
465                btype,
466                cmp,
467                d,
468                a,
469                asel,
470                b,
471                bsel,
472            })
473        }
474    }
475
476    impl PtxParser for VsetAtypeBtypeCmpOp2 {
477        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
478            stream.expect_string("vset")?;
479            let atype = Atype::parse(stream)?;
480            stream.expect_complete()?;
481            let btype = Btype::parse(stream)?;
482            stream.expect_complete()?;
483            let cmp = Cmp::parse(stream)?;
484            stream.expect_complete()?;
485            let op2 = Op2::parse(stream)?;
486            stream.expect_complete()?;
487            let d = GeneralOperand::parse(stream)?;
488            stream.expect_complete()?;
489            stream.expect(&PtxToken::Comma)?;
490            let a = GeneralOperand::parse(stream)?;
491            let saved_pos = stream.position();
492            let asel = match Asel::parse(stream) {
493                Ok(val) => Some(val),
494                Err(_) => {
495                    stream.set_position(saved_pos);
496                    None
497                }
498            };
499            stream.expect_complete()?;
500            stream.expect(&PtxToken::Comma)?;
501            let b = GeneralOperand::parse(stream)?;
502            let saved_pos = stream.position();
503            let bsel = match Bsel::parse(stream) {
504                Ok(val) => Some(val),
505                Err(_) => {
506                    stream.set_position(saved_pos);
507                    None
508                }
509            };
510            stream.expect_complete()?;
511            stream.expect(&PtxToken::Comma)?;
512            let c = GeneralOperand::parse(stream)?;
513            stream.expect_complete()?;
514            stream.expect_complete()?;
515            stream.expect(&PtxToken::Semicolon)?;
516            Ok(VsetAtypeBtypeCmpOp2 {
517                atype,
518                btype,
519                cmp,
520                op2,
521                d,
522                a,
523                asel,
524                b,
525                bsel,
526                c,
527            })
528        }
529    }
530
531    impl PtxParser for VsetAtypeBtypeCmp1 {
532        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
533            stream.expect_string("vset")?;
534            let atype = Atype::parse(stream)?;
535            stream.expect_complete()?;
536            let btype = Btype::parse(stream)?;
537            stream.expect_complete()?;
538            let cmp = Cmp::parse(stream)?;
539            stream.expect_complete()?;
540            let d = GeneralOperand::parse(stream)?;
541            let dsel = Dsel::parse(stream)?;
542            stream.expect_complete()?;
543            stream.expect(&PtxToken::Comma)?;
544            let a = GeneralOperand::parse(stream)?;
545            let saved_pos = stream.position();
546            let asel = match Asel::parse(stream) {
547                Ok(val) => Some(val),
548                Err(_) => {
549                    stream.set_position(saved_pos);
550                    None
551                }
552            };
553            stream.expect_complete()?;
554            stream.expect(&PtxToken::Comma)?;
555            let b = GeneralOperand::parse(stream)?;
556            let saved_pos = stream.position();
557            let bsel = match Bsel::parse(stream) {
558                Ok(val) => Some(val),
559                Err(_) => {
560                    stream.set_position(saved_pos);
561                    None
562                }
563            };
564            stream.expect_complete()?;
565            stream.expect(&PtxToken::Comma)?;
566            let c = GeneralOperand::parse(stream)?;
567            stream.expect_complete()?;
568            stream.expect_complete()?;
569            stream.expect(&PtxToken::Semicolon)?;
570            Ok(VsetAtypeBtypeCmp1 {
571                atype,
572                btype,
573                cmp,
574                d,
575                dsel,
576                a,
577                asel,
578                b,
579                bsel,
580                c,
581            })
582        }
583    }
584}
ptx_parser/parser/instruction/vset.rs

ptx_parser/parser/instruction/
vset.rs
