ptx_parser/parser/instruction/
tld4.rs

1//! Original PTX specification:
2//!
3//! tld4.comp.2d.v4.dtype.f32    d{|p}, [a, c] {, e} {, f};
4//! tld4.comp.geom.v4.dtype.f32  d{|p}, [a, b, c] {, e} {, f};  // explicit sampler
5//! .comp  = { .r, .g, .b, .a };
6//! .geom  = { .2d, .a2d, .cube, .acube };
7//! .dtype = { .u32, .s32, .f32 };
8
9#![allow(unused)]
10
11use crate::lexer::PtxToken;
12use crate::parser::{PtxParseError, PtxParser, PtxTokenStream, Span};
13use crate::r#type::common::*;
14
15pub mod section_0 {
16    use super::*;
17    use crate::r#type::instruction::tld4::section_0::*;
18
19    // ============================================================================
20    // Generated enum parsers
21    // ============================================================================
22
23    impl PtxParser for Comp {
24        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
25            // Try R
26            {
27                let saved_pos = stream.position();
28                if stream.expect_string(".r").is_ok() {
29                    return Ok(Comp::R);
30                }
31                stream.set_position(saved_pos);
32            }
33            let saved_pos = stream.position();
34            // Try G
35            {
36                let saved_pos = stream.position();
37                if stream.expect_string(".g").is_ok() {
38                    return Ok(Comp::G);
39                }
40                stream.set_position(saved_pos);
41            }
42            stream.set_position(saved_pos);
43            let saved_pos = stream.position();
44            // Try B
45            {
46                let saved_pos = stream.position();
47                if stream.expect_string(".b").is_ok() {
48                    return Ok(Comp::B);
49                }
50                stream.set_position(saved_pos);
51            }
52            stream.set_position(saved_pos);
53            let saved_pos = stream.position();
54            // Try A
55            {
56                let saved_pos = stream.position();
57                if stream.expect_string(".a").is_ok() {
58                    return Ok(Comp::A);
59                }
60                stream.set_position(saved_pos);
61            }
62            stream.set_position(saved_pos);
63            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
64            let expected = &[".r", ".g", ".b", ".a"];
65            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
66            Err(crate::parser::unexpected_value(span, expected, found))
67        }
68    }
69
70    impl PtxParser for Dtype {
71        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
72            // Try U32
73            {
74                let saved_pos = stream.position();
75                if stream.expect_string(".u32").is_ok() {
76                    return Ok(Dtype::U32);
77                }
78                stream.set_position(saved_pos);
79            }
80            let saved_pos = stream.position();
81            // Try S32
82            {
83                let saved_pos = stream.position();
84                if stream.expect_string(".s32").is_ok() {
85                    return Ok(Dtype::S32);
86                }
87                stream.set_position(saved_pos);
88            }
89            stream.set_position(saved_pos);
90            let saved_pos = stream.position();
91            // Try F32
92            {
93                let saved_pos = stream.position();
94                if stream.expect_string(".f32").is_ok() {
95                    return Ok(Dtype::F32);
96                }
97                stream.set_position(saved_pos);
98            }
99            stream.set_position(saved_pos);
100            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
101            let expected = &[".u32", ".s32", ".f32"];
102            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
103            Err(crate::parser::unexpected_value(span, expected, found))
104        }
105    }
106
107    impl PtxParser for Geom {
108        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
109            // Try Acube
110            {
111                let saved_pos = stream.position();
112                if stream.expect_string(".acube").is_ok() {
113                    return Ok(Geom::Acube);
114                }
115                stream.set_position(saved_pos);
116            }
117            let saved_pos = stream.position();
118            // Try Cube
119            {
120                let saved_pos = stream.position();
121                if stream.expect_string(".cube").is_ok() {
122                    return Ok(Geom::Cube);
123                }
124                stream.set_position(saved_pos);
125            }
126            stream.set_position(saved_pos);
127            let saved_pos = stream.position();
128            // Try A2d
129            {
130                let saved_pos = stream.position();
131                if stream.expect_string(".a2d").is_ok() {
132                    return Ok(Geom::A2d);
133                }
134                stream.set_position(saved_pos);
135            }
136            stream.set_position(saved_pos);
137            let saved_pos = stream.position();
138            // Try _2d
139            {
140                let saved_pos = stream.position();
141                if stream.expect_string(".2d").is_ok() {
142                    return Ok(Geom::_2d);
143                }
144                stream.set_position(saved_pos);
145            }
146            stream.set_position(saved_pos);
147            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
148            let expected = &[".acube", ".cube", ".a2d", ".2d"];
149            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
150            Err(crate::parser::unexpected_value(span, expected, found))
151        }
152    }
153
154    impl PtxParser for Tld4Comp2dV4DtypeF32 {
155        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
156            stream.expect_string("tld4")?;
157            let comp = Comp::parse(stream)?;
158            stream.expect_complete()?;
159            stream.expect_string(".2d")?;
160            let _2d = ();
161            stream.expect_complete()?;
162            stream.expect_string(".v4")?;
163            let v4 = ();
164            stream.expect_complete()?;
165            let dtype = Dtype::parse(stream)?;
166            stream.expect_complete()?;
167            stream.expect_string(".f32")?;
168            let f32 = ();
169            stream.expect_complete()?;
170            let d = GeneralOperand::parse(stream)?;
171            let saved_pos = stream.position();
172            let p = if stream.consume_if(|t| matches!(t, PtxToken::Pipe)).is_some() {
173                Some(GeneralOperand::parse(stream)?)
174            } else {
175                stream.set_position(saved_pos);
176                None
177            };
178            stream.expect_complete()?;
179            stream.expect(&PtxToken::Comma)?;
180            let a = TexHandler2::parse(stream)?;
181            stream.expect_complete()?;
182            let saved_pos = stream.position();
183            let has_comma = stream.expect(&PtxToken::Comma).is_ok();
184            if !has_comma {
185                stream.set_position(saved_pos);
186            }
187            let saved_pos = stream.position();
188            let e = match GeneralOperand::parse(stream) {
189                Ok(val) => Some(val),
190                Err(_) => {
191                    stream.set_position(saved_pos);
192                    None
193                }
194            };
195            stream.expect_complete()?;
196            let saved_pos = stream.position();
197            let has_comma = stream.expect(&PtxToken::Comma).is_ok();
198            if !has_comma {
199                stream.set_position(saved_pos);
200            }
201            let saved_pos = stream.position();
202            let f = match GeneralOperand::parse(stream) {
203                Ok(val) => Some(val),
204                Err(_) => {
205                    stream.set_position(saved_pos);
206                    None
207                }
208            };
209            stream.expect_complete()?;
210            stream.expect_complete()?;
211            stream.expect(&PtxToken::Semicolon)?;
212            Ok(Tld4Comp2dV4DtypeF32 {
213                comp,
214                _2d,
215                v4,
216                dtype,
217                f32,
218                d,
219                p,
220                a,
221                e,
222                f,
223            })
224        }
225    }
226
227
228    impl PtxParser for Tld4CompGeomV4DtypeF32 {
229        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
230            stream.expect_string("tld4")?;
231            let comp = Comp::parse(stream)?;
232            stream.expect_complete()?;
233            let geom = Geom::parse(stream)?;
234            stream.expect_complete()?;
235            stream.expect_string(".v4")?;
236            let v4 = ();
237            stream.expect_complete()?;
238            let dtype = Dtype::parse(stream)?;
239            stream.expect_complete()?;
240            stream.expect_string(".f32")?;
241            let f32 = ();
242            stream.expect_complete()?;
243            let d = GeneralOperand::parse(stream)?;
244            let saved_pos = stream.position();
245            let p = if stream.consume_if(|t| matches!(t, PtxToken::Pipe)).is_some() {
246                Some(GeneralOperand::parse(stream)?)
247            } else {
248                stream.set_position(saved_pos);
249                None
250            };
251            stream.expect_complete()?;
252            stream.expect(&PtxToken::Comma)?;
253            let a = TexHandler3::parse(stream)?;
254            stream.expect_complete()?;
255            let saved_pos = stream.position();
256            let has_comma = stream.expect(&PtxToken::Comma).is_ok();
257            if !has_comma {
258                stream.set_position(saved_pos);
259            }
260            let saved_pos = stream.position();
261            let e = match GeneralOperand::parse(stream) {
262                Ok(val) => Some(val),
263                Err(_) => {
264                    stream.set_position(saved_pos);
265                    None
266                }
267            };
268            stream.expect_complete()?;
269            let saved_pos = stream.position();
270            let has_comma = stream.expect(&PtxToken::Comma).is_ok();
271            if !has_comma {
272                stream.set_position(saved_pos);
273            }
274            let saved_pos = stream.position();
275            let f = match GeneralOperand::parse(stream) {
276                Ok(val) => Some(val),
277                Err(_) => {
278                    stream.set_position(saved_pos);
279                    None
280                }
281            };
282            stream.expect_complete()?;
283            stream.expect_complete()?;
284            stream.expect(&PtxToken::Semicolon)?;
285            Ok(Tld4CompGeomV4DtypeF32 {
286                comp,
287                geom,
288                v4,
289                dtype,
290                f32,
291                d,
292                p,
293                a,
294                e,
295                f,
296            })
297        }
298    }
299
300
301}
302
ptx_parser/parser/instruction/tld4.rs

ptx_parser/parser/instruction/
tld4.rs
