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
42                .peek()
43                .map(|(_, s)| s.clone())
44                .unwrap_or(Span { start: 0, end: 0 });
45            let expected = &[".u32", ".s32"];
46            let found = stream
47                .peek()
48                .map(|(t, _)| format!("{:?}", t))
49                .unwrap_or_else(|_| "<end of input>".to_string());
50            Err(crate::parser::unexpected_value(span, expected, found))
51        }
52    }
53
54    impl PtxParser for Btype {
55        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
56            // Try U32
57            {
58                let saved_pos = stream.position();
59                if stream.expect_string(".u32").is_ok() {
60                    return Ok(Btype::U32);
61                }
62                stream.set_position(saved_pos);
63            }
64            let saved_pos = stream.position();
65            // Try S32
66            {
67                let saved_pos = stream.position();
68                if stream.expect_string(".s32").is_ok() {
69                    return Ok(Btype::S32);
70                }
71                stream.set_position(saved_pos);
72            }
73            stream.set_position(saved_pos);
74            let span = stream
75                .peek()
76                .map(|(_, s)| s.clone())
77                .unwrap_or(Span { start: 0, end: 0 });
78            let expected = &[".u32", ".s32"];
79            let found = stream
80                .peek()
81                .map(|(t, _)| format!("{:?}", t))
82                .unwrap_or_else(|_| "<end of input>".to_string());
83            Err(crate::parser::unexpected_value(span, expected, found))
84        }
85    }
86
87    impl PtxParser for Mode {
88        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
89            // Try Lo
90            {
91                let saved_pos = stream.position();
92                if stream.expect_string(".lo").is_ok() {
93                    return Ok(Mode::Lo);
94                }
95                stream.set_position(saved_pos);
96            }
97            let saved_pos = stream.position();
98            // Try Hi
99            {
100                let saved_pos = stream.position();
101                if stream.expect_string(".hi").is_ok() {
102                    return Ok(Mode::Hi);
103                }
104                stream.set_position(saved_pos);
105            }
106            stream.set_position(saved_pos);
107            let span = stream
108                .peek()
109                .map(|(_, s)| s.clone())
110                .unwrap_or(Span { start: 0, end: 0 });
111            let expected = &[".lo", ".hi"];
112            let found = stream
113                .peek()
114                .map(|(t, _)| format!("{:?}", t))
115                .unwrap_or_else(|_| "<end of input>".to_string());
116            Err(crate::parser::unexpected_value(span, expected, found))
117        }
118    }
119
120    impl PtxParser for Dp2aModeAtypeBtype {
121        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
122            stream.expect_string("dp2a")?;
123            let mode = Mode::parse(stream)?;
124            stream.expect_complete()?;
125            let atype = Atype::parse(stream)?;
126            stream.expect_complete()?;
127            let btype = Btype::parse(stream)?;
128            stream.expect_complete()?;
129            let d = GeneralOperand::parse(stream)?;
130            stream.expect_complete()?;
131            stream.expect(&PtxToken::Comma)?;
132            let a = GeneralOperand::parse(stream)?;
133            stream.expect_complete()?;
134            stream.expect(&PtxToken::Comma)?;
135            let b = GeneralOperand::parse(stream)?;
136            stream.expect_complete()?;
137            stream.expect(&PtxToken::Comma)?;
138            let c = GeneralOperand::parse(stream)?;
139            stream.expect_complete()?;
140            stream.expect_complete()?;
141            stream.expect(&PtxToken::Semicolon)?;
142            Ok(Dp2aModeAtypeBtype {
143                mode,
144                atype,
145                btype,
146                d,
147                a,
148                b,
149                c,
150            })
151        }
152    }
153}
ptx_parser/parser/instruction/dp2a.rs

ptx_parser/parser/instruction/
dp2a.rs
