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.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
135            let expected = &[".b16", ".b32", ".b64", ".u16", ".u32", ".u64", ".s16", ".s32", ".s64", ".f32", ".f64"];
136            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
137            Err(crate::parser::unexpected_value(span, expected, found))
138        }
139    }
140
141    impl PtxParser for SlctDtypeS32 {
142        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
143            stream.expect_string("slct")?;
144            let dtype = Dtype::parse(stream)?;
145            stream.expect_complete()?;
146            stream.expect_string(".s32")?;
147            let s32 = ();
148            stream.expect_complete()?;
149            let d = GeneralOperand::parse(stream)?;
150            stream.expect_complete()?;
151            stream.expect(&PtxToken::Comma)?;
152            let a = GeneralOperand::parse(stream)?;
153            stream.expect_complete()?;
154            stream.expect(&PtxToken::Comma)?;
155            let b = GeneralOperand::parse(stream)?;
156            stream.expect_complete()?;
157            stream.expect(&PtxToken::Comma)?;
158            let c = GeneralOperand::parse(stream)?;
159            stream.expect_complete()?;
160            stream.expect_complete()?;
161            stream.expect(&PtxToken::Semicolon)?;
162            Ok(SlctDtypeS32 {
163                dtype,
164                s32,
165                d,
166                a,
167                b,
168                c,
169            })
170        }
171    }
172
173
174    impl PtxParser for SlctFtzDtypeF32 {
175        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
176            stream.expect_string("slct")?;
177            let saved_pos = stream.position();
178            let ftz = stream.expect_string(".ftz").is_ok();
179            if !ftz {
180                stream.set_position(saved_pos);
181            }
182            stream.expect_complete()?;
183            let dtype = Dtype::parse(stream)?;
184            stream.expect_complete()?;
185            stream.expect_string(".f32")?;
186            let f32 = ();
187            stream.expect_complete()?;
188            let d = GeneralOperand::parse(stream)?;
189            stream.expect_complete()?;
190            stream.expect(&PtxToken::Comma)?;
191            let a = GeneralOperand::parse(stream)?;
192            stream.expect_complete()?;
193            stream.expect(&PtxToken::Comma)?;
194            let b = GeneralOperand::parse(stream)?;
195            stream.expect_complete()?;
196            stream.expect(&PtxToken::Comma)?;
197            let c = GeneralOperand::parse(stream)?;
198            stream.expect_complete()?;
199            stream.expect_complete()?;
200            stream.expect(&PtxToken::Semicolon)?;
201            Ok(SlctFtzDtypeF32 {
202                ftz,
203                dtype,
204                f32,
205                d,
206                a,
207                b,
208                c,
209            })
210        }
211    }
212
213
214}
215
ptx_parser/parser/instruction/slct.rs

ptx_parser/parser/instruction/
slct.rs
