ptx_parser/parser/instruction/
tex.rs

1//! Original PTX specification:
2//!
3//! tex.geom.v4.dtype.ctype  d{|p}, [a, c] {, e} {, f};
4//! tex.geom.v4.dtype.ctype  d{|p}, [a, b, c] {, e} {, f};  // explicit sampler
5//! tex.geom.v2.f16x2.ctype  d{|p}, [a, c] {, e} {, f};
6//! tex.geom.v2.f16x2.ctype  d{|p}, [a, b, c] {, e} {, f};  // explicit sampler
7//! // mipmaps
8//! tex.base.geom.v4.dtype.ctype   d{|p}, [a, {b,} c] {, e} {, f};
9//! tex.level.geom.v4.dtype.ctype  d{|p}, [a, {b,} c], lod {, e} {, f};
10//! tex.grad.geom.v4.dtype.ctype   d{|p}, [a, {b,} c], dPdx, dPdy {, e} {, f};
11//! tex.base.geom.v2.f16x2.ctype   d{|p}, [a, {b,} c] {, e} {, f};
12//! tex.level.geom.v2.f16x2.ctype  d{|p}, [a, {b,} c], lod {, e} {, f};
13//! tex.grad.geom.v2.f16x2.ctype   d{|p}, [a, {b,} c], dPdx, dPdy {, e} {, f};
14//! .geom  = { .1d, .2d, .3d, .a1d, .a2d, .cube, .acube, .2dms, .a2dms };
15//! .dtype = { .u32, .s32, .f16,  .f32 };
16//! .ctype = {       .s32, .f32 };          // .cube, .acube require .f32
17//! // .2dms, .a2dms require .s32
18
19#![allow(unused)]
20
21use crate::lexer::PtxToken;
22use crate::parser::{PtxParseError, PtxParser, PtxTokenStream, Span};
23use crate::r#type::common::*;
24
25pub mod section_0 {
26    use super::*;
27    use crate::r#type::instruction::tex::section_0::*;
28
29    // ============================================================================
30    // Generated enum parsers
31    // ============================================================================
32
33    impl PtxParser for Ctype {
34        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
35            // Try S32
36            {
37                let saved_pos = stream.position();
38                if stream.expect_string(".s32").is_ok() {
39                    return Ok(Ctype::S32);
40                }
41                stream.set_position(saved_pos);
42            }
43            let saved_pos = stream.position();
44            // Try F32
45            {
46                let saved_pos = stream.position();
47                if stream.expect_string(".f32").is_ok() {
48                    return Ok(Ctype::F32);
49                }
50                stream.set_position(saved_pos);
51            }
52            stream.set_position(saved_pos);
53            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
54            let expected = &[".s32", ".f32"];
55            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
56            Err(crate::parser::unexpected_value(span, expected, found))
57        }
58    }
59
60    impl PtxParser for Dtype {
61        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
62            // Try U32
63            {
64                let saved_pos = stream.position();
65                if stream.expect_string(".u32").is_ok() {
66                    return Ok(Dtype::U32);
67                }
68                stream.set_position(saved_pos);
69            }
70            let saved_pos = stream.position();
71            // Try S32
72            {
73                let saved_pos = stream.position();
74                if stream.expect_string(".s32").is_ok() {
75                    return Ok(Dtype::S32);
76                }
77                stream.set_position(saved_pos);
78            }
79            stream.set_position(saved_pos);
80            let saved_pos = stream.position();
81            // Try F16
82            {
83                let saved_pos = stream.position();
84                if stream.expect_string(".f16").is_ok() {
85                    return Ok(Dtype::F16);
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", ".f16", ".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 A2dms
119            {
120                let saved_pos = stream.position();
121                if stream.expect_string(".a2dms").is_ok() {
122                    return Ok(Geom::A2dms);
123                }
124                stream.set_position(saved_pos);
125            }
126            stream.set_position(saved_pos);
127            let saved_pos = stream.position();
128            // Try Cube
129            {
130                let saved_pos = stream.position();
131                if stream.expect_string(".cube").is_ok() {
132                    return Ok(Geom::Cube);
133                }
134                stream.set_position(saved_pos);
135            }
136            stream.set_position(saved_pos);
137            let saved_pos = stream.position();
138            // Try _2dms
139            {
140                let saved_pos = stream.position();
141                if stream.expect_string(".2dms").is_ok() {
142                    return Ok(Geom::_2dms);
143                }
144                stream.set_position(saved_pos);
145            }
146            stream.set_position(saved_pos);
147            let saved_pos = stream.position();
148            // Try A1d
149            {
150                let saved_pos = stream.position();
151                if stream.expect_string(".a1d").is_ok() {
152                    return Ok(Geom::A1d);
153                }
154                stream.set_position(saved_pos);
155            }
156            stream.set_position(saved_pos);
157            let saved_pos = stream.position();
158            // Try A2d
159            {
160                let saved_pos = stream.position();
161                if stream.expect_string(".a2d").is_ok() {
162                    return Ok(Geom::A2d);
163                }
164                stream.set_position(saved_pos);
165            }
166            stream.set_position(saved_pos);
167            let saved_pos = stream.position();
168            // Try _1d
169            {
170                let saved_pos = stream.position();
171                if stream.expect_string(".1d").is_ok() {
172                    return Ok(Geom::_1d);
173                }
174                stream.set_position(saved_pos);
175            }
176            stream.set_position(saved_pos);
177            let saved_pos = stream.position();
178            // Try _2d
179            {
180                let saved_pos = stream.position();
181                if stream.expect_string(".2d").is_ok() {
182                    return Ok(Geom::_2d);
183                }
184                stream.set_position(saved_pos);
185            }
186            stream.set_position(saved_pos);
187            let saved_pos = stream.position();
188            // Try _3d
189            {
190                let saved_pos = stream.position();
191                if stream.expect_string(".3d").is_ok() {
192                    return Ok(Geom::_3d);
193                }
194                stream.set_position(saved_pos);
195            }
196            stream.set_position(saved_pos);
197            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
198            let expected = &[".acube", ".a2dms", ".cube", ".2dms", ".a1d", ".a2d", ".1d", ".2d", ".3d"];
199            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
200            Err(crate::parser::unexpected_value(span, expected, found))
201        }
202    }
203
204    impl PtxParser for TexGeomV4DtypeCtype {
205        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
206            stream.expect_string("tex")?;
207            let geom = Geom::parse(stream)?;
208            stream.expect_complete()?;
209            stream.expect_string(".v4")?;
210            let v4 = ();
211            stream.expect_complete()?;
212            let dtype = Dtype::parse(stream)?;
213            stream.expect_complete()?;
214            let ctype = Ctype::parse(stream)?;
215            stream.expect_complete()?;
216            let d = GeneralOperand::parse(stream)?;
217            let saved_pos = stream.position();
218            let p = if stream.consume_if(|t| matches!(t, PtxToken::Pipe)).is_some() {
219                Some(GeneralOperand::parse(stream)?)
220            } else {
221                stream.set_position(saved_pos);
222                None
223            };
224            stream.expect_complete()?;
225            stream.expect(&PtxToken::Comma)?;
226            let a = TexHandler2::parse(stream)?;
227            stream.expect_complete()?;
228            let saved_pos = stream.position();
229            let has_comma = stream.expect(&PtxToken::Comma).is_ok();
230            if !has_comma {
231                stream.set_position(saved_pos);
232            }
233            let saved_pos = stream.position();
234            let e = match GeneralOperand::parse(stream) {
235                Ok(val) => Some(val),
236                Err(_) => {
237                    stream.set_position(saved_pos);
238                    None
239                }
240            };
241            stream.expect_complete()?;
242            let saved_pos = stream.position();
243            let has_comma = stream.expect(&PtxToken::Comma).is_ok();
244            if !has_comma {
245                stream.set_position(saved_pos);
246            }
247            let saved_pos = stream.position();
248            let f = match GeneralOperand::parse(stream) {
249                Ok(val) => Some(val),
250                Err(_) => {
251                    stream.set_position(saved_pos);
252                    None
253                }
254            };
255            stream.expect_complete()?;
256            stream.expect_complete()?;
257            stream.expect(&PtxToken::Semicolon)?;
258            Ok(TexGeomV4DtypeCtype {
259                geom,
260                v4,
261                dtype,
262                ctype,
263                d,
264                p,
265                a,
266                e,
267                f,
268            })
269        }
270    }
271
272
273    impl PtxParser for TexGeomV4DtypeCtype1 {
274        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
275            stream.expect_string("tex")?;
276            let geom = Geom::parse(stream)?;
277            stream.expect_complete()?;
278            stream.expect_string(".v4")?;
279            let v4 = ();
280            stream.expect_complete()?;
281            let dtype = Dtype::parse(stream)?;
282            stream.expect_complete()?;
283            let ctype = Ctype::parse(stream)?;
284            stream.expect_complete()?;
285            let d = GeneralOperand::parse(stream)?;
286            let saved_pos = stream.position();
287            let p = if stream.consume_if(|t| matches!(t, PtxToken::Pipe)).is_some() {
288                Some(GeneralOperand::parse(stream)?)
289            } else {
290                stream.set_position(saved_pos);
291                None
292            };
293            stream.expect_complete()?;
294            stream.expect(&PtxToken::Comma)?;
295            let a = TexHandler3::parse(stream)?;
296            stream.expect_complete()?;
297            let saved_pos = stream.position();
298            let has_comma = stream.expect(&PtxToken::Comma).is_ok();
299            if !has_comma {
300                stream.set_position(saved_pos);
301            }
302            let saved_pos = stream.position();
303            let e = match GeneralOperand::parse(stream) {
304                Ok(val) => Some(val),
305                Err(_) => {
306                    stream.set_position(saved_pos);
307                    None
308                }
309            };
310            stream.expect_complete()?;
311            let saved_pos = stream.position();
312            let has_comma = stream.expect(&PtxToken::Comma).is_ok();
313            if !has_comma {
314                stream.set_position(saved_pos);
315            }
316            let saved_pos = stream.position();
317            let f = match GeneralOperand::parse(stream) {
318                Ok(val) => Some(val),
319                Err(_) => {
320                    stream.set_position(saved_pos);
321                    None
322                }
323            };
324            stream.expect_complete()?;
325            stream.expect_complete()?;
326            stream.expect(&PtxToken::Semicolon)?;
327            Ok(TexGeomV4DtypeCtype1 {
328                geom,
329                v4,
330                dtype,
331                ctype,
332                d,
333                p,
334                a,
335                e,
336                f,
337            })
338        }
339    }
340
341
342    impl PtxParser for TexGeomV2F16x2Ctype {
343        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
344            stream.expect_string("tex")?;
345            let geom = Geom::parse(stream)?;
346            stream.expect_complete()?;
347            stream.expect_string(".v2")?;
348            let v2 = ();
349            stream.expect_complete()?;
350            stream.expect_string(".f16x2")?;
351            let f16x2 = ();
352            stream.expect_complete()?;
353            let ctype = Ctype::parse(stream)?;
354            stream.expect_complete()?;
355            let d = GeneralOperand::parse(stream)?;
356            let saved_pos = stream.position();
357            let p = if stream.consume_if(|t| matches!(t, PtxToken::Pipe)).is_some() {
358                Some(GeneralOperand::parse(stream)?)
359            } else {
360                stream.set_position(saved_pos);
361                None
362            };
363            stream.expect_complete()?;
364            stream.expect(&PtxToken::Comma)?;
365            let a = TexHandler2::parse(stream)?;
366            stream.expect_complete()?;
367            let saved_pos = stream.position();
368            let has_comma = stream.expect(&PtxToken::Comma).is_ok();
369            if !has_comma {
370                stream.set_position(saved_pos);
371            }
372            let saved_pos = stream.position();
373            let e = match GeneralOperand::parse(stream) {
374                Ok(val) => Some(val),
375                Err(_) => {
376                    stream.set_position(saved_pos);
377                    None
378                }
379            };
380            stream.expect_complete()?;
381            let saved_pos = stream.position();
382            let has_comma = stream.expect(&PtxToken::Comma).is_ok();
383            if !has_comma {
384                stream.set_position(saved_pos);
385            }
386            let saved_pos = stream.position();
387            let f = match GeneralOperand::parse(stream) {
388                Ok(val) => Some(val),
389                Err(_) => {
390                    stream.set_position(saved_pos);
391                    None
392                }
393            };
394            stream.expect_complete()?;
395            stream.expect_complete()?;
396            stream.expect(&PtxToken::Semicolon)?;
397            Ok(TexGeomV2F16x2Ctype {
398                geom,
399                v2,
400                f16x2,
401                ctype,
402                d,
403                p,
404                a,
405                e,
406                f,
407            })
408        }
409    }
410
411
412    impl PtxParser for TexGeomV2F16x2Ctype1 {
413        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
414            stream.expect_string("tex")?;
415            let geom = Geom::parse(stream)?;
416            stream.expect_complete()?;
417            stream.expect_string(".v2")?;
418            let v2 = ();
419            stream.expect_complete()?;
420            stream.expect_string(".f16x2")?;
421            let f16x2 = ();
422            stream.expect_complete()?;
423            let ctype = Ctype::parse(stream)?;
424            stream.expect_complete()?;
425            let d = GeneralOperand::parse(stream)?;
426            let saved_pos = stream.position();
427            let p = if stream.consume_if(|t| matches!(t, PtxToken::Pipe)).is_some() {
428                Some(GeneralOperand::parse(stream)?)
429            } else {
430                stream.set_position(saved_pos);
431                None
432            };
433            stream.expect_complete()?;
434            stream.expect(&PtxToken::Comma)?;
435            let a = TexHandler3::parse(stream)?;
436            stream.expect_complete()?;
437            let saved_pos = stream.position();
438            let has_comma = stream.expect(&PtxToken::Comma).is_ok();
439            if !has_comma {
440                stream.set_position(saved_pos);
441            }
442            let saved_pos = stream.position();
443            let e = match GeneralOperand::parse(stream) {
444                Ok(val) => Some(val),
445                Err(_) => {
446                    stream.set_position(saved_pos);
447                    None
448                }
449            };
450            stream.expect_complete()?;
451            let saved_pos = stream.position();
452            let has_comma = stream.expect(&PtxToken::Comma).is_ok();
453            if !has_comma {
454                stream.set_position(saved_pos);
455            }
456            let saved_pos = stream.position();
457            let f = match GeneralOperand::parse(stream) {
458                Ok(val) => Some(val),
459                Err(_) => {
460                    stream.set_position(saved_pos);
461                    None
462                }
463            };
464            stream.expect_complete()?;
465            stream.expect_complete()?;
466            stream.expect(&PtxToken::Semicolon)?;
467            Ok(TexGeomV2F16x2Ctype1 {
468                geom,
469                v2,
470                f16x2,
471                ctype,
472                d,
473                p,
474                a,
475                e,
476                f,
477            })
478        }
479    }
480
481
482    impl PtxParser for TexBaseGeomV4DtypeCtype {
483        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
484            stream.expect_string("tex")?;
485            stream.expect_string(".base")?;
486            let base = ();
487            stream.expect_complete()?;
488            let geom = Geom::parse(stream)?;
489            stream.expect_complete()?;
490            stream.expect_string(".v4")?;
491            let v4 = ();
492            stream.expect_complete()?;
493            let dtype = Dtype::parse(stream)?;
494            stream.expect_complete()?;
495            let ctype = Ctype::parse(stream)?;
496            stream.expect_complete()?;
497            let d = GeneralOperand::parse(stream)?;
498            let saved_pos = stream.position();
499            let p = if stream.consume_if(|t| matches!(t, PtxToken::Pipe)).is_some() {
500                Some(GeneralOperand::parse(stream)?)
501            } else {
502                stream.set_position(saved_pos);
503                None
504            };
505            stream.expect_complete()?;
506            stream.expect(&PtxToken::Comma)?;
507            let a = TexHandler3Optional::parse(stream)?;
508            stream.expect_complete()?;
509            let saved_pos = stream.position();
510            let has_comma = stream.expect(&PtxToken::Comma).is_ok();
511            if !has_comma {
512                stream.set_position(saved_pos);
513            }
514            let saved_pos = stream.position();
515            let e = match GeneralOperand::parse(stream) {
516                Ok(val) => Some(val),
517                Err(_) => {
518                    stream.set_position(saved_pos);
519                    None
520                }
521            };
522            stream.expect_complete()?;
523            let saved_pos = stream.position();
524            let has_comma = stream.expect(&PtxToken::Comma).is_ok();
525            if !has_comma {
526                stream.set_position(saved_pos);
527            }
528            let saved_pos = stream.position();
529            let f = match GeneralOperand::parse(stream) {
530                Ok(val) => Some(val),
531                Err(_) => {
532                    stream.set_position(saved_pos);
533                    None
534                }
535            };
536            stream.expect_complete()?;
537            stream.expect_complete()?;
538            stream.expect(&PtxToken::Semicolon)?;
539            Ok(TexBaseGeomV4DtypeCtype {
540                base,
541                geom,
542                v4,
543                dtype,
544                ctype,
545                d,
546                p,
547                a,
548                e,
549                f,
550            })
551        }
552    }
553
554
555    impl PtxParser for TexLevelGeomV4DtypeCtype {
556        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
557            stream.expect_string("tex")?;
558            stream.expect_string(".level")?;
559            let level = ();
560            stream.expect_complete()?;
561            let geom = Geom::parse(stream)?;
562            stream.expect_complete()?;
563            stream.expect_string(".v4")?;
564            let v4 = ();
565            stream.expect_complete()?;
566            let dtype = Dtype::parse(stream)?;
567            stream.expect_complete()?;
568            let ctype = Ctype::parse(stream)?;
569            stream.expect_complete()?;
570            let d = GeneralOperand::parse(stream)?;
571            let saved_pos = stream.position();
572            let p = if stream.consume_if(|t| matches!(t, PtxToken::Pipe)).is_some() {
573                Some(GeneralOperand::parse(stream)?)
574            } else {
575                stream.set_position(saved_pos);
576                None
577            };
578            stream.expect_complete()?;
579            stream.expect(&PtxToken::Comma)?;
580            let a = TexHandler3Optional::parse(stream)?;
581            stream.expect_complete()?;
582            stream.expect(&PtxToken::Comma)?;
583            let lod = GeneralOperand::parse(stream)?;
584            stream.expect_complete()?;
585            let saved_pos = stream.position();
586            let has_comma = stream.expect(&PtxToken::Comma).is_ok();
587            if !has_comma {
588                stream.set_position(saved_pos);
589            }
590            let saved_pos = stream.position();
591            let e = match GeneralOperand::parse(stream) {
592                Ok(val) => Some(val),
593                Err(_) => {
594                    stream.set_position(saved_pos);
595                    None
596                }
597            };
598            stream.expect_complete()?;
599            let saved_pos = stream.position();
600            let has_comma = stream.expect(&PtxToken::Comma).is_ok();
601            if !has_comma {
602                stream.set_position(saved_pos);
603            }
604            let saved_pos = stream.position();
605            let f = match GeneralOperand::parse(stream) {
606                Ok(val) => Some(val),
607                Err(_) => {
608                    stream.set_position(saved_pos);
609                    None
610                }
611            };
612            stream.expect_complete()?;
613            stream.expect_complete()?;
614            stream.expect(&PtxToken::Semicolon)?;
615            Ok(TexLevelGeomV4DtypeCtype {
616                level,
617                geom,
618                v4,
619                dtype,
620                ctype,
621                d,
622                p,
623                a,
624                lod,
625                e,
626                f,
627            })
628        }
629    }
630
631
632    impl PtxParser for TexGradGeomV4DtypeCtype {
633        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
634            stream.expect_string("tex")?;
635            stream.expect_string(".grad")?;
636            let grad = ();
637            stream.expect_complete()?;
638            let geom = Geom::parse(stream)?;
639            stream.expect_complete()?;
640            stream.expect_string(".v4")?;
641            let v4 = ();
642            stream.expect_complete()?;
643            let dtype = Dtype::parse(stream)?;
644            stream.expect_complete()?;
645            let ctype = Ctype::parse(stream)?;
646            stream.expect_complete()?;
647            let d = GeneralOperand::parse(stream)?;
648            let saved_pos = stream.position();
649            let p = if stream.consume_if(|t| matches!(t, PtxToken::Pipe)).is_some() {
650                Some(GeneralOperand::parse(stream)?)
651            } else {
652                stream.set_position(saved_pos);
653                None
654            };
655            stream.expect_complete()?;
656            stream.expect(&PtxToken::Comma)?;
657            let a = TexHandler3Optional::parse(stream)?;
658            stream.expect_complete()?;
659            stream.expect(&PtxToken::Comma)?;
660            let dpdx = GeneralOperand::parse(stream)?;
661            stream.expect_complete()?;
662            stream.expect(&PtxToken::Comma)?;
663            let dpdy = GeneralOperand::parse(stream)?;
664            stream.expect_complete()?;
665            let saved_pos = stream.position();
666            let has_comma = stream.expect(&PtxToken::Comma).is_ok();
667            if !has_comma {
668                stream.set_position(saved_pos);
669            }
670            let saved_pos = stream.position();
671            let e = match GeneralOperand::parse(stream) {
672                Ok(val) => Some(val),
673                Err(_) => {
674                    stream.set_position(saved_pos);
675                    None
676                }
677            };
678            stream.expect_complete()?;
679            let saved_pos = stream.position();
680            let has_comma = stream.expect(&PtxToken::Comma).is_ok();
681            if !has_comma {
682                stream.set_position(saved_pos);
683            }
684            let saved_pos = stream.position();
685            let f = match GeneralOperand::parse(stream) {
686                Ok(val) => Some(val),
687                Err(_) => {
688                    stream.set_position(saved_pos);
689                    None
690                }
691            };
692            stream.expect_complete()?;
693            stream.expect_complete()?;
694            stream.expect(&PtxToken::Semicolon)?;
695            Ok(TexGradGeomV4DtypeCtype {
696                grad,
697                geom,
698                v4,
699                dtype,
700                ctype,
701                d,
702                p,
703                a,
704                dpdx,
705                dpdy,
706                e,
707                f,
708            })
709        }
710    }
711
712
713    impl PtxParser for TexBaseGeomV2F16x2Ctype {
714        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
715            stream.expect_string("tex")?;
716            stream.expect_string(".base")?;
717            let base = ();
718            stream.expect_complete()?;
719            let geom = Geom::parse(stream)?;
720            stream.expect_complete()?;
721            stream.expect_string(".v2")?;
722            let v2 = ();
723            stream.expect_complete()?;
724            stream.expect_string(".f16x2")?;
725            let f16x2 = ();
726            stream.expect_complete()?;
727            let ctype = Ctype::parse(stream)?;
728            stream.expect_complete()?;
729            let d = GeneralOperand::parse(stream)?;
730            let saved_pos = stream.position();
731            let p = if stream.consume_if(|t| matches!(t, PtxToken::Pipe)).is_some() {
732                Some(GeneralOperand::parse(stream)?)
733            } else {
734                stream.set_position(saved_pos);
735                None
736            };
737            stream.expect_complete()?;
738            stream.expect(&PtxToken::Comma)?;
739            let a = TexHandler3Optional::parse(stream)?;
740            stream.expect_complete()?;
741            let saved_pos = stream.position();
742            let has_comma = stream.expect(&PtxToken::Comma).is_ok();
743            if !has_comma {
744                stream.set_position(saved_pos);
745            }
746            let saved_pos = stream.position();
747            let e = match GeneralOperand::parse(stream) {
748                Ok(val) => Some(val),
749                Err(_) => {
750                    stream.set_position(saved_pos);
751                    None
752                }
753            };
754            stream.expect_complete()?;
755            let saved_pos = stream.position();
756            let has_comma = stream.expect(&PtxToken::Comma).is_ok();
757            if !has_comma {
758                stream.set_position(saved_pos);
759            }
760            let saved_pos = stream.position();
761            let f = match GeneralOperand::parse(stream) {
762                Ok(val) => Some(val),
763                Err(_) => {
764                    stream.set_position(saved_pos);
765                    None
766                }
767            };
768            stream.expect_complete()?;
769            stream.expect_complete()?;
770            stream.expect(&PtxToken::Semicolon)?;
771            Ok(TexBaseGeomV2F16x2Ctype {
772                base,
773                geom,
774                v2,
775                f16x2,
776                ctype,
777                d,
778                p,
779                a,
780                e,
781                f,
782            })
783        }
784    }
785
786
787    impl PtxParser for TexLevelGeomV2F16x2Ctype {
788        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
789            stream.expect_string("tex")?;
790            stream.expect_string(".level")?;
791            let level = ();
792            stream.expect_complete()?;
793            let geom = Geom::parse(stream)?;
794            stream.expect_complete()?;
795            stream.expect_string(".v2")?;
796            let v2 = ();
797            stream.expect_complete()?;
798            stream.expect_string(".f16x2")?;
799            let f16x2 = ();
800            stream.expect_complete()?;
801            let ctype = Ctype::parse(stream)?;
802            stream.expect_complete()?;
803            let d = GeneralOperand::parse(stream)?;
804            let saved_pos = stream.position();
805            let p = if stream.consume_if(|t| matches!(t, PtxToken::Pipe)).is_some() {
806                Some(GeneralOperand::parse(stream)?)
807            } else {
808                stream.set_position(saved_pos);
809                None
810            };
811            stream.expect_complete()?;
812            stream.expect(&PtxToken::Comma)?;
813            let a = TexHandler3Optional::parse(stream)?;
814            stream.expect_complete()?;
815            stream.expect(&PtxToken::Comma)?;
816            let lod = GeneralOperand::parse(stream)?;
817            stream.expect_complete()?;
818            let saved_pos = stream.position();
819            let has_comma = stream.expect(&PtxToken::Comma).is_ok();
820            if !has_comma {
821                stream.set_position(saved_pos);
822            }
823            let saved_pos = stream.position();
824            let e = match GeneralOperand::parse(stream) {
825                Ok(val) => Some(val),
826                Err(_) => {
827                    stream.set_position(saved_pos);
828                    None
829                }
830            };
831            stream.expect_complete()?;
832            let saved_pos = stream.position();
833            let has_comma = stream.expect(&PtxToken::Comma).is_ok();
834            if !has_comma {
835                stream.set_position(saved_pos);
836            }
837            let saved_pos = stream.position();
838            let f = match GeneralOperand::parse(stream) {
839                Ok(val) => Some(val),
840                Err(_) => {
841                    stream.set_position(saved_pos);
842                    None
843                }
844            };
845            stream.expect_complete()?;
846            stream.expect_complete()?;
847            stream.expect(&PtxToken::Semicolon)?;
848            Ok(TexLevelGeomV2F16x2Ctype {
849                level,
850                geom,
851                v2,
852                f16x2,
853                ctype,
854                d,
855                p,
856                a,
857                lod,
858                e,
859                f,
860            })
861        }
862    }
863
864
865    impl PtxParser for TexGradGeomV2F16x2Ctype {
866        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
867            stream.expect_string("tex")?;
868            stream.expect_string(".grad")?;
869            let grad = ();
870            stream.expect_complete()?;
871            let geom = Geom::parse(stream)?;
872            stream.expect_complete()?;
873            stream.expect_string(".v2")?;
874            let v2 = ();
875            stream.expect_complete()?;
876            stream.expect_string(".f16x2")?;
877            let f16x2 = ();
878            stream.expect_complete()?;
879            let ctype = Ctype::parse(stream)?;
880            stream.expect_complete()?;
881            let d = GeneralOperand::parse(stream)?;
882            let saved_pos = stream.position();
883            let p = if stream.consume_if(|t| matches!(t, PtxToken::Pipe)).is_some() {
884                Some(GeneralOperand::parse(stream)?)
885            } else {
886                stream.set_position(saved_pos);
887                None
888            };
889            stream.expect_complete()?;
890            stream.expect(&PtxToken::Comma)?;
891            let a = TexHandler3Optional::parse(stream)?;
892            stream.expect_complete()?;
893            stream.expect(&PtxToken::Comma)?;
894            let dpdx = GeneralOperand::parse(stream)?;
895            stream.expect_complete()?;
896            stream.expect(&PtxToken::Comma)?;
897            let dpdy = GeneralOperand::parse(stream)?;
898            stream.expect_complete()?;
899            let saved_pos = stream.position();
900            let has_comma = stream.expect(&PtxToken::Comma).is_ok();
901            if !has_comma {
902                stream.set_position(saved_pos);
903            }
904            let saved_pos = stream.position();
905            let e = match GeneralOperand::parse(stream) {
906                Ok(val) => Some(val),
907                Err(_) => {
908                    stream.set_position(saved_pos);
909                    None
910                }
911            };
912            stream.expect_complete()?;
913            let saved_pos = stream.position();
914            let has_comma = stream.expect(&PtxToken::Comma).is_ok();
915            if !has_comma {
916                stream.set_position(saved_pos);
917            }
918            let saved_pos = stream.position();
919            let f = match GeneralOperand::parse(stream) {
920                Ok(val) => Some(val),
921                Err(_) => {
922                    stream.set_position(saved_pos);
923                    None
924                }
925            };
926            stream.expect_complete()?;
927            stream.expect_complete()?;
928            stream.expect(&PtxToken::Semicolon)?;
929            Ok(TexGradGeomV2F16x2Ctype {
930                grad,
931                geom,
932                v2,
933                f16x2,
934                ctype,
935                d,
936                p,
937                a,
938                dpdx,
939                dpdy,
940                e,
941                f,
942            })
943        }
944    }
945
946
947}
948
ptx_parser/parser/instruction/tex.rs

ptx_parser/parser/instruction/
tex.rs
