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
64                .peek()
65                .map(|(_, s)| s.clone())
66                .unwrap_or(Span { start: 0, end: 0 });
67            let expected = &[".r", ".g", ".b", ".a"];
68            let found = stream
69                .peek()
70                .map(|(t, _)| format!("{:?}", t))
71                .unwrap_or_else(|_| "<end of input>".to_string());
72            Err(crate::parser::unexpected_value(span, expected, found))
73        }
74    }
75
76    impl PtxParser for Dtype {
77        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
78            // Try U32
79            {
80                let saved_pos = stream.position();
81                if stream.expect_string(".u32").is_ok() {
82                    return Ok(Dtype::U32);
83                }
84                stream.set_position(saved_pos);
85            }
86            let saved_pos = stream.position();
87            // Try S32
88            {
89                let saved_pos = stream.position();
90                if stream.expect_string(".s32").is_ok() {
91                    return Ok(Dtype::S32);
92                }
93                stream.set_position(saved_pos);
94            }
95            stream.set_position(saved_pos);
96            let saved_pos = stream.position();
97            // Try F32
98            {
99                let saved_pos = stream.position();
100                if stream.expect_string(".f32").is_ok() {
101                    return Ok(Dtype::F32);
102                }
103                stream.set_position(saved_pos);
104            }
105            stream.set_position(saved_pos);
106            let span = stream
107                .peek()
108                .map(|(_, s)| s.clone())
109                .unwrap_or(Span { start: 0, end: 0 });
110            let expected = &[".u32", ".s32", ".f32"];
111            let found = stream
112                .peek()
113                .map(|(t, _)| format!("{:?}", t))
114                .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 Acube
122            {
123                let saved_pos = stream.position();
124                if stream.expect_string(".acube").is_ok() {
125                    return Ok(Geom::Acube);
126                }
127                stream.set_position(saved_pos);
128            }
129            let saved_pos = stream.position();
130            // Try Cube
131            {
132                let saved_pos = stream.position();
133                if stream.expect_string(".cube").is_ok() {
134                    return Ok(Geom::Cube);
135                }
136                stream.set_position(saved_pos);
137            }
138            stream.set_position(saved_pos);
139            let saved_pos = stream.position();
140            // Try A2d
141            {
142                let saved_pos = stream.position();
143                if stream.expect_string(".a2d").is_ok() {
144                    return Ok(Geom::A2d);
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 span = stream
160                .peek()
161                .map(|(_, s)| s.clone())
162                .unwrap_or(Span { start: 0, end: 0 });
163            let expected = &[".acube", ".cube", ".a2d", ".2d"];
164            let found = stream
165                .peek()
166                .map(|(t, _)| format!("{:?}", t))
167                .unwrap_or_else(|_| "<end of input>".to_string());
168            Err(crate::parser::unexpected_value(span, expected, found))
169        }
170    }
171
172    impl PtxParser for Tld4Comp2dV4DtypeF32 {
173        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
174            stream.expect_string("tld4")?;
175            let comp = Comp::parse(stream)?;
176            stream.expect_complete()?;
177            stream.expect_string(".2d")?;
178            let _2d = ();
179            stream.expect_complete()?;
180            stream.expect_string(".v4")?;
181            let v4 = ();
182            stream.expect_complete()?;
183            let dtype = Dtype::parse(stream)?;
184            stream.expect_complete()?;
185            stream.expect_string(".f32")?;
186            let f32 = ();
187            stream.expect_complete()?;
188            let d = GeneralOperand::parse(stream)?;
189            let saved_pos = stream.position();
190            let p = if stream.consume_if(|t| matches!(t, PtxToken::Pipe)).is_some() {
191                Some(GeneralOperand::parse(stream)?)
192            } else {
193                stream.set_position(saved_pos);
194                None
195            };
196            stream.expect_complete()?;
197            stream.expect(&PtxToken::Comma)?;
198            let a = TexHandler2::parse(stream)?;
199            stream.expect_complete()?;
200            let saved_pos = stream.position();
201            let has_comma = stream.expect(&PtxToken::Comma).is_ok();
202            if !has_comma {
203                stream.set_position(saved_pos);
204            }
205            let saved_pos = stream.position();
206            let e = match GeneralOperand::parse(stream) {
207                Ok(val) => Some(val),
208                Err(_) => {
209                    stream.set_position(saved_pos);
210                    None
211                }
212            };
213            stream.expect_complete()?;
214            let saved_pos = stream.position();
215            let has_comma = stream.expect(&PtxToken::Comma).is_ok();
216            if !has_comma {
217                stream.set_position(saved_pos);
218            }
219            let saved_pos = stream.position();
220            let f = match GeneralOperand::parse(stream) {
221                Ok(val) => Some(val),
222                Err(_) => {
223                    stream.set_position(saved_pos);
224                    None
225                }
226            };
227            stream.expect_complete()?;
228            stream.expect_complete()?;
229            stream.expect(&PtxToken::Semicolon)?;
230            Ok(Tld4Comp2dV4DtypeF32 {
231                comp,
232                _2d,
233                v4,
234                dtype,
235                f32,
236                d,
237                p,
238                a,
239                e,
240                f,
241            })
242        }
243    }
244
245    impl PtxParser for Tld4CompGeomV4DtypeF32 {
246        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
247            stream.expect_string("tld4")?;
248            let comp = Comp::parse(stream)?;
249            stream.expect_complete()?;
250            let geom = Geom::parse(stream)?;
251            stream.expect_complete()?;
252            stream.expect_string(".v4")?;
253            let v4 = ();
254            stream.expect_complete()?;
255            let dtype = Dtype::parse(stream)?;
256            stream.expect_complete()?;
257            stream.expect_string(".f32")?;
258            let f32 = ();
259            stream.expect_complete()?;
260            let d = GeneralOperand::parse(stream)?;
261            let saved_pos = stream.position();
262            let p = if stream.consume_if(|t| matches!(t, PtxToken::Pipe)).is_some() {
263                Some(GeneralOperand::parse(stream)?)
264            } else {
265                stream.set_position(saved_pos);
266                None
267            };
268            stream.expect_complete()?;
269            stream.expect(&PtxToken::Comma)?;
270            let a = TexHandler3::parse(stream)?;
271            stream.expect_complete()?;
272            let saved_pos = stream.position();
273            let has_comma = stream.expect(&PtxToken::Comma).is_ok();
274            if !has_comma {
275                stream.set_position(saved_pos);
276            }
277            let saved_pos = stream.position();
278            let e = match GeneralOperand::parse(stream) {
279                Ok(val) => Some(val),
280                Err(_) => {
281                    stream.set_position(saved_pos);
282                    None
283                }
284            };
285            stream.expect_complete()?;
286            let saved_pos = stream.position();
287            let has_comma = stream.expect(&PtxToken::Comma).is_ok();
288            if !has_comma {
289                stream.set_position(saved_pos);
290            }
291            let saved_pos = stream.position();
292            let f = match GeneralOperand::parse(stream) {
293                Ok(val) => Some(val),
294                Err(_) => {
295                    stream.set_position(saved_pos);
296                    None
297                }
298            };
299            stream.expect_complete()?;
300            stream.expect_complete()?;
301            stream.expect(&PtxToken::Semicolon)?;
302            Ok(Tld4CompGeomV4DtypeF32 {
303                comp,
304                geom,
305                v4,
306                dtype,
307                f32,
308                d,
309                p,
310                a,
311                e,
312                f,
313            })
314        }
315    }
316}
ptx_parser/parser/instruction/tld4.rs

ptx_parser/parser/instruction/
tld4.rs
