ptx_parser/parser/instruction/
mad24.rs

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

ptx_parser/parser/instruction/
mad24.rs
