ptx_parser/parser/instruction/
mad_cc.rs

1//! Original PTX specification:
2//!
3//! mad.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::mad_cc::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.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
42            let expected = &[".hi", ".lo"];
43            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
44            Err(crate::parser::unexpected_value(span, expected, found))
45        }
46    }
47
48    impl PtxParser for Type {
49        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
50            // Try U32
51            {
52                let saved_pos = stream.position();
53                if stream.expect_string(".u32").is_ok() {
54                    return Ok(Type::U32);
55                }
56                stream.set_position(saved_pos);
57            }
58            let saved_pos = stream.position();
59            // Try S32
60            {
61                let saved_pos = stream.position();
62                if stream.expect_string(".s32").is_ok() {
63                    return Ok(Type::S32);
64                }
65                stream.set_position(saved_pos);
66            }
67            stream.set_position(saved_pos);
68            let saved_pos = stream.position();
69            // Try U64
70            {
71                let saved_pos = stream.position();
72                if stream.expect_string(".u64").is_ok() {
73                    return Ok(Type::U64);
74                }
75                stream.set_position(saved_pos);
76            }
77            stream.set_position(saved_pos);
78            let saved_pos = stream.position();
79            // Try S64
80            {
81                let saved_pos = stream.position();
82                if stream.expect_string(".s64").is_ok() {
83                    return Ok(Type::S64);
84                }
85                stream.set_position(saved_pos);
86            }
87            stream.set_position(saved_pos);
88            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
89            let expected = &[".u32", ".s32", ".u64", ".s64"];
90            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
91            Err(crate::parser::unexpected_value(span, expected, found))
92        }
93    }
94
95    impl PtxParser for MadHiloCcType {
96        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
97            stream.expect_string("mad")?;
98            let hilo = Hilo::parse(stream)?;
99            stream.expect_complete()?;
100            stream.expect_string(".cc")?;
101            let cc = ();
102            stream.expect_complete()?;
103            let type_ = Type::parse(stream)?;
104            stream.expect_complete()?;
105            let d = GeneralOperand::parse(stream)?;
106            stream.expect_complete()?;
107            stream.expect(&PtxToken::Comma)?;
108            let a = GeneralOperand::parse(stream)?;
109            stream.expect_complete()?;
110            stream.expect(&PtxToken::Comma)?;
111            let b = GeneralOperand::parse(stream)?;
112            stream.expect_complete()?;
113            stream.expect(&PtxToken::Comma)?;
114            let c = GeneralOperand::parse(stream)?;
115            stream.expect_complete()?;
116            stream.expect_complete()?;
117            stream.expect(&PtxToken::Semicolon)?;
118            Ok(MadHiloCcType {
119                hilo,
120                cc,
121                type_,
122                d,
123                a,
124                b,
125                c,
126            })
127        }
128    }
129
130
131}
132
ptx_parser/parser/instruction/mad_cc.rs

ptx_parser/parser/instruction/
mad_cc.rs
