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

ptx_parser/parser/instruction/
mad24.rs
