ptx_parser/parser/instruction/
dp4a.rs

1//! Original PTX specification:
2//!
3//! dp4a.atype.btype  d, a, b, c;
4//! .atype = .btype = { .u32, .s32 };
5
6#![allow(unused)]
7
8use crate::lexer::PtxToken;
9use crate::parser::{PtxParseError, PtxParser, PtxTokenStream, Span};
10use crate::r#type::common::*;
11
12pub mod section_0 {
13    use super::*;
14    use crate::r#type::instruction::dp4a::section_0::*;
15
16    // ============================================================================
17    // Generated enum parsers
18    // ============================================================================
19
20    impl PtxParser for Atype {
21        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
22            // Try U32
23            {
24                let saved_pos = stream.position();
25                if stream.expect_string(".u32").is_ok() {
26                    return Ok(Atype::U32);
27                }
28                stream.set_position(saved_pos);
29            }
30            let saved_pos = stream.position();
31            // Try S32
32            {
33                let saved_pos = stream.position();
34                if stream.expect_string(".s32").is_ok() {
35                    return Ok(Atype::S32);
36                }
37                stream.set_position(saved_pos);
38            }
39            stream.set_position(saved_pos);
40            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
41            let expected = &[".u32", ".s32"];
42            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
43            Err(crate::parser::unexpected_value(span, expected, found))
44        }
45    }
46
47    impl PtxParser for Btype {
48        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
49            // Try U32
50            {
51                let saved_pos = stream.position();
52                if stream.expect_string(".u32").is_ok() {
53                    return Ok(Btype::U32);
54                }
55                stream.set_position(saved_pos);
56            }
57            let saved_pos = stream.position();
58            // Try S32
59            {
60                let saved_pos = stream.position();
61                if stream.expect_string(".s32").is_ok() {
62                    return Ok(Btype::S32);
63                }
64                stream.set_position(saved_pos);
65            }
66            stream.set_position(saved_pos);
67            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
68            let expected = &[".u32", ".s32"];
69            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
70            Err(crate::parser::unexpected_value(span, expected, found))
71        }
72    }
73
74    impl PtxParser for Dp4aAtypeBtype {
75        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
76            stream.expect_string("dp4a")?;
77            let atype = Atype::parse(stream)?;
78            stream.expect_complete()?;
79            let btype = Btype::parse(stream)?;
80            stream.expect_complete()?;
81            let d = GeneralOperand::parse(stream)?;
82            stream.expect_complete()?;
83            stream.expect(&PtxToken::Comma)?;
84            let a = GeneralOperand::parse(stream)?;
85            stream.expect_complete()?;
86            stream.expect(&PtxToken::Comma)?;
87            let b = GeneralOperand::parse(stream)?;
88            stream.expect_complete()?;
89            stream.expect(&PtxToken::Comma)?;
90            let c = GeneralOperand::parse(stream)?;
91            stream.expect_complete()?;
92            stream.expect_complete()?;
93            stream.expect(&PtxToken::Semicolon)?;
94            Ok(Dp4aAtypeBtype {
95                atype,
96                btype,
97                d,
98                a,
99                b,
100                c,
101            })
102        }
103    }
104
105
106}
107