ptx_parser/parser/instruction/
bfind.rs

1//! Original PTX specification:
2//!
3//! bfind.type           d, a;
4//! bfind.shiftamt.type  d, a;
5//! .type = { .u32, .u64, .s32, .s64 };
6
7#![allow(unused)]
8
9use crate::lexer::PtxToken;
10use crate::parser::{PtxParseError, PtxParser, PtxTokenStream, Span};
11use crate::r#type::common::*;
12
13pub mod section_0 {
14    use super::*;
15    use crate::r#type::instruction::bfind::section_0::*;
16
17    // ============================================================================
18    // Generated enum parsers
19    // ============================================================================
20
21    impl PtxParser for Type {
22        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
23            // Try U32
24            {
25                let saved_pos = stream.position();
26                if stream.expect_string(".u32").is_ok() {
27                    return Ok(Type::U32);
28                }
29                stream.set_position(saved_pos);
30            }
31            let saved_pos = stream.position();
32            // Try U64
33            {
34                let saved_pos = stream.position();
35                if stream.expect_string(".u64").is_ok() {
36                    return Ok(Type::U64);
37                }
38                stream.set_position(saved_pos);
39            }
40            stream.set_position(saved_pos);
41            let saved_pos = stream.position();
42            // Try S32
43            {
44                let saved_pos = stream.position();
45                if stream.expect_string(".s32").is_ok() {
46                    return Ok(Type::S32);
47                }
48                stream.set_position(saved_pos);
49            }
50            stream.set_position(saved_pos);
51            let saved_pos = stream.position();
52            // Try S64
53            {
54                let saved_pos = stream.position();
55                if stream.expect_string(".s64").is_ok() {
56                    return Ok(Type::S64);
57                }
58                stream.set_position(saved_pos);
59            }
60            stream.set_position(saved_pos);
61            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
62            let expected = &[".u32", ".u64", ".s32", ".s64"];
63            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
64            Err(crate::parser::unexpected_value(span, expected, found))
65        }
66    }
67
68    impl PtxParser for BfindType {
69        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
70            stream.expect_string("bfind")?;
71            let type_ = Type::parse(stream)?;
72            stream.expect_complete()?;
73            let d = GeneralOperand::parse(stream)?;
74            stream.expect_complete()?;
75            stream.expect(&PtxToken::Comma)?;
76            let a = GeneralOperand::parse(stream)?;
77            stream.expect_complete()?;
78            stream.expect_complete()?;
79            stream.expect(&PtxToken::Semicolon)?;
80            Ok(BfindType {
81                type_,
82                d,
83                a,
84            })
85        }
86    }
87
88
89    impl PtxParser for BfindShiftamtType {
90        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
91            stream.expect_string("bfind")?;
92            stream.expect_string(".shiftamt")?;
93            let shiftamt = ();
94            stream.expect_complete()?;
95            let type_ = Type::parse(stream)?;
96            stream.expect_complete()?;
97            let d = GeneralOperand::parse(stream)?;
98            stream.expect_complete()?;
99            stream.expect(&PtxToken::Comma)?;
100            let a = GeneralOperand::parse(stream)?;
101            stream.expect_complete()?;
102            stream.expect_complete()?;
103            stream.expect(&PtxToken::Semicolon)?;
104            Ok(BfindShiftamtType {
105                shiftamt,
106                type_,
107                d,
108                a,
109            })
110        }
111    }
112
113
114}
115