ptx_parser/parser/instruction/
madc.rs

1//! Original PTX specification:
2//!
3//! madc.hilo{.cc}.type  d, a, b, c;
4//! .type = { .u32, .s32, .u64, .s64 };
5//! .hilo = { .hi, .lo };
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::madc::section_0::*;
16
17    // ============================================================================
18    // Generated enum parsers
19    // ============================================================================
20
21    impl PtxParser for Hilo {
22        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
23            // Try Hi
24            {
25                let saved_pos = stream.position();
26                if stream.expect_string(".hi").is_ok() {
27                    return Ok(Hilo::Hi);
28                }
29                stream.set_position(saved_pos);
30            }
31            let saved_pos = stream.position();
32            // Try Lo
33            {
34                let saved_pos = stream.position();
35                if stream.expect_string(".lo").is_ok() {
36                    return Ok(Hilo::Lo);
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 = &[".hi", ".lo"];
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 Type {
55        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
56            // Try U32
57            {
58                let saved_pos = stream.position();
59                if stream.expect_string(".u32").is_ok() {
60                    return Ok(Type::U32);
61                }
62                stream.set_position(saved_pos);
63            }
64            let saved_pos = stream.position();
65            // Try S32
66            {
67                let saved_pos = stream.position();
68                if stream.expect_string(".s32").is_ok() {
69                    return Ok(Type::S32);
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(Type::U64);
80                }
81                stream.set_position(saved_pos);
82            }
83            stream.set_position(saved_pos);
84            let saved_pos = stream.position();
85            // Try S64
86            {
87                let saved_pos = stream.position();
88                if stream.expect_string(".s64").is_ok() {
89                    return Ok(Type::S64);
90                }
91                stream.set_position(saved_pos);
92            }
93            stream.set_position(saved_pos);
94            let span = stream
95                .peek()
96                .map(|(_, s)| s.clone())
97                .unwrap_or(Span { start: 0, end: 0 });
98            let expected = &[".u32", ".s32", ".u64", ".s64"];
99            let found = stream
100                .peek()
101                .map(|(t, _)| format!("{:?}", t))
102                .unwrap_or_else(|_| "<end of input>".to_string());
103            Err(crate::parser::unexpected_value(span, expected, found))
104        }
105    }
106
107    impl PtxParser for MadcHiloCcType {
108        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
109            stream.expect_string("madc")?;
110            let hilo = Hilo::parse(stream)?;
111            stream.expect_complete()?;
112            let saved_pos = stream.position();
113            let cc = stream.expect_string(".cc").is_ok();
114            if !cc {
115                stream.set_position(saved_pos);
116            }
117            stream.expect_complete()?;
118            let type_ = Type::parse(stream)?;
119            stream.expect_complete()?;
120            let d = GeneralOperand::parse(stream)?;
121            stream.expect_complete()?;
122            stream.expect(&PtxToken::Comma)?;
123            let a = GeneralOperand::parse(stream)?;
124            stream.expect_complete()?;
125            stream.expect(&PtxToken::Comma)?;
126            let b = GeneralOperand::parse(stream)?;
127            stream.expect_complete()?;
128            stream.expect(&PtxToken::Comma)?;
129            let c = GeneralOperand::parse(stream)?;
130            stream.expect_complete()?;
131            stream.expect_complete()?;
132            stream.expect(&PtxToken::Semicolon)?;
133            Ok(MadcHiloCcType {
134                hilo,
135                cc,
136                type_,
137                d,
138                a,
139                b,
140                c,
141            })
142        }
143    }
144}
ptx_parser/parser/instruction/madc.rs

ptx_parser/parser/instruction/
madc.rs
