ptx_parser/parser/instruction/
sured.rs

1//! Original PTX specification:
2//!
3//! sured.b.op.geom.ctype.mode [a,b],c; // byte addressing
4//! .op    = { .add, .min, .max, .and, .or };
5//! .geom  = { .1d, .2d, .3d };
6//! .ctype = { .u32, .u64, .s32, .b32, .s64 };  // for sured.b
7//! .mode  = { .trap, .clamp, .zero };
8//! ----------------------------------------------------
9//! sured.p.op.geom.ctype.mode [a,b],c; // sample addressing
10//! .op    = { .add, .min, .max, .and, .or };
11//! .geom  = { .1d, .2d, .3d };
12//! .ctype = { .b32, .b64 };                    // for sured.p
13//! .mode  = { .trap, .clamp, .zero };
14
15#![allow(unused)]
16
17use crate::lexer::PtxToken;
18use crate::parser::{PtxParseError, PtxParser, PtxTokenStream, Span};
19use crate::r#type::common::*;
20
21pub mod section_0 {
22    use super::*;
23    use crate::r#type::instruction::sured::section_0::*;
24
25    // ============================================================================
26    // Generated enum parsers
27    // ============================================================================
28
29    impl PtxParser for Ctype {
30        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
31            // Try U32
32            {
33                let saved_pos = stream.position();
34                if stream.expect_string(".u32").is_ok() {
35                    return Ok(Ctype::U32);
36                }
37                stream.set_position(saved_pos);
38            }
39            let saved_pos = stream.position();
40            // Try U64
41            {
42                let saved_pos = stream.position();
43                if stream.expect_string(".u64").is_ok() {
44                    return Ok(Ctype::U64);
45                }
46                stream.set_position(saved_pos);
47            }
48            stream.set_position(saved_pos);
49            let saved_pos = stream.position();
50            // Try S32
51            {
52                let saved_pos = stream.position();
53                if stream.expect_string(".s32").is_ok() {
54                    return Ok(Ctype::S32);
55                }
56                stream.set_position(saved_pos);
57            }
58            stream.set_position(saved_pos);
59            let saved_pos = stream.position();
60            // Try B32
61            {
62                let saved_pos = stream.position();
63                if stream.expect_string(".b32").is_ok() {
64                    return Ok(Ctype::B32);
65                }
66                stream.set_position(saved_pos);
67            }
68            stream.set_position(saved_pos);
69            let saved_pos = stream.position();
70            // Try S64
71            {
72                let saved_pos = stream.position();
73                if stream.expect_string(".s64").is_ok() {
74                    return Ok(Ctype::S64);
75                }
76                stream.set_position(saved_pos);
77            }
78            stream.set_position(saved_pos);
79            let span = stream
80                .peek()
81                .map(|(_, s)| s.clone())
82                .unwrap_or(Span { start: 0, end: 0 });
83            let expected = &[".u32", ".u64", ".s32", ".b32", ".s64"];
84            let found = stream
85                .peek()
86                .map(|(t, _)| format!("{:?}", t))
87                .unwrap_or_else(|_| "<end of input>".to_string());
88            Err(crate::parser::unexpected_value(span, expected, found))
89        }
90    }
91
92    impl PtxParser for Geom {
93        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
94            // Try _1d
95            {
96                let saved_pos = stream.position();
97                if stream.expect_string(".1d").is_ok() {
98                    return Ok(Geom::_1d);
99                }
100                stream.set_position(saved_pos);
101            }
102            let saved_pos = stream.position();
103            // Try _2d
104            {
105                let saved_pos = stream.position();
106                if stream.expect_string(".2d").is_ok() {
107                    return Ok(Geom::_2d);
108                }
109                stream.set_position(saved_pos);
110            }
111            stream.set_position(saved_pos);
112            let saved_pos = stream.position();
113            // Try _3d
114            {
115                let saved_pos = stream.position();
116                if stream.expect_string(".3d").is_ok() {
117                    return Ok(Geom::_3d);
118                }
119                stream.set_position(saved_pos);
120            }
121            stream.set_position(saved_pos);
122            let span = stream
123                .peek()
124                .map(|(_, s)| s.clone())
125                .unwrap_or(Span { start: 0, end: 0 });
126            let expected = &[".1d", ".2d", ".3d"];
127            let found = stream
128                .peek()
129                .map(|(t, _)| format!("{:?}", t))
130                .unwrap_or_else(|_| "<end of input>".to_string());
131            Err(crate::parser::unexpected_value(span, expected, found))
132        }
133    }
134
135    impl PtxParser for Mode {
136        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
137            // Try Clamp
138            {
139                let saved_pos = stream.position();
140                if stream.expect_string(".clamp").is_ok() {
141                    return Ok(Mode::Clamp);
142                }
143                stream.set_position(saved_pos);
144            }
145            let saved_pos = stream.position();
146            // Try Trap
147            {
148                let saved_pos = stream.position();
149                if stream.expect_string(".trap").is_ok() {
150                    return Ok(Mode::Trap);
151                }
152                stream.set_position(saved_pos);
153            }
154            stream.set_position(saved_pos);
155            let saved_pos = stream.position();
156            // Try Zero
157            {
158                let saved_pos = stream.position();
159                if stream.expect_string(".zero").is_ok() {
160                    return Ok(Mode::Zero);
161                }
162                stream.set_position(saved_pos);
163            }
164            stream.set_position(saved_pos);
165            let span = stream
166                .peek()
167                .map(|(_, s)| s.clone())
168                .unwrap_or(Span { start: 0, end: 0 });
169            let expected = &[".clamp", ".trap", ".zero"];
170            let found = stream
171                .peek()
172                .map(|(t, _)| format!("{:?}", t))
173                .unwrap_or_else(|_| "<end of input>".to_string());
174            Err(crate::parser::unexpected_value(span, expected, found))
175        }
176    }
177
178    impl PtxParser for Op {
179        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
180            // Try Add
181            {
182                let saved_pos = stream.position();
183                if stream.expect_string(".add").is_ok() {
184                    return Ok(Op::Add);
185                }
186                stream.set_position(saved_pos);
187            }
188            let saved_pos = stream.position();
189            // Try Min
190            {
191                let saved_pos = stream.position();
192                if stream.expect_string(".min").is_ok() {
193                    return Ok(Op::Min);
194                }
195                stream.set_position(saved_pos);
196            }
197            stream.set_position(saved_pos);
198            let saved_pos = stream.position();
199            // Try Max
200            {
201                let saved_pos = stream.position();
202                if stream.expect_string(".max").is_ok() {
203                    return Ok(Op::Max);
204                }
205                stream.set_position(saved_pos);
206            }
207            stream.set_position(saved_pos);
208            let saved_pos = stream.position();
209            // Try And
210            {
211                let saved_pos = stream.position();
212                if stream.expect_string(".and").is_ok() {
213                    return Ok(Op::And);
214                }
215                stream.set_position(saved_pos);
216            }
217            stream.set_position(saved_pos);
218            let saved_pos = stream.position();
219            // Try Or
220            {
221                let saved_pos = stream.position();
222                if stream.expect_string(".or").is_ok() {
223                    return Ok(Op::Or);
224                }
225                stream.set_position(saved_pos);
226            }
227            stream.set_position(saved_pos);
228            let span = stream
229                .peek()
230                .map(|(_, s)| s.clone())
231                .unwrap_or(Span { start: 0, end: 0 });
232            let expected = &[".add", ".min", ".max", ".and", ".or"];
233            let found = stream
234                .peek()
235                .map(|(t, _)| format!("{:?}", t))
236                .unwrap_or_else(|_| "<end of input>".to_string());
237            Err(crate::parser::unexpected_value(span, expected, found))
238        }
239    }
240
241    impl PtxParser for SuredBOpGeomCtypeMode {
242        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
243            stream.expect_string("sured")?;
244            stream.expect_string(".b")?;
245            let b = ();
246            stream.expect_complete()?;
247            let op = Op::parse(stream)?;
248            stream.expect_complete()?;
249            let geom = Geom::parse(stream)?;
250            stream.expect_complete()?;
251            let ctype = Ctype::parse(stream)?;
252            stream.expect_complete()?;
253            let mode = Mode::parse(stream)?;
254            stream.expect_complete()?;
255            let a = TexHandler2::parse(stream)?;
256            stream.expect_complete()?;
257            stream.expect(&PtxToken::Comma)?;
258            let c = GeneralOperand::parse(stream)?;
259            stream.expect_complete()?;
260            stream.expect_complete()?;
261            stream.expect(&PtxToken::Semicolon)?;
262            Ok(SuredBOpGeomCtypeMode {
263                b,
264                op,
265                geom,
266                ctype,
267                mode,
268                a,
269                c,
270            })
271        }
272    }
273}
274
275pub mod section_1 {
276    use super::*;
277    use crate::r#type::instruction::sured::section_1::*;
278
279    // ============================================================================
280    // Generated enum parsers
281    // ============================================================================
282
283    impl PtxParser for Ctype {
284        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
285            // Try B32
286            {
287                let saved_pos = stream.position();
288                if stream.expect_string(".b32").is_ok() {
289                    return Ok(Ctype::B32);
290                }
291                stream.set_position(saved_pos);
292            }
293            let saved_pos = stream.position();
294            // Try B64
295            {
296                let saved_pos = stream.position();
297                if stream.expect_string(".b64").is_ok() {
298                    return Ok(Ctype::B64);
299                }
300                stream.set_position(saved_pos);
301            }
302            stream.set_position(saved_pos);
303            let span = stream
304                .peek()
305                .map(|(_, s)| s.clone())
306                .unwrap_or(Span { start: 0, end: 0 });
307            let expected = &[".b32", ".b64"];
308            let found = stream
309                .peek()
310                .map(|(t, _)| format!("{:?}", t))
311                .unwrap_or_else(|_| "<end of input>".to_string());
312            Err(crate::parser::unexpected_value(span, expected, found))
313        }
314    }
315
316    impl PtxParser for Geom {
317        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
318            // Try _1d
319            {
320                let saved_pos = stream.position();
321                if stream.expect_string(".1d").is_ok() {
322                    return Ok(Geom::_1d);
323                }
324                stream.set_position(saved_pos);
325            }
326            let saved_pos = stream.position();
327            // Try _2d
328            {
329                let saved_pos = stream.position();
330                if stream.expect_string(".2d").is_ok() {
331                    return Ok(Geom::_2d);
332                }
333                stream.set_position(saved_pos);
334            }
335            stream.set_position(saved_pos);
336            let saved_pos = stream.position();
337            // Try _3d
338            {
339                let saved_pos = stream.position();
340                if stream.expect_string(".3d").is_ok() {
341                    return Ok(Geom::_3d);
342                }
343                stream.set_position(saved_pos);
344            }
345            stream.set_position(saved_pos);
346            let span = stream
347                .peek()
348                .map(|(_, s)| s.clone())
349                .unwrap_or(Span { start: 0, end: 0 });
350            let expected = &[".1d", ".2d", ".3d"];
351            let found = stream
352                .peek()
353                .map(|(t, _)| format!("{:?}", t))
354                .unwrap_or_else(|_| "<end of input>".to_string());
355            Err(crate::parser::unexpected_value(span, expected, found))
356        }
357    }
358
359    impl PtxParser for Mode {
360        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
361            // Try Clamp
362            {
363                let saved_pos = stream.position();
364                if stream.expect_string(".clamp").is_ok() {
365                    return Ok(Mode::Clamp);
366                }
367                stream.set_position(saved_pos);
368            }
369            let saved_pos = stream.position();
370            // Try Trap
371            {
372                let saved_pos = stream.position();
373                if stream.expect_string(".trap").is_ok() {
374                    return Ok(Mode::Trap);
375                }
376                stream.set_position(saved_pos);
377            }
378            stream.set_position(saved_pos);
379            let saved_pos = stream.position();
380            // Try Zero
381            {
382                let saved_pos = stream.position();
383                if stream.expect_string(".zero").is_ok() {
384                    return Ok(Mode::Zero);
385                }
386                stream.set_position(saved_pos);
387            }
388            stream.set_position(saved_pos);
389            let span = stream
390                .peek()
391                .map(|(_, s)| s.clone())
392                .unwrap_or(Span { start: 0, end: 0 });
393            let expected = &[".clamp", ".trap", ".zero"];
394            let found = stream
395                .peek()
396                .map(|(t, _)| format!("{:?}", t))
397                .unwrap_or_else(|_| "<end of input>".to_string());
398            Err(crate::parser::unexpected_value(span, expected, found))
399        }
400    }
401
402    impl PtxParser for Op {
403        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
404            // Try Add
405            {
406                let saved_pos = stream.position();
407                if stream.expect_string(".add").is_ok() {
408                    return Ok(Op::Add);
409                }
410                stream.set_position(saved_pos);
411            }
412            let saved_pos = stream.position();
413            // Try Min
414            {
415                let saved_pos = stream.position();
416                if stream.expect_string(".min").is_ok() {
417                    return Ok(Op::Min);
418                }
419                stream.set_position(saved_pos);
420            }
421            stream.set_position(saved_pos);
422            let saved_pos = stream.position();
423            // Try Max
424            {
425                let saved_pos = stream.position();
426                if stream.expect_string(".max").is_ok() {
427                    return Ok(Op::Max);
428                }
429                stream.set_position(saved_pos);
430            }
431            stream.set_position(saved_pos);
432            let saved_pos = stream.position();
433            // Try And
434            {
435                let saved_pos = stream.position();
436                if stream.expect_string(".and").is_ok() {
437                    return Ok(Op::And);
438                }
439                stream.set_position(saved_pos);
440            }
441            stream.set_position(saved_pos);
442            let saved_pos = stream.position();
443            // Try Or
444            {
445                let saved_pos = stream.position();
446                if stream.expect_string(".or").is_ok() {
447                    return Ok(Op::Or);
448                }
449                stream.set_position(saved_pos);
450            }
451            stream.set_position(saved_pos);
452            let span = stream
453                .peek()
454                .map(|(_, s)| s.clone())
455                .unwrap_or(Span { start: 0, end: 0 });
456            let expected = &[".add", ".min", ".max", ".and", ".or"];
457            let found = stream
458                .peek()
459                .map(|(t, _)| format!("{:?}", t))
460                .unwrap_or_else(|_| "<end of input>".to_string());
461            Err(crate::parser::unexpected_value(span, expected, found))
462        }
463    }
464
465    impl PtxParser for SuredPOpGeomCtypeMode {
466        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
467            stream.expect_string("sured")?;
468            stream.expect_string(".p")?;
469            let p = ();
470            stream.expect_complete()?;
471            let op = Op::parse(stream)?;
472            stream.expect_complete()?;
473            let geom = Geom::parse(stream)?;
474            stream.expect_complete()?;
475            let ctype = Ctype::parse(stream)?;
476            stream.expect_complete()?;
477            let mode = Mode::parse(stream)?;
478            stream.expect_complete()?;
479            let a = TexHandler2::parse(stream)?;
480            stream.expect_complete()?;
481            stream.expect(&PtxToken::Comma)?;
482            let c = GeneralOperand::parse(stream)?;
483            stream.expect_complete()?;
484            stream.expect_complete()?;
485            stream.expect(&PtxToken::Semicolon)?;
486            Ok(SuredPOpGeomCtypeMode {
487                p,
488                op,
489                geom,
490                ctype,
491                mode,
492                a,
493                c,
494            })
495        }
496    }
497}
ptx_parser/parser/instruction/sured.rs

ptx_parser/parser/instruction/
sured.rs
