ptx_parser/parser/instruction/
selp.rs

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

ptx_parser/parser/instruction/
selp.rs
