ptx_parser/parser/instruction/
sust.rs

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

ptx_parser/parser/instruction/
sust.rs
