ptx_parser/parser/instruction/
txq.rs

1//! Original PTX specification:
2//!
3//! txq.tquery.b32         d, [a];       // texture attributes
4//! txq.level.tlquery.b32  d, [a], lod;  // texture attributes
5//! txq.squery.b32         d, [a];       // sampler attributes
6//! .tquery  = { .width, .height, .depth,
7//! .channel_data_type, .channel_order,
8//! .normalized_coords, .array_size,
9//! .num_mipmap_levels, .num_samples};
10//! .tlquery = { .width, .height, .depth };
11//! .squery  = { .force_unnormalized_coords, .filter_mode,
12//! .addr_mode_0, addr_mode_1, addr_mode_2 };
13
14#![allow(unused)]
15
16use crate::lexer::PtxToken;
17use crate::parser::{PtxParseError, PtxParser, PtxTokenStream, Span};
18use crate::r#type::common::*;
19
20pub mod section_0 {
21    use super::*;
22    use crate::r#type::instruction::txq::section_0::*;
23
24    // ============================================================================
25    // Generated enum parsers
26    // ============================================================================
27
28    impl PtxParser for Squery {
29        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
30            // Try ForceUnnormalizedCoords
31            {
32                let saved_pos = stream.position();
33                if stream.expect_string(".force_unnormalized_coords").is_ok() {
34                    return Ok(Squery::ForceUnnormalizedCoords);
35                }
36                stream.set_position(saved_pos);
37            }
38            let saved_pos = stream.position();
39            // Try FilterMode
40            {
41                let saved_pos = stream.position();
42                if stream.expect_string(".filter_mode").is_ok() {
43                    return Ok(Squery::FilterMode);
44                }
45                stream.set_position(saved_pos);
46            }
47            stream.set_position(saved_pos);
48            let saved_pos = stream.position();
49            // Try AddrMode0
50            {
51                let saved_pos = stream.position();
52                if stream.expect_string(".addr_mode_0").is_ok() {
53                    return Ok(Squery::AddrMode0);
54                }
55                stream.set_position(saved_pos);
56            }
57            stream.set_position(saved_pos);
58            let saved_pos = stream.position();
59            // Try AddrMode1
60            {
61                let saved_pos = stream.position();
62                if stream.expect_string("addr_mode_1").is_ok() {
63                    return Ok(Squery::AddrMode1);
64                }
65                stream.set_position(saved_pos);
66            }
67            stream.set_position(saved_pos);
68            let saved_pos = stream.position();
69            // Try AddrMode2
70            {
71                let saved_pos = stream.position();
72                if stream.expect_string("addr_mode_2").is_ok() {
73                    return Ok(Squery::AddrMode2);
74                }
75                stream.set_position(saved_pos);
76            }
77            stream.set_position(saved_pos);
78            let span = stream
79                .peek()
80                .map(|(_, s)| s.clone())
81                .unwrap_or(Span { start: 0, end: 0 });
82            let expected = &[
83                ".force_unnormalized_coords",
84                ".filter_mode",
85                ".addr_mode_0",
86                "addr_mode_1",
87                "addr_mode_2",
88            ];
89            let found = stream
90                .peek()
91                .map(|(t, _)| format!("{:?}", t))
92                .unwrap_or_else(|_| "<end of input>".to_string());
93            Err(crate::parser::unexpected_value(span, expected, found))
94        }
95    }
96
97    impl PtxParser for Tlquery {
98        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
99            // Try Height
100            {
101                let saved_pos = stream.position();
102                if stream.expect_string(".height").is_ok() {
103                    return Ok(Tlquery::Height);
104                }
105                stream.set_position(saved_pos);
106            }
107            let saved_pos = stream.position();
108            // Try Width
109            {
110                let saved_pos = stream.position();
111                if stream.expect_string(".width").is_ok() {
112                    return Ok(Tlquery::Width);
113                }
114                stream.set_position(saved_pos);
115            }
116            stream.set_position(saved_pos);
117            let saved_pos = stream.position();
118            // Try Depth
119            {
120                let saved_pos = stream.position();
121                if stream.expect_string(".depth").is_ok() {
122                    return Ok(Tlquery::Depth);
123                }
124                stream.set_position(saved_pos);
125            }
126            stream.set_position(saved_pos);
127            let span = stream
128                .peek()
129                .map(|(_, s)| s.clone())
130                .unwrap_or(Span { start: 0, end: 0 });
131            let expected = &[".height", ".width", ".depth"];
132            let found = stream
133                .peek()
134                .map(|(t, _)| format!("{:?}", t))
135                .unwrap_or_else(|_| "<end of input>".to_string());
136            Err(crate::parser::unexpected_value(span, expected, found))
137        }
138    }
139
140    impl PtxParser for Tquery {
141        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
142            // Try ChannelDataType
143            {
144                let saved_pos = stream.position();
145                if stream.expect_string(".channel_data_type").is_ok() {
146                    return Ok(Tquery::ChannelDataType);
147                }
148                stream.set_position(saved_pos);
149            }
150            let saved_pos = stream.position();
151            // Try NormalizedCoords
152            {
153                let saved_pos = stream.position();
154                if stream.expect_string(".normalized_coords").is_ok() {
155                    return Ok(Tquery::NormalizedCoords);
156                }
157                stream.set_position(saved_pos);
158            }
159            stream.set_position(saved_pos);
160            let saved_pos = stream.position();
161            // Try NumMipmapLevels
162            {
163                let saved_pos = stream.position();
164                if stream.expect_string(".num_mipmap_levels").is_ok() {
165                    return Ok(Tquery::NumMipmapLevels);
166                }
167                stream.set_position(saved_pos);
168            }
169            stream.set_position(saved_pos);
170            let saved_pos = stream.position();
171            // Try ChannelOrder
172            {
173                let saved_pos = stream.position();
174                if stream.expect_string(".channel_order").is_ok() {
175                    return Ok(Tquery::ChannelOrder);
176                }
177                stream.set_position(saved_pos);
178            }
179            stream.set_position(saved_pos);
180            let saved_pos = stream.position();
181            // Try NumSamples
182            {
183                let saved_pos = stream.position();
184                if stream.expect_string(".num_samples").is_ok() {
185                    return Ok(Tquery::NumSamples);
186                }
187                stream.set_position(saved_pos);
188            }
189            stream.set_position(saved_pos);
190            let saved_pos = stream.position();
191            // Try ArraySize
192            {
193                let saved_pos = stream.position();
194                if stream.expect_string(".array_size").is_ok() {
195                    return Ok(Tquery::ArraySize);
196                }
197                stream.set_position(saved_pos);
198            }
199            stream.set_position(saved_pos);
200            let saved_pos = stream.position();
201            // Try Height
202            {
203                let saved_pos = stream.position();
204                if stream.expect_string(".height").is_ok() {
205                    return Ok(Tquery::Height);
206                }
207                stream.set_position(saved_pos);
208            }
209            stream.set_position(saved_pos);
210            let saved_pos = stream.position();
211            // Try Width
212            {
213                let saved_pos = stream.position();
214                if stream.expect_string(".width").is_ok() {
215                    return Ok(Tquery::Width);
216                }
217                stream.set_position(saved_pos);
218            }
219            stream.set_position(saved_pos);
220            let saved_pos = stream.position();
221            // Try Depth
222            {
223                let saved_pos = stream.position();
224                if stream.expect_string(".depth").is_ok() {
225                    return Ok(Tquery::Depth);
226                }
227                stream.set_position(saved_pos);
228            }
229            stream.set_position(saved_pos);
230            let span = stream
231                .peek()
232                .map(|(_, s)| s.clone())
233                .unwrap_or(Span { start: 0, end: 0 });
234            let expected = &[
235                ".channel_data_type",
236                ".normalized_coords",
237                ".num_mipmap_levels",
238                ".channel_order",
239                ".num_samples",
240                ".array_size",
241                ".height",
242                ".width",
243                ".depth",
244            ];
245            let found = stream
246                .peek()
247                .map(|(t, _)| format!("{:?}", t))
248                .unwrap_or_else(|_| "<end of input>".to_string());
249            Err(crate::parser::unexpected_value(span, expected, found))
250        }
251    }
252
253    impl PtxParser for TxqTqueryB32 {
254        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
255            stream.expect_string("txq")?;
256            let tquery = Tquery::parse(stream)?;
257            stream.expect_complete()?;
258            stream.expect_string(".b32")?;
259            let b32 = ();
260            stream.expect_complete()?;
261            let d = GeneralOperand::parse(stream)?;
262            stream.expect_complete()?;
263            stream.expect(&PtxToken::Comma)?;
264            let a = AddressOperand::parse(stream)?;
265            stream.expect_complete()?;
266            stream.expect_complete()?;
267            stream.expect(&PtxToken::Semicolon)?;
268            Ok(TxqTqueryB32 { tquery, b32, d, a })
269        }
270    }
271
272    impl PtxParser for TxqLevelTlqueryB32 {
273        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
274            stream.expect_string("txq")?;
275            stream.expect_string(".level")?;
276            let level = ();
277            stream.expect_complete()?;
278            let tlquery = Tlquery::parse(stream)?;
279            stream.expect_complete()?;
280            stream.expect_string(".b32")?;
281            let b32 = ();
282            stream.expect_complete()?;
283            let d = GeneralOperand::parse(stream)?;
284            stream.expect_complete()?;
285            stream.expect(&PtxToken::Comma)?;
286            let a = AddressOperand::parse(stream)?;
287            stream.expect_complete()?;
288            stream.expect(&PtxToken::Comma)?;
289            let lod = GeneralOperand::parse(stream)?;
290            stream.expect_complete()?;
291            stream.expect_complete()?;
292            stream.expect(&PtxToken::Semicolon)?;
293            Ok(TxqLevelTlqueryB32 {
294                level,
295                tlquery,
296                b32,
297                d,
298                a,
299                lod,
300            })
301        }
302    }
303
304    impl PtxParser for TxqSqueryB32 {
305        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
306            stream.expect_string("txq")?;
307            let squery = Squery::parse(stream)?;
308            stream.expect_complete()?;
309            stream.expect_string(".b32")?;
310            let b32 = ();
311            stream.expect_complete()?;
312            let d = GeneralOperand::parse(stream)?;
313            stream.expect_complete()?;
314            stream.expect(&PtxToken::Comma)?;
315            let a = AddressOperand::parse(stream)?;
316            stream.expect_complete()?;
317            stream.expect_complete()?;
318            stream.expect(&PtxToken::Semicolon)?;
319            Ok(TxqSqueryB32 { squery, b32, d, a })
320        }
321    }
322}
ptx_parser/parser/instruction/txq.rs

ptx_parser/parser/instruction/
txq.rs
