ptx_parser/parser/instruction/
dp2a.rs

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

ptx_parser/parser/instruction/
dp2a.rs
