ptx_parser/parser/instruction/
suld.rs

1//! Original PTX specification:
2//!
3//! suld.b.geom{.cop}.vec.dtype{.mode}  d, [a, b];  // unformatted
4//!
5//! .geom  = { .1d, .2d, .3d, .a1d, .a2d };
6//! .cop   = { .ca, .cg, .cs, .cv };               // cache operation
7//! .vec   = { none, .v2, .v4 };
8//! .dtype = { .b8 , .b16, .b32, .b64 };
9//! .mode = { .trap, .clamp, .zero };
10
11#![allow(unused)]
12
13use crate::lexer::PtxToken;
14use crate::parser::{PtxParseError, PtxParser, PtxTokenStream, Span};
15use crate::r#type::common::*;
16
17pub mod section_0 {
18    use super::*;
19    use crate::r#type::instruction::suld::section_0::*;
20
21    // ============================================================================
22    // Generated enum parsers
23    // ============================================================================
24
25    impl PtxParser for Cop {
26        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
27            // Try Ca
28            {
29                let saved_pos = stream.position();
30                if stream.expect_string(".ca").is_ok() {
31                    return Ok(Cop::Ca);
32                }
33                stream.set_position(saved_pos);
34            }
35            let saved_pos = stream.position();
36            // Try Cg
37            {
38                let saved_pos = stream.position();
39                if stream.expect_string(".cg").is_ok() {
40                    return Ok(Cop::Cg);
41                }
42                stream.set_position(saved_pos);
43            }
44            stream.set_position(saved_pos);
45            let saved_pos = stream.position();
46            // Try Cs
47            {
48                let saved_pos = stream.position();
49                if stream.expect_string(".cs").is_ok() {
50                    return Ok(Cop::Cs);
51                }
52                stream.set_position(saved_pos);
53            }
54            stream.set_position(saved_pos);
55            let saved_pos = stream.position();
56            // Try Cv
57            {
58                let saved_pos = stream.position();
59                if stream.expect_string(".cv").is_ok() {
60                    return Ok(Cop::Cv);
61                }
62                stream.set_position(saved_pos);
63            }
64            stream.set_position(saved_pos);
65            let span = stream
66                .peek()
67                .map(|(_, s)| s.clone())
68                .unwrap_or(Span { start: 0, end: 0 });
69            let expected = &[".ca", ".cg", ".cs", ".cv"];
70            let found = stream
71                .peek()
72                .map(|(t, _)| format!("{:?}", t))
73                .unwrap_or_else(|_| "<end of input>".to_string());
74            Err(crate::parser::unexpected_value(span, expected, found))
75        }
76    }
77
78    impl PtxParser for Dtype {
79        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
80            // Try B16
81            {
82                let saved_pos = stream.position();
83                if stream.expect_string(".b16").is_ok() {
84                    return Ok(Dtype::B16);
85                }
86                stream.set_position(saved_pos);
87            }
88            let saved_pos = stream.position();
89            // Try B32
90            {
91                let saved_pos = stream.position();
92                if stream.expect_string(".b32").is_ok() {
93                    return Ok(Dtype::B32);
94                }
95                stream.set_position(saved_pos);
96            }
97            stream.set_position(saved_pos);
98            let saved_pos = stream.position();
99            // Try B64
100            {
101                let saved_pos = stream.position();
102                if stream.expect_string(".b64").is_ok() {
103                    return Ok(Dtype::B64);
104                }
105                stream.set_position(saved_pos);
106            }
107            stream.set_position(saved_pos);
108            let saved_pos = stream.position();
109            // Try B8
110            {
111                let saved_pos = stream.position();
112                if stream.expect_string(".b8").is_ok() {
113                    return Ok(Dtype::B8);
114                }
115                stream.set_position(saved_pos);
116            }
117            stream.set_position(saved_pos);
118            let span = stream
119                .peek()
120                .map(|(_, s)| s.clone())
121                .unwrap_or(Span { start: 0, end: 0 });
122            let expected = &[".b16", ".b32", ".b64", ".b8"];
123            let found = stream
124                .peek()
125                .map(|(t, _)| format!("{:?}", t))
126                .unwrap_or_else(|_| "<end of input>".to_string());
127            Err(crate::parser::unexpected_value(span, expected, found))
128        }
129    }
130
131    impl PtxParser for Geom {
132        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
133            // Try A1d
134            {
135                let saved_pos = stream.position();
136                if stream.expect_string(".a1d").is_ok() {
137                    return Ok(Geom::A1d);
138                }
139                stream.set_position(saved_pos);
140            }
141            let saved_pos = stream.position();
142            // Try A2d
143            {
144                let saved_pos = stream.position();
145                if stream.expect_string(".a2d").is_ok() {
146                    return Ok(Geom::A2d);
147                }
148                stream.set_position(saved_pos);
149            }
150            stream.set_position(saved_pos);
151            let saved_pos = stream.position();
152            // Try _1d
153            {
154                let saved_pos = stream.position();
155                if stream.expect_string(".1d").is_ok() {
156                    return Ok(Geom::_1d);
157                }
158                stream.set_position(saved_pos);
159            }
160            stream.set_position(saved_pos);
161            let saved_pos = stream.position();
162            // Try _2d
163            {
164                let saved_pos = stream.position();
165                if stream.expect_string(".2d").is_ok() {
166                    return Ok(Geom::_2d);
167                }
168                stream.set_position(saved_pos);
169            }
170            stream.set_position(saved_pos);
171            let saved_pos = stream.position();
172            // Try _3d
173            {
174                let saved_pos = stream.position();
175                if stream.expect_string(".3d").is_ok() {
176                    return Ok(Geom::_3d);
177                }
178                stream.set_position(saved_pos);
179            }
180            stream.set_position(saved_pos);
181            let span = stream
182                .peek()
183                .map(|(_, s)| s.clone())
184                .unwrap_or(Span { start: 0, end: 0 });
185            let expected = &[".a1d", ".a2d", ".1d", ".2d", ".3d"];
186            let found = stream
187                .peek()
188                .map(|(t, _)| format!("{:?}", t))
189                .unwrap_or_else(|_| "<end of input>".to_string());
190            Err(crate::parser::unexpected_value(span, expected, found))
191        }
192    }
193
194    impl PtxParser for Mode {
195        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
196            // Try Clamp
197            {
198                let saved_pos = stream.position();
199                if stream.expect_string(".clamp").is_ok() {
200                    return Ok(Mode::Clamp);
201                }
202                stream.set_position(saved_pos);
203            }
204            let saved_pos = stream.position();
205            // Try Trap
206            {
207                let saved_pos = stream.position();
208                if stream.expect_string(".trap").is_ok() {
209                    return Ok(Mode::Trap);
210                }
211                stream.set_position(saved_pos);
212            }
213            stream.set_position(saved_pos);
214            let saved_pos = stream.position();
215            // Try Zero
216            {
217                let saved_pos = stream.position();
218                if stream.expect_string(".zero").is_ok() {
219                    return Ok(Mode::Zero);
220                }
221                stream.set_position(saved_pos);
222            }
223            stream.set_position(saved_pos);
224            let span = stream
225                .peek()
226                .map(|(_, s)| s.clone())
227                .unwrap_or(Span { start: 0, end: 0 });
228            let expected = &[".clamp", ".trap", ".zero"];
229            let found = stream
230                .peek()
231                .map(|(t, _)| format!("{:?}", t))
232                .unwrap_or_else(|_| "<end of input>".to_string());
233            Err(crate::parser::unexpected_value(span, expected, found))
234        }
235    }
236
237    impl PtxParser for Vec {
238        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
239            // Try None
240            {
241                let saved_pos = stream.position();
242                if stream.expect_string("none").is_ok() {
243                    return Ok(Vec::None);
244                }
245                stream.set_position(saved_pos);
246            }
247            let saved_pos = stream.position();
248            // Try V2
249            {
250                let saved_pos = stream.position();
251                if stream.expect_string(".v2").is_ok() {
252                    return Ok(Vec::V2);
253                }
254                stream.set_position(saved_pos);
255            }
256            stream.set_position(saved_pos);
257            let saved_pos = stream.position();
258            // Try V4
259            {
260                let saved_pos = stream.position();
261                if stream.expect_string(".v4").is_ok() {
262                    return Ok(Vec::V4);
263                }
264                stream.set_position(saved_pos);
265            }
266            stream.set_position(saved_pos);
267            let span = stream
268                .peek()
269                .map(|(_, s)| s.clone())
270                .unwrap_or(Span { start: 0, end: 0 });
271            let expected = &["none", ".v2", ".v4"];
272            let found = stream
273                .peek()
274                .map(|(t, _)| format!("{:?}", t))
275                .unwrap_or_else(|_| "<end of input>".to_string());
276            Err(crate::parser::unexpected_value(span, expected, found))
277        }
278    }
279
280    impl PtxParser for SuldBGeomCopVecDtypeMode {
281        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
282            stream.expect_string("suld")?;
283            stream.expect_string(".b")?;
284            let b = ();
285            stream.expect_complete()?;
286            let geom = Geom::parse(stream)?;
287            stream.expect_complete()?;
288            let saved_pos = stream.position();
289            let cop = match Cop::parse(stream) {
290                Ok(val) => Some(val),
291                Err(_) => {
292                    stream.set_position(saved_pos);
293                    None
294                }
295            };
296            stream.expect_complete()?;
297            let vec = Vec::parse(stream)?;
298            stream.expect_complete()?;
299            let dtype = Dtype::parse(stream)?;
300            stream.expect_complete()?;
301            let saved_pos = stream.position();
302            let mode = match Mode::parse(stream) {
303                Ok(val) => Some(val),
304                Err(_) => {
305                    stream.set_position(saved_pos);
306                    None
307                }
308            };
309            stream.expect_complete()?;
310            let d = GeneralOperand::parse(stream)?;
311            stream.expect_complete()?;
312            stream.expect(&PtxToken::Comma)?;
313            let a = TexHandler2::parse(stream)?;
314            stream.expect_complete()?;
315            stream.expect_complete()?;
316            stream.expect(&PtxToken::Semicolon)?;
317            Ok(SuldBGeomCopVecDtypeMode {
318                b,
319                geom,
320                cop,
321                vec,
322                dtype,
323                mode,
324                d,
325                a,
326            })
327        }
328    }
329}
ptx_parser/parser/instruction/suld.rs

ptx_parser/parser/instruction/
suld.rs
