ptx_parser/parser/instruction/
cvt_pack.rs

1//! Original PTX specification:
2//!
3//! cvt.pack.sat.convertType.abType  d, a, b;
4//! .convertType  = { .u16, .s16 };
5//! .abType       = { .s32 };
6//! ----------------------------------------------------------------
7//! cvt.pack.sat.convertType.abType.cType  d, a, b, c;
8//! .convertType  = { .u2, .s2, .u4, .s4, .u8, .s8 };
9//! .abType       = { .s32 };
10//! .cType        = { .b32 };
11
12#![allow(unused)]
13
14use crate::lexer::PtxToken;
15use crate::parser::{PtxParseError, PtxParser, PtxTokenStream, Span};
16use crate::r#type::common::*;
17
18pub mod section_0 {
19    use super::*;
20    use crate::r#type::instruction::cvt_pack::section_0::*;
21
22    // ============================================================================
23    // Generated enum parsers
24    // ============================================================================
25
26    impl PtxParser for Abtype {
27        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
28            // Try S32
29            {
30                let saved_pos = stream.position();
31                if stream.expect_string(".s32").is_ok() {
32                    return Ok(Abtype::S32);
33                }
34                stream.set_position(saved_pos);
35            }
36            let span = stream
37                .peek()
38                .map(|(_, s)| s.clone())
39                .unwrap_or(Span { start: 0, end: 0 });
40            let expected = &[".s32"];
41            let found = stream
42                .peek()
43                .map(|(t, _)| format!("{:?}", t))
44                .unwrap_or_else(|_| "<end of input>".to_string());
45            Err(crate::parser::unexpected_value(span, expected, found))
46        }
47    }
48
49    impl PtxParser for Converttype {
50        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
51            // Try U16
52            {
53                let saved_pos = stream.position();
54                if stream.expect_string(".u16").is_ok() {
55                    return Ok(Converttype::U16);
56                }
57                stream.set_position(saved_pos);
58            }
59            let saved_pos = stream.position();
60            // Try S16
61            {
62                let saved_pos = stream.position();
63                if stream.expect_string(".s16").is_ok() {
64                    return Ok(Converttype::S16);
65                }
66                stream.set_position(saved_pos);
67            }
68            stream.set_position(saved_pos);
69            let span = stream
70                .peek()
71                .map(|(_, s)| s.clone())
72                .unwrap_or(Span { start: 0, end: 0 });
73            let expected = &[".u16", ".s16"];
74            let found = stream
75                .peek()
76                .map(|(t, _)| format!("{:?}", t))
77                .unwrap_or_else(|_| "<end of input>".to_string());
78            Err(crate::parser::unexpected_value(span, expected, found))
79        }
80    }
81
82    impl PtxParser for CvtPackSatConverttypeAbtype {
83        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
84            stream.expect_string("cvt")?;
85            stream.expect_string(".pack")?;
86            let pack = ();
87            stream.expect_complete()?;
88            stream.expect_string(".sat")?;
89            let sat = ();
90            stream.expect_complete()?;
91            let converttype = Converttype::parse(stream)?;
92            stream.expect_complete()?;
93            let abtype = Abtype::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_complete()?;
104            stream.expect(&PtxToken::Semicolon)?;
105            Ok(CvtPackSatConverttypeAbtype {
106                pack,
107                sat,
108                converttype,
109                abtype,
110                d,
111                a,
112                b,
113            })
114        }
115    }
116}
117
118pub mod section_1 {
119    use super::*;
120    use crate::r#type::instruction::cvt_pack::section_1::*;
121
122    // ============================================================================
123    // Generated enum parsers
124    // ============================================================================
125
126    impl PtxParser for Abtype {
127        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
128            // Try S32
129            {
130                let saved_pos = stream.position();
131                if stream.expect_string(".s32").is_ok() {
132                    return Ok(Abtype::S32);
133                }
134                stream.set_position(saved_pos);
135            }
136            let span = stream
137                .peek()
138                .map(|(_, s)| s.clone())
139                .unwrap_or(Span { start: 0, end: 0 });
140            let expected = &[".s32"];
141            let found = stream
142                .peek()
143                .map(|(t, _)| format!("{:?}", t))
144                .unwrap_or_else(|_| "<end of input>".to_string());
145            Err(crate::parser::unexpected_value(span, expected, found))
146        }
147    }
148
149    impl PtxParser for Converttype {
150        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
151            // Try U2
152            {
153                let saved_pos = stream.position();
154                if stream.expect_string(".u2").is_ok() {
155                    return Ok(Converttype::U2);
156                }
157                stream.set_position(saved_pos);
158            }
159            let saved_pos = stream.position();
160            // Try S2
161            {
162                let saved_pos = stream.position();
163                if stream.expect_string(".s2").is_ok() {
164                    return Ok(Converttype::S2);
165                }
166                stream.set_position(saved_pos);
167            }
168            stream.set_position(saved_pos);
169            let saved_pos = stream.position();
170            // Try U4
171            {
172                let saved_pos = stream.position();
173                if stream.expect_string(".u4").is_ok() {
174                    return Ok(Converttype::U4);
175                }
176                stream.set_position(saved_pos);
177            }
178            stream.set_position(saved_pos);
179            let saved_pos = stream.position();
180            // Try S4
181            {
182                let saved_pos = stream.position();
183                if stream.expect_string(".s4").is_ok() {
184                    return Ok(Converttype::S4);
185                }
186                stream.set_position(saved_pos);
187            }
188            stream.set_position(saved_pos);
189            let saved_pos = stream.position();
190            // Try U8
191            {
192                let saved_pos = stream.position();
193                if stream.expect_string(".u8").is_ok() {
194                    return Ok(Converttype::U8);
195                }
196                stream.set_position(saved_pos);
197            }
198            stream.set_position(saved_pos);
199            let saved_pos = stream.position();
200            // Try S8
201            {
202                let saved_pos = stream.position();
203                if stream.expect_string(".s8").is_ok() {
204                    return Ok(Converttype::S8);
205                }
206                stream.set_position(saved_pos);
207            }
208            stream.set_position(saved_pos);
209            let span = stream
210                .peek()
211                .map(|(_, s)| s.clone())
212                .unwrap_or(Span { start: 0, end: 0 });
213            let expected = &[".u2", ".s2", ".u4", ".s4", ".u8", ".s8"];
214            let found = stream
215                .peek()
216                .map(|(t, _)| format!("{:?}", t))
217                .unwrap_or_else(|_| "<end of input>".to_string());
218            Err(crate::parser::unexpected_value(span, expected, found))
219        }
220    }
221
222    impl PtxParser for Ctype {
223        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
224            // Try B32
225            {
226                let saved_pos = stream.position();
227                if stream.expect_string(".b32").is_ok() {
228                    return Ok(Ctype::B32);
229                }
230                stream.set_position(saved_pos);
231            }
232            let span = stream
233                .peek()
234                .map(|(_, s)| s.clone())
235                .unwrap_or(Span { start: 0, end: 0 });
236            let expected = &[".b32"];
237            let found = stream
238                .peek()
239                .map(|(t, _)| format!("{:?}", t))
240                .unwrap_or_else(|_| "<end of input>".to_string());
241            Err(crate::parser::unexpected_value(span, expected, found))
242        }
243    }
244
245    impl PtxParser for CvtPackSatConverttypeAbtypeCtype {
246        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
247            stream.expect_string("cvt")?;
248            stream.expect_string(".pack")?;
249            let pack = ();
250            stream.expect_complete()?;
251            stream.expect_string(".sat")?;
252            let sat = ();
253            stream.expect_complete()?;
254            let converttype = Converttype::parse(stream)?;
255            stream.expect_complete()?;
256            let abtype = Abtype::parse(stream)?;
257            stream.expect_complete()?;
258            let ctype = Ctype::parse(stream)?;
259            stream.expect_complete()?;
260            let d = GeneralOperand::parse(stream)?;
261            stream.expect_complete()?;
262            stream.expect(&PtxToken::Comma)?;
263            let a = GeneralOperand::parse(stream)?;
264            stream.expect_complete()?;
265            stream.expect(&PtxToken::Comma)?;
266            let b = GeneralOperand::parse(stream)?;
267            stream.expect_complete()?;
268            stream.expect(&PtxToken::Comma)?;
269            let c = GeneralOperand::parse(stream)?;
270            stream.expect_complete()?;
271            stream.expect_complete()?;
272            stream.expect(&PtxToken::Semicolon)?;
273            Ok(CvtPackSatConverttypeAbtypeCtype {
274                pack,
275                sat,
276                converttype,
277                abtype,
278                ctype,
279                d,
280                a,
281                b,
282                c,
283            })
284        }
285    }
286}
ptx_parser/parser/instruction/cvt_pack.rs

ptx_parser/parser/instruction/
cvt_pack.rs
