ptx_parser/parser/instruction/
div.rs

1//! Original PTX specification:
2//!
3//! div.type  d, a, b;
4//! .type = { .u16, .u32, .u64,
5//! .s16, .s32, .s64 };
6//! 
7//! div.approx{.ftz}.f32  d, a, b;  // fast, approximate divide
8//! div.full{.ftz}.f32    d, a, b;  // full-range approximate divide
9//! div.rnd{.ftz}.f32     d, a, b;  // IEEE 754 compliant rounding
10//! div.rnd.f64           d, a, b;  // IEEE 754 compliant rounding
11//! .rnd = { .rn, .rz, .rm, .rp };
12
13#![allow(unused)]
14
15use crate::lexer::PtxToken;
16use crate::parser::{PtxParseError, PtxParser, PtxTokenStream, Span};
17use crate::r#type::common::*;
18
19pub mod section_0 {
20    use super::*;
21    use crate::r#type::instruction::div::section_0::*;
22
23    // ============================================================================
24    // Generated enum parsers
25    // ============================================================================
26
27    impl PtxParser for Rnd {
28        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
29            // Try Rn
30            {
31                let saved_pos = stream.position();
32                if stream.expect_string(".rn").is_ok() {
33                    return Ok(Rnd::Rn);
34                }
35                stream.set_position(saved_pos);
36            }
37            let saved_pos = stream.position();
38            // Try Rz
39            {
40                let saved_pos = stream.position();
41                if stream.expect_string(".rz").is_ok() {
42                    return Ok(Rnd::Rz);
43                }
44                stream.set_position(saved_pos);
45            }
46            stream.set_position(saved_pos);
47            let saved_pos = stream.position();
48            // Try Rm
49            {
50                let saved_pos = stream.position();
51                if stream.expect_string(".rm").is_ok() {
52                    return Ok(Rnd::Rm);
53                }
54                stream.set_position(saved_pos);
55            }
56            stream.set_position(saved_pos);
57            let saved_pos = stream.position();
58            // Try Rp
59            {
60                let saved_pos = stream.position();
61                if stream.expect_string(".rp").is_ok() {
62                    return Ok(Rnd::Rp);
63                }
64                stream.set_position(saved_pos);
65            }
66            stream.set_position(saved_pos);
67            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
68            let expected = &[".rn", ".rz", ".rm", ".rp"];
69            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
70            Err(crate::parser::unexpected_value(span, expected, found))
71        }
72    }
73
74    impl PtxParser for Type {
75        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
76            // Try U16
77            {
78                let saved_pos = stream.position();
79                if stream.expect_string(".u16").is_ok() {
80                    return Ok(Type::U16);
81                }
82                stream.set_position(saved_pos);
83            }
84            let saved_pos = stream.position();
85            // Try U32
86            {
87                let saved_pos = stream.position();
88                if stream.expect_string(".u32").is_ok() {
89                    return Ok(Type::U32);
90                }
91                stream.set_position(saved_pos);
92            }
93            stream.set_position(saved_pos);
94            let saved_pos = stream.position();
95            // Try U64
96            {
97                let saved_pos = stream.position();
98                if stream.expect_string(".u64").is_ok() {
99                    return Ok(Type::U64);
100                }
101                stream.set_position(saved_pos);
102            }
103            stream.set_position(saved_pos);
104            let saved_pos = stream.position();
105            // Try S16
106            {
107                let saved_pos = stream.position();
108                if stream.expect_string(".s16").is_ok() {
109                    return Ok(Type::S16);
110                }
111                stream.set_position(saved_pos);
112            }
113            stream.set_position(saved_pos);
114            let saved_pos = stream.position();
115            // Try S32
116            {
117                let saved_pos = stream.position();
118                if stream.expect_string(".s32").is_ok() {
119                    return Ok(Type::S32);
120                }
121                stream.set_position(saved_pos);
122            }
123            stream.set_position(saved_pos);
124            let saved_pos = stream.position();
125            // Try S64
126            {
127                let saved_pos = stream.position();
128                if stream.expect_string(".s64").is_ok() {
129                    return Ok(Type::S64);
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 = &[".u16", ".u32", ".u64", ".s16", ".s32", ".s64"];
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 DivType {
142        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
143            stream.expect_string("div")?;
144            let type_ = Type::parse(stream)?;
145            stream.expect_complete()?;
146            let d = GeneralOperand::parse(stream)?;
147            stream.expect_complete()?;
148            stream.expect(&PtxToken::Comma)?;
149            let a = GeneralOperand::parse(stream)?;
150            stream.expect_complete()?;
151            stream.expect(&PtxToken::Comma)?;
152            let b = GeneralOperand::parse(stream)?;
153            stream.expect_complete()?;
154            stream.expect_complete()?;
155            stream.expect(&PtxToken::Semicolon)?;
156            Ok(DivType {
157                type_,
158                d,
159                a,
160                b,
161            })
162        }
163    }
164
165
166    impl PtxParser for DivApproxFtzF32 {
167        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
168            stream.expect_string("div")?;
169            stream.expect_string(".approx")?;
170            let approx = ();
171            stream.expect_complete()?;
172            let saved_pos = stream.position();
173            let ftz = stream.expect_string(".ftz").is_ok();
174            if !ftz {
175                stream.set_position(saved_pos);
176            }
177            stream.expect_complete()?;
178            stream.expect_string(".f32")?;
179            let f32 = ();
180            stream.expect_complete()?;
181            let d = GeneralOperand::parse(stream)?;
182            stream.expect_complete()?;
183            stream.expect(&PtxToken::Comma)?;
184            let a = GeneralOperand::parse(stream)?;
185            stream.expect_complete()?;
186            stream.expect(&PtxToken::Comma)?;
187            let b = GeneralOperand::parse(stream)?;
188            stream.expect_complete()?;
189            stream.expect_complete()?;
190            stream.expect(&PtxToken::Semicolon)?;
191            Ok(DivApproxFtzF32 {
192                approx,
193                ftz,
194                f32,
195                d,
196                a,
197                b,
198            })
199        }
200    }
201
202
203    impl PtxParser for DivFullFtzF32 {
204        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
205            stream.expect_string("div")?;
206            stream.expect_string(".full")?;
207            let full = ();
208            stream.expect_complete()?;
209            let saved_pos = stream.position();
210            let ftz = stream.expect_string(".ftz").is_ok();
211            if !ftz {
212                stream.set_position(saved_pos);
213            }
214            stream.expect_complete()?;
215            stream.expect_string(".f32")?;
216            let f32 = ();
217            stream.expect_complete()?;
218            let d = GeneralOperand::parse(stream)?;
219            stream.expect_complete()?;
220            stream.expect(&PtxToken::Comma)?;
221            let a = GeneralOperand::parse(stream)?;
222            stream.expect_complete()?;
223            stream.expect(&PtxToken::Comma)?;
224            let b = GeneralOperand::parse(stream)?;
225            stream.expect_complete()?;
226            stream.expect_complete()?;
227            stream.expect(&PtxToken::Semicolon)?;
228            Ok(DivFullFtzF32 {
229                full,
230                ftz,
231                f32,
232                d,
233                a,
234                b,
235            })
236        }
237    }
238
239
240    impl PtxParser for DivRndFtzF32 {
241        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
242            stream.expect_string("div")?;
243            let rnd = Rnd::parse(stream)?;
244            stream.expect_complete()?;
245            let saved_pos = stream.position();
246            let ftz = stream.expect_string(".ftz").is_ok();
247            if !ftz {
248                stream.set_position(saved_pos);
249            }
250            stream.expect_complete()?;
251            stream.expect_string(".f32")?;
252            let f32 = ();
253            stream.expect_complete()?;
254            let d = GeneralOperand::parse(stream)?;
255            stream.expect_complete()?;
256            stream.expect(&PtxToken::Comma)?;
257            let a = GeneralOperand::parse(stream)?;
258            stream.expect_complete()?;
259            stream.expect(&PtxToken::Comma)?;
260            let b = GeneralOperand::parse(stream)?;
261            stream.expect_complete()?;
262            stream.expect_complete()?;
263            stream.expect(&PtxToken::Semicolon)?;
264            Ok(DivRndFtzF32 {
265                rnd,
266                ftz,
267                f32,
268                d,
269                a,
270                b,
271            })
272        }
273    }
274
275
276    impl PtxParser for DivRndF64 {
277        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
278            stream.expect_string("div")?;
279            let rnd = Rnd::parse(stream)?;
280            stream.expect_complete()?;
281            stream.expect_string(".f64")?;
282            let f64 = ();
283            stream.expect_complete()?;
284            let d = GeneralOperand::parse(stream)?;
285            stream.expect_complete()?;
286            stream.expect(&PtxToken::Comma)?;
287            let a = GeneralOperand::parse(stream)?;
288            stream.expect_complete()?;
289            stream.expect(&PtxToken::Comma)?;
290            let b = GeneralOperand::parse(stream)?;
291            stream.expect_complete()?;
292            stream.expect_complete()?;
293            stream.expect(&PtxToken::Semicolon)?;
294            Ok(DivRndF64 {
295                rnd,
296                f64,
297                d,
298                a,
299                b,
300            })
301        }
302    }
303
304
305}
306
ptx_parser/parser/instruction/div.rs

ptx_parser/parser/instruction/
div.rs
