ptx_parser/parser/instruction/
slct.rs

1//! Original PTX specification:
2//!
3//! slct.dtype.s32        d, a, b, c;
4//! slct{.ftz}.dtype.f32  d, a, b, c;
5//! .dtype = { .b16, .b32, .b64,
6//! .u16, .u32, .u64,
7//! .s16, .s32, .s64,
8//! .f32, .f64 };
9
10#![allow(unused)]
11
12use crate::lexer::PtxToken;
13use crate::parser::{PtxParseError, PtxParser, PtxTokenStream, Span};
14use crate::r#type::common::*;
15
16pub mod section_0 {
17    use super::*;
18    use crate::r#type::instruction::slct::section_0::*;
19
20    // ============================================================================
21    // Generated enum parsers
22    // ============================================================================
23
24    impl PtxParser for Dtype {
25        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
26            // Try B16
27            {
28                let saved_pos = stream.position();
29                if stream.expect_string(".b16").is_ok() {
30                    return Ok(Dtype::B16);
31                }
32                stream.set_position(saved_pos);
33            }
34            let saved_pos = stream.position();
35            // Try B32
36            {
37                let saved_pos = stream.position();
38                if stream.expect_string(".b32").is_ok() {
39                    return Ok(Dtype::B32);
40                }
41                stream.set_position(saved_pos);
42            }
43            stream.set_position(saved_pos);
44            let saved_pos = stream.position();
45            // Try B64
46            {
47                let saved_pos = stream.position();
48                if stream.expect_string(".b64").is_ok() {
49                    return Ok(Dtype::B64);
50                }
51                stream.set_position(saved_pos);
52            }
53            stream.set_position(saved_pos);
54            let saved_pos = stream.position();
55            // Try U16
56            {
57                let saved_pos = stream.position();
58                if stream.expect_string(".u16").is_ok() {
59                    return Ok(Dtype::U16);
60                }
61                stream.set_position(saved_pos);
62            }
63            stream.set_position(saved_pos);
64            let saved_pos = stream.position();
65            // Try U32
66            {
67                let saved_pos = stream.position();
68                if stream.expect_string(".u32").is_ok() {
69                    return Ok(Dtype::U32);
70                }
71                stream.set_position(saved_pos);
72            }
73            stream.set_position(saved_pos);
74            let saved_pos = stream.position();
75            // Try U64
76            {
77                let saved_pos = stream.position();
78                if stream.expect_string(".u64").is_ok() {
79                    return Ok(Dtype::U64);
80                }
81                stream.set_position(saved_pos);
82            }
83            stream.set_position(saved_pos);
84            let saved_pos = stream.position();
85            // Try S16
86            {
87                let saved_pos = stream.position();
88                if stream.expect_string(".s16").is_ok() {
89                    return Ok(Dtype::S16);
90                }
91                stream.set_position(saved_pos);
92            }
93            stream.set_position(saved_pos);
94            let saved_pos = stream.position();
95            // Try S32
96            {
97                let saved_pos = stream.position();
98                if stream.expect_string(".s32").is_ok() {
99                    return Ok(Dtype::S32);
100                }
101                stream.set_position(saved_pos);
102            }
103            stream.set_position(saved_pos);
104            let saved_pos = stream.position();
105            // Try S64
106            {
107                let saved_pos = stream.position();
108                if stream.expect_string(".s64").is_ok() {
109                    return Ok(Dtype::S64);
110                }
111                stream.set_position(saved_pos);
112            }
113            stream.set_position(saved_pos);
114            let saved_pos = stream.position();
115            // Try F32
116            {
117                let saved_pos = stream.position();
118                if stream.expect_string(".f32").is_ok() {
119                    return Ok(Dtype::F32);
120                }
121                stream.set_position(saved_pos);
122            }
123            stream.set_position(saved_pos);
124            let saved_pos = stream.position();
125            // Try F64
126            {
127                let saved_pos = stream.position();
128                if stream.expect_string(".f64").is_ok() {
129                    return Ok(Dtype::F64);
130                }
131                stream.set_position(saved_pos);
132            }
133            stream.set_position(saved_pos);
134            let span = stream
135                .peek()
136                .map(|(_, s)| s.clone())
137                .unwrap_or(Span { start: 0, end: 0 });
138            let expected = &[
139                ".b16", ".b32", ".b64", ".u16", ".u32", ".u64", ".s16", ".s32", ".s64", ".f32",
140                ".f64",
141            ];
142            let found = stream
143                .peek()
144                .map(|(t, _)| format!("{:?}", t))
145                .unwrap_or_else(|_| "<end of input>".to_string());
146            Err(crate::parser::unexpected_value(span, expected, found))
147        }
148    }
149
150    impl PtxParser for SlctDtypeS32 {
151        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
152            stream.expect_string("slct")?;
153            let dtype = Dtype::parse(stream)?;
154            stream.expect_complete()?;
155            stream.expect_string(".s32")?;
156            let s32 = ();
157            stream.expect_complete()?;
158            let d = GeneralOperand::parse(stream)?;
159            stream.expect_complete()?;
160            stream.expect(&PtxToken::Comma)?;
161            let a = GeneralOperand::parse(stream)?;
162            stream.expect_complete()?;
163            stream.expect(&PtxToken::Comma)?;
164            let b = GeneralOperand::parse(stream)?;
165            stream.expect_complete()?;
166            stream.expect(&PtxToken::Comma)?;
167            let c = GeneralOperand::parse(stream)?;
168            stream.expect_complete()?;
169            stream.expect_complete()?;
170            stream.expect(&PtxToken::Semicolon)?;
171            Ok(SlctDtypeS32 {
172                dtype,
173                s32,
174                d,
175                a,
176                b,
177                c,
178            })
179        }
180    }
181
182    impl PtxParser for SlctFtzDtypeF32 {
183        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
184            stream.expect_string("slct")?;
185            let saved_pos = stream.position();
186            let ftz = stream.expect_string(".ftz").is_ok();
187            if !ftz {
188                stream.set_position(saved_pos);
189            }
190            stream.expect_complete()?;
191            let dtype = Dtype::parse(stream)?;
192            stream.expect_complete()?;
193            stream.expect_string(".f32")?;
194            let f32 = ();
195            stream.expect_complete()?;
196            let d = GeneralOperand::parse(stream)?;
197            stream.expect_complete()?;
198            stream.expect(&PtxToken::Comma)?;
199            let a = GeneralOperand::parse(stream)?;
200            stream.expect_complete()?;
201            stream.expect(&PtxToken::Comma)?;
202            let b = GeneralOperand::parse(stream)?;
203            stream.expect_complete()?;
204            stream.expect(&PtxToken::Comma)?;
205            let c = GeneralOperand::parse(stream)?;
206            stream.expect_complete()?;
207            stream.expect_complete()?;
208            stream.expect(&PtxToken::Semicolon)?;
209            Ok(SlctFtzDtypeF32 {
210                ftz,
211                dtype,
212                f32,
213                d,
214                a,
215                b,
216                c,
217            })
218        }
219    }
220}
ptx_parser/parser/instruction/slct.rs

ptx_parser/parser/instruction/
slct.rs
