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.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
66            let expected = &[".ca", ".cg", ".cs", ".cv"];
67            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
68            Err(crate::parser::unexpected_value(span, expected, found))
69        }
70    }
71
72    impl PtxParser for Dtype {
73        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
74            // Try B16
75            {
76                let saved_pos = stream.position();
77                if stream.expect_string(".b16").is_ok() {
78                    return Ok(Dtype::B16);
79                }
80                stream.set_position(saved_pos);
81            }
82            let saved_pos = stream.position();
83            // Try B32
84            {
85                let saved_pos = stream.position();
86                if stream.expect_string(".b32").is_ok() {
87                    return Ok(Dtype::B32);
88                }
89                stream.set_position(saved_pos);
90            }
91            stream.set_position(saved_pos);
92            let saved_pos = stream.position();
93            // Try B64
94            {
95                let saved_pos = stream.position();
96                if stream.expect_string(".b64").is_ok() {
97                    return Ok(Dtype::B64);
98                }
99                stream.set_position(saved_pos);
100            }
101            stream.set_position(saved_pos);
102            let saved_pos = stream.position();
103            // Try B8
104            {
105                let saved_pos = stream.position();
106                if stream.expect_string(".b8").is_ok() {
107                    return Ok(Dtype::B8);
108                }
109                stream.set_position(saved_pos);
110            }
111            stream.set_position(saved_pos);
112            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
113            let expected = &[".b16", ".b32", ".b64", ".b8"];
114            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
115            Err(crate::parser::unexpected_value(span, expected, found))
116        }
117    }
118
119    impl PtxParser for Geom {
120        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
121            // Try A1d
122            {
123                let saved_pos = stream.position();
124                if stream.expect_string(".a1d").is_ok() {
125                    return Ok(Geom::A1d);
126                }
127                stream.set_position(saved_pos);
128            }
129            let saved_pos = stream.position();
130            // Try A2d
131            {
132                let saved_pos = stream.position();
133                if stream.expect_string(".a2d").is_ok() {
134                    return Ok(Geom::A2d);
135                }
136                stream.set_position(saved_pos);
137            }
138            stream.set_position(saved_pos);
139            let saved_pos = stream.position();
140            // Try _1d
141            {
142                let saved_pos = stream.position();
143                if stream.expect_string(".1d").is_ok() {
144                    return Ok(Geom::_1d);
145                }
146                stream.set_position(saved_pos);
147            }
148            stream.set_position(saved_pos);
149            let saved_pos = stream.position();
150            // Try _2d
151            {
152                let saved_pos = stream.position();
153                if stream.expect_string(".2d").is_ok() {
154                    return Ok(Geom::_2d);
155                }
156                stream.set_position(saved_pos);
157            }
158            stream.set_position(saved_pos);
159            let saved_pos = stream.position();
160            // Try _3d
161            {
162                let saved_pos = stream.position();
163                if stream.expect_string(".3d").is_ok() {
164                    return Ok(Geom::_3d);
165                }
166                stream.set_position(saved_pos);
167            }
168            stream.set_position(saved_pos);
169            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
170            let expected = &[".a1d", ".a2d", ".1d", ".2d", ".3d"];
171            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
172            Err(crate::parser::unexpected_value(span, expected, found))
173        }
174    }
175
176    impl PtxParser for Mode {
177        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
178            // Try Clamp
179            {
180                let saved_pos = stream.position();
181                if stream.expect_string(".clamp").is_ok() {
182                    return Ok(Mode::Clamp);
183                }
184                stream.set_position(saved_pos);
185            }
186            let saved_pos = stream.position();
187            // Try Trap
188            {
189                let saved_pos = stream.position();
190                if stream.expect_string(".trap").is_ok() {
191                    return Ok(Mode::Trap);
192                }
193                stream.set_position(saved_pos);
194            }
195            stream.set_position(saved_pos);
196            let saved_pos = stream.position();
197            // Try Zero
198            {
199                let saved_pos = stream.position();
200                if stream.expect_string(".zero").is_ok() {
201                    return Ok(Mode::Zero);
202                }
203                stream.set_position(saved_pos);
204            }
205            stream.set_position(saved_pos);
206            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
207            let expected = &[".clamp", ".trap", ".zero"];
208            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
209            Err(crate::parser::unexpected_value(span, expected, found))
210        }
211    }
212
213    impl PtxParser for Vec {
214        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
215            // Try None
216            {
217                let saved_pos = stream.position();
218                if stream.expect_string("none").is_ok() {
219                    return Ok(Vec::None);
220                }
221                stream.set_position(saved_pos);
222            }
223            let saved_pos = stream.position();
224            // Try V2
225            {
226                let saved_pos = stream.position();
227                if stream.expect_string(".v2").is_ok() {
228                    return Ok(Vec::V2);
229                }
230                stream.set_position(saved_pos);
231            }
232            stream.set_position(saved_pos);
233            let saved_pos = stream.position();
234            // Try V4
235            {
236                let saved_pos = stream.position();
237                if stream.expect_string(".v4").is_ok() {
238                    return Ok(Vec::V4);
239                }
240                stream.set_position(saved_pos);
241            }
242            stream.set_position(saved_pos);
243            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
244            let expected = &["none", ".v2", ".v4"];
245            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
246            Err(crate::parser::unexpected_value(span, expected, found))
247        }
248    }
249
250    impl PtxParser for SuldBGeomCopVecDtypeMode {
251        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
252            stream.expect_string("suld")?;
253            stream.expect_string(".b")?;
254            let b = ();
255            stream.expect_complete()?;
256            let geom = Geom::parse(stream)?;
257            stream.expect_complete()?;
258            let saved_pos = stream.position();
259            let cop = match Cop::parse(stream) {
260                Ok(val) => Some(val),
261                Err(_) => {
262                    stream.set_position(saved_pos);
263                    None
264                }
265            };
266            stream.expect_complete()?;
267            let vec = Vec::parse(stream)?;
268            stream.expect_complete()?;
269            let dtype = Dtype::parse(stream)?;
270            stream.expect_complete()?;
271            let saved_pos = stream.position();
272            let mode = match Mode::parse(stream) {
273                Ok(val) => Some(val),
274                Err(_) => {
275                    stream.set_position(saved_pos);
276                    None
277                }
278            };
279            stream.expect_complete()?;
280            let d = GeneralOperand::parse(stream)?;
281            stream.expect_complete()?;
282            stream.expect(&PtxToken::Comma)?;
283            let a = TexHandler2::parse(stream)?;
284            stream.expect_complete()?;
285            stream.expect_complete()?;
286            stream.expect(&PtxToken::Semicolon)?;
287            Ok(SuldBGeomCopVecDtypeMode {
288                b,
289                geom,
290                cop,
291                vec,
292                dtype,
293                mode,
294                d,
295                a,
296            })
297        }
298    }
299
300
301}
302
ptx_parser/parser/instruction/suld.rs

ptx_parser/parser/instruction/
suld.rs
