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

ptx_parser/parser/instruction/
sust.rs
