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.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
37            let expected = &[".s32"];
38            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
39            Err(crate::parser::unexpected_value(span, expected, found))
40        }
41    }
42
43    impl PtxParser for Converttype {
44        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
45            // Try U16
46            {
47                let saved_pos = stream.position();
48                if stream.expect_string(".u16").is_ok() {
49                    return Ok(Converttype::U16);
50                }
51                stream.set_position(saved_pos);
52            }
53            let saved_pos = stream.position();
54            // Try S16
55            {
56                let saved_pos = stream.position();
57                if stream.expect_string(".s16").is_ok() {
58                    return Ok(Converttype::S16);
59                }
60                stream.set_position(saved_pos);
61            }
62            stream.set_position(saved_pos);
63            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
64            let expected = &[".u16", ".s16"];
65            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
66            Err(crate::parser::unexpected_value(span, expected, found))
67        }
68    }
69
70    impl PtxParser for CvtPackSatConverttypeAbtype {
71        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
72            stream.expect_string("cvt")?;
73            stream.expect_string(".pack")?;
74            let pack = ();
75            stream.expect_complete()?;
76            stream.expect_string(".sat")?;
77            let sat = ();
78            stream.expect_complete()?;
79            let converttype = Converttype::parse(stream)?;
80            stream.expect_complete()?;
81            let abtype = Abtype::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_complete()?;
92            stream.expect(&PtxToken::Semicolon)?;
93            Ok(CvtPackSatConverttypeAbtype {
94                pack,
95                sat,
96                converttype,
97                abtype,
98                d,
99                a,
100                b,
101            })
102        }
103    }
104
105
106}
107
108pub mod section_1 {
109    use super::*;
110    use crate::r#type::instruction::cvt_pack::section_1::*;
111
112    // ============================================================================
113    // Generated enum parsers
114    // ============================================================================
115
116    impl PtxParser for Abtype {
117        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
118            // Try S32
119            {
120                let saved_pos = stream.position();
121                if stream.expect_string(".s32").is_ok() {
122                    return Ok(Abtype::S32);
123                }
124                stream.set_position(saved_pos);
125            }
126            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
127            let expected = &[".s32"];
128            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
129            Err(crate::parser::unexpected_value(span, expected, found))
130        }
131    }
132
133    impl PtxParser for Converttype {
134        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
135            // Try U2
136            {
137                let saved_pos = stream.position();
138                if stream.expect_string(".u2").is_ok() {
139                    return Ok(Converttype::U2);
140                }
141                stream.set_position(saved_pos);
142            }
143            let saved_pos = stream.position();
144            // Try S2
145            {
146                let saved_pos = stream.position();
147                if stream.expect_string(".s2").is_ok() {
148                    return Ok(Converttype::S2);
149                }
150                stream.set_position(saved_pos);
151            }
152            stream.set_position(saved_pos);
153            let saved_pos = stream.position();
154            // Try U4
155            {
156                let saved_pos = stream.position();
157                if stream.expect_string(".u4").is_ok() {
158                    return Ok(Converttype::U4);
159                }
160                stream.set_position(saved_pos);
161            }
162            stream.set_position(saved_pos);
163            let saved_pos = stream.position();
164            // Try S4
165            {
166                let saved_pos = stream.position();
167                if stream.expect_string(".s4").is_ok() {
168                    return Ok(Converttype::S4);
169                }
170                stream.set_position(saved_pos);
171            }
172            stream.set_position(saved_pos);
173            let saved_pos = stream.position();
174            // Try U8
175            {
176                let saved_pos = stream.position();
177                if stream.expect_string(".u8").is_ok() {
178                    return Ok(Converttype::U8);
179                }
180                stream.set_position(saved_pos);
181            }
182            stream.set_position(saved_pos);
183            let saved_pos = stream.position();
184            // Try S8
185            {
186                let saved_pos = stream.position();
187                if stream.expect_string(".s8").is_ok() {
188                    return Ok(Converttype::S8);
189                }
190                stream.set_position(saved_pos);
191            }
192            stream.set_position(saved_pos);
193            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
194            let expected = &[".u2", ".s2", ".u4", ".s4", ".u8", ".s8"];
195            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
196            Err(crate::parser::unexpected_value(span, expected, found))
197        }
198    }
199
200    impl PtxParser for Ctype {
201        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
202            // Try B32
203            {
204                let saved_pos = stream.position();
205                if stream.expect_string(".b32").is_ok() {
206                    return Ok(Ctype::B32);
207                }
208                stream.set_position(saved_pos);
209            }
210            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
211            let expected = &[".b32"];
212            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
213            Err(crate::parser::unexpected_value(span, expected, found))
214        }
215    }
216
217    impl PtxParser for CvtPackSatConverttypeAbtypeCtype {
218        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
219            stream.expect_string("cvt")?;
220            stream.expect_string(".pack")?;
221            let pack = ();
222            stream.expect_complete()?;
223            stream.expect_string(".sat")?;
224            let sat = ();
225            stream.expect_complete()?;
226            let converttype = Converttype::parse(stream)?;
227            stream.expect_complete()?;
228            let abtype = Abtype::parse(stream)?;
229            stream.expect_complete()?;
230            let ctype = Ctype::parse(stream)?;
231            stream.expect_complete()?;
232            let d = GeneralOperand::parse(stream)?;
233            stream.expect_complete()?;
234            stream.expect(&PtxToken::Comma)?;
235            let a = GeneralOperand::parse(stream)?;
236            stream.expect_complete()?;
237            stream.expect(&PtxToken::Comma)?;
238            let b = GeneralOperand::parse(stream)?;
239            stream.expect_complete()?;
240            stream.expect(&PtxToken::Comma)?;
241            let c = GeneralOperand::parse(stream)?;
242            stream.expect_complete()?;
243            stream.expect_complete()?;
244            stream.expect(&PtxToken::Semicolon)?;
245            Ok(CvtPackSatConverttypeAbtypeCtype {
246                pack,
247                sat,
248                converttype,
249                abtype,
250                ctype,
251                d,
252                a,
253                b,
254                c,
255            })
256        }
257    }
258
259
260}
261
ptx_parser/parser/instruction/cvt_pack.rs

ptx_parser/parser/instruction/
cvt_pack.rs
