ptx_parser/parser/instruction/
match_sync.rs

1//! Original PTX specification:
2//!
3//! match.any.sync.type  d, a, membermask;
4//! match.all.sync.type  d{|p}, a, membermask;
5//! .type = { .b32, .b64 };
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::match_sync::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 B32
24            {
25                let saved_pos = stream.position();
26                if stream.expect_string(".b32").is_ok() {
27                    return Ok(Type::B32);
28                }
29                stream.set_position(saved_pos);
30            }
31            let saved_pos = stream.position();
32            // Try B64
33            {
34                let saved_pos = stream.position();
35                if stream.expect_string(".b64").is_ok() {
36                    return Ok(Type::B64);
37                }
38                stream.set_position(saved_pos);
39            }
40            stream.set_position(saved_pos);
41            let span = stream
42                .peek()
43                .map(|(_, s)| s.clone())
44                .unwrap_or(Span { start: 0, end: 0 });
45            let expected = &[".b32", ".b64"];
46            let found = stream
47                .peek()
48                .map(|(t, _)| format!("{:?}", t))
49                .unwrap_or_else(|_| "<end of input>".to_string());
50            Err(crate::parser::unexpected_value(span, expected, found))
51        }
52    }
53
54    impl PtxParser for MatchAnySyncType {
55        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
56            stream.expect_string("match")?;
57            stream.expect_string(".any")?;
58            let any = ();
59            stream.expect_complete()?;
60            stream.expect_string(".sync")?;
61            let sync = ();
62            stream.expect_complete()?;
63            let type_ = Type::parse(stream)?;
64            stream.expect_complete()?;
65            let d = GeneralOperand::parse(stream)?;
66            stream.expect_complete()?;
67            stream.expect(&PtxToken::Comma)?;
68            let a = GeneralOperand::parse(stream)?;
69            stream.expect_complete()?;
70            stream.expect(&PtxToken::Comma)?;
71            let membermask = GeneralOperand::parse(stream)?;
72            stream.expect_complete()?;
73            stream.expect_complete()?;
74            stream.expect(&PtxToken::Semicolon)?;
75            Ok(MatchAnySyncType {
76                any,
77                sync,
78                type_,
79                d,
80                a,
81                membermask,
82            })
83        }
84    }
85
86    impl PtxParser for MatchAllSyncType {
87        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
88            stream.expect_string("match")?;
89            stream.expect_string(".all")?;
90            let all = ();
91            stream.expect_complete()?;
92            stream.expect_string(".sync")?;
93            let sync = ();
94            stream.expect_complete()?;
95            let type_ = Type::parse(stream)?;
96            stream.expect_complete()?;
97            let d = GeneralOperand::parse(stream)?;
98            let saved_pos = stream.position();
99            let p = if stream.consume_if(|t| matches!(t, PtxToken::Pipe)).is_some() {
100                Some(GeneralOperand::parse(stream)?)
101            } else {
102                stream.set_position(saved_pos);
103                None
104            };
105            stream.expect_complete()?;
106            stream.expect(&PtxToken::Comma)?;
107            let a = GeneralOperand::parse(stream)?;
108            stream.expect_complete()?;
109            stream.expect(&PtxToken::Comma)?;
110            let membermask = GeneralOperand::parse(stream)?;
111            stream.expect_complete()?;
112            stream.expect_complete()?;
113            stream.expect(&PtxToken::Semicolon)?;
114            Ok(MatchAllSyncType {
115                all,
116                sync,
117                type_,
118                d,
119                p,
120                a,
121                membermask,
122            })
123        }
124    }
125}
ptx_parser/parser/instruction/match_sync.rs

ptx_parser/parser/instruction/
match_sync.rs
