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.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
80            let expected = &[".u32", ".u64", ".s32", ".b32", ".s64"];
81            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
82            Err(crate::parser::unexpected_value(span, expected, found))
83        }
84    }
85
86    impl PtxParser for Geom {
87        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
88            // Try _1d
89            {
90                let saved_pos = stream.position();
91                if stream.expect_string(".1d").is_ok() {
92                    return Ok(Geom::_1d);
93                }
94                stream.set_position(saved_pos);
95            }
96            let saved_pos = stream.position();
97            // Try _2d
98            {
99                let saved_pos = stream.position();
100                if stream.expect_string(".2d").is_ok() {
101                    return Ok(Geom::_2d);
102                }
103                stream.set_position(saved_pos);
104            }
105            stream.set_position(saved_pos);
106            let saved_pos = stream.position();
107            // Try _3d
108            {
109                let saved_pos = stream.position();
110                if stream.expect_string(".3d").is_ok() {
111                    return Ok(Geom::_3d);
112                }
113                stream.set_position(saved_pos);
114            }
115            stream.set_position(saved_pos);
116            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
117            let expected = &[".1d", ".2d", ".3d"];
118            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
119            Err(crate::parser::unexpected_value(span, expected, found))
120        }
121    }
122
123    impl PtxParser for Mode {
124        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
125            // Try Clamp
126            {
127                let saved_pos = stream.position();
128                if stream.expect_string(".clamp").is_ok() {
129                    return Ok(Mode::Clamp);
130                }
131                stream.set_position(saved_pos);
132            }
133            let saved_pos = stream.position();
134            // Try Trap
135            {
136                let saved_pos = stream.position();
137                if stream.expect_string(".trap").is_ok() {
138                    return Ok(Mode::Trap);
139                }
140                stream.set_position(saved_pos);
141            }
142            stream.set_position(saved_pos);
143            let saved_pos = stream.position();
144            // Try Zero
145            {
146                let saved_pos = stream.position();
147                if stream.expect_string(".zero").is_ok() {
148                    return Ok(Mode::Zero);
149                }
150                stream.set_position(saved_pos);
151            }
152            stream.set_position(saved_pos);
153            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
154            let expected = &[".clamp", ".trap", ".zero"];
155            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
156            Err(crate::parser::unexpected_value(span, expected, found))
157        }
158    }
159
160    impl PtxParser for Op {
161        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
162            // Try Add
163            {
164                let saved_pos = stream.position();
165                if stream.expect_string(".add").is_ok() {
166                    return Ok(Op::Add);
167                }
168                stream.set_position(saved_pos);
169            }
170            let saved_pos = stream.position();
171            // Try Min
172            {
173                let saved_pos = stream.position();
174                if stream.expect_string(".min").is_ok() {
175                    return Ok(Op::Min);
176                }
177                stream.set_position(saved_pos);
178            }
179            stream.set_position(saved_pos);
180            let saved_pos = stream.position();
181            // Try Max
182            {
183                let saved_pos = stream.position();
184                if stream.expect_string(".max").is_ok() {
185                    return Ok(Op::Max);
186                }
187                stream.set_position(saved_pos);
188            }
189            stream.set_position(saved_pos);
190            let saved_pos = stream.position();
191            // Try And
192            {
193                let saved_pos = stream.position();
194                if stream.expect_string(".and").is_ok() {
195                    return Ok(Op::And);
196                }
197                stream.set_position(saved_pos);
198            }
199            stream.set_position(saved_pos);
200            let saved_pos = stream.position();
201            // Try Or
202            {
203                let saved_pos = stream.position();
204                if stream.expect_string(".or").is_ok() {
205                    return Ok(Op::Or);
206                }
207                stream.set_position(saved_pos);
208            }
209            stream.set_position(saved_pos);
210            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
211            let expected = &[".add", ".min", ".max", ".and", ".or"];
212            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
213            Err(crate::parser::unexpected_value(span, expected, found))
214        }
215    }
216
217    impl PtxParser for SuredBOpGeomCtypeMode {
218        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
219            stream.expect_string("sured")?;
220            stream.expect_string(".b")?;
221            let b = ();
222            stream.expect_complete()?;
223            let op = Op::parse(stream)?;
224            stream.expect_complete()?;
225            let geom = Geom::parse(stream)?;
226            stream.expect_complete()?;
227            let ctype = Ctype::parse(stream)?;
228            stream.expect_complete()?;
229            let mode = Mode::parse(stream)?;
230            stream.expect_complete()?;
231            let a = TexHandler2::parse(stream)?;
232            stream.expect_complete()?;
233            stream.expect(&PtxToken::Comma)?;
234            let c = GeneralOperand::parse(stream)?;
235            stream.expect_complete()?;
236            stream.expect_complete()?;
237            stream.expect(&PtxToken::Semicolon)?;
238            Ok(SuredBOpGeomCtypeMode {
239                b,
240                op,
241                geom,
242                ctype,
243                mode,
244                a,
245                c,
246            })
247        }
248    }
249
250
251}
252
253pub mod section_1 {
254    use super::*;
255    use crate::r#type::instruction::sured::section_1::*;
256
257    // ============================================================================
258    // Generated enum parsers
259    // ============================================================================
260
261    impl PtxParser for Ctype {
262        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
263            // Try B32
264            {
265                let saved_pos = stream.position();
266                if stream.expect_string(".b32").is_ok() {
267                    return Ok(Ctype::B32);
268                }
269                stream.set_position(saved_pos);
270            }
271            let saved_pos = stream.position();
272            // Try B64
273            {
274                let saved_pos = stream.position();
275                if stream.expect_string(".b64").is_ok() {
276                    return Ok(Ctype::B64);
277                }
278                stream.set_position(saved_pos);
279            }
280            stream.set_position(saved_pos);
281            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
282            let expected = &[".b32", ".b64"];
283            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
284            Err(crate::parser::unexpected_value(span, expected, found))
285        }
286    }
287
288    impl PtxParser for Geom {
289        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
290            // Try _1d
291            {
292                let saved_pos = stream.position();
293                if stream.expect_string(".1d").is_ok() {
294                    return Ok(Geom::_1d);
295                }
296                stream.set_position(saved_pos);
297            }
298            let saved_pos = stream.position();
299            // Try _2d
300            {
301                let saved_pos = stream.position();
302                if stream.expect_string(".2d").is_ok() {
303                    return Ok(Geom::_2d);
304                }
305                stream.set_position(saved_pos);
306            }
307            stream.set_position(saved_pos);
308            let saved_pos = stream.position();
309            // Try _3d
310            {
311                let saved_pos = stream.position();
312                if stream.expect_string(".3d").is_ok() {
313                    return Ok(Geom::_3d);
314                }
315                stream.set_position(saved_pos);
316            }
317            stream.set_position(saved_pos);
318            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
319            let expected = &[".1d", ".2d", ".3d"];
320            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
321            Err(crate::parser::unexpected_value(span, expected, found))
322        }
323    }
324
325    impl PtxParser for Mode {
326        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
327            // Try Clamp
328            {
329                let saved_pos = stream.position();
330                if stream.expect_string(".clamp").is_ok() {
331                    return Ok(Mode::Clamp);
332                }
333                stream.set_position(saved_pos);
334            }
335            let saved_pos = stream.position();
336            // Try Trap
337            {
338                let saved_pos = stream.position();
339                if stream.expect_string(".trap").is_ok() {
340                    return Ok(Mode::Trap);
341                }
342                stream.set_position(saved_pos);
343            }
344            stream.set_position(saved_pos);
345            let saved_pos = stream.position();
346            // Try Zero
347            {
348                let saved_pos = stream.position();
349                if stream.expect_string(".zero").is_ok() {
350                    return Ok(Mode::Zero);
351                }
352                stream.set_position(saved_pos);
353            }
354            stream.set_position(saved_pos);
355            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
356            let expected = &[".clamp", ".trap", ".zero"];
357            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
358            Err(crate::parser::unexpected_value(span, expected, found))
359        }
360    }
361
362    impl PtxParser for Op {
363        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
364            // Try Add
365            {
366                let saved_pos = stream.position();
367                if stream.expect_string(".add").is_ok() {
368                    return Ok(Op::Add);
369                }
370                stream.set_position(saved_pos);
371            }
372            let saved_pos = stream.position();
373            // Try Min
374            {
375                let saved_pos = stream.position();
376                if stream.expect_string(".min").is_ok() {
377                    return Ok(Op::Min);
378                }
379                stream.set_position(saved_pos);
380            }
381            stream.set_position(saved_pos);
382            let saved_pos = stream.position();
383            // Try Max
384            {
385                let saved_pos = stream.position();
386                if stream.expect_string(".max").is_ok() {
387                    return Ok(Op::Max);
388                }
389                stream.set_position(saved_pos);
390            }
391            stream.set_position(saved_pos);
392            let saved_pos = stream.position();
393            // Try And
394            {
395                let saved_pos = stream.position();
396                if stream.expect_string(".and").is_ok() {
397                    return Ok(Op::And);
398                }
399                stream.set_position(saved_pos);
400            }
401            stream.set_position(saved_pos);
402            let saved_pos = stream.position();
403            // Try Or
404            {
405                let saved_pos = stream.position();
406                if stream.expect_string(".or").is_ok() {
407                    return Ok(Op::Or);
408                }
409                stream.set_position(saved_pos);
410            }
411            stream.set_position(saved_pos);
412            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
413            let expected = &[".add", ".min", ".max", ".and", ".or"];
414            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
415            Err(crate::parser::unexpected_value(span, expected, found))
416        }
417    }
418
419    impl PtxParser for SuredPOpGeomCtypeMode {
420        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
421            stream.expect_string("sured")?;
422            stream.expect_string(".p")?;
423            let p = ();
424            stream.expect_complete()?;
425            let op = Op::parse(stream)?;
426            stream.expect_complete()?;
427            let geom = Geom::parse(stream)?;
428            stream.expect_complete()?;
429            let ctype = Ctype::parse(stream)?;
430            stream.expect_complete()?;
431            let mode = Mode::parse(stream)?;
432            stream.expect_complete()?;
433            let a = TexHandler2::parse(stream)?;
434            stream.expect_complete()?;
435            stream.expect(&PtxToken::Comma)?;
436            let c = GeneralOperand::parse(stream)?;
437            stream.expect_complete()?;
438            stream.expect_complete()?;
439            stream.expect(&PtxToken::Semicolon)?;
440            Ok(SuredPOpGeomCtypeMode {
441                p,
442                op,
443                geom,
444                ctype,
445                mode,
446                a,
447                c,
448            })
449        }
450    }
451
452
453}
454
ptx_parser/parser/instruction/sured.rs

ptx_parser/parser/instruction/
sured.rs
