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

ptx_parser/parser/instruction/
tex.rs
