ptx_parser/parser/instruction/
testp.rs

1//! Original PTX specification:
2//!
3//! testp.op.type  p, a;  // result is .pred
4//! .op   = { .finite, .infinite,
5//! .number, .notanumber,
6//! .normal, .subnormal };
7//! .type = { .f32, .f64 };
8
9#![allow(unused)]
10
11use crate::lexer::PtxToken;
12use crate::parser::{PtxParseError, PtxParser, PtxTokenStream, Span};
13use crate::r#type::common::*;
14
15pub mod section_0 {
16    use super::*;
17    use crate::r#type::instruction::testp::section_0::*;
18
19    // ============================================================================
20    // Generated enum parsers
21    // ============================================================================
22
23    impl PtxParser for Op {
24        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
25            // Try Notanumber
26            {
27                let saved_pos = stream.position();
28                if stream.expect_string(".notanumber").is_ok() {
29                    return Ok(Op::Notanumber);
30                }
31                stream.set_position(saved_pos);
32            }
33            let saved_pos = stream.position();
34            // Try Subnormal
35            {
36                let saved_pos = stream.position();
37                if stream.expect_string(".subnormal").is_ok() {
38                    return Ok(Op::Subnormal);
39                }
40                stream.set_position(saved_pos);
41            }
42            stream.set_position(saved_pos);
43            let saved_pos = stream.position();
44            // Try Infinite
45            {
46                let saved_pos = stream.position();
47                if stream.expect_string(".infinite").is_ok() {
48                    return Ok(Op::Infinite);
49                }
50                stream.set_position(saved_pos);
51            }
52            stream.set_position(saved_pos);
53            let saved_pos = stream.position();
54            // Try Finite
55            {
56                let saved_pos = stream.position();
57                if stream.expect_string(".finite").is_ok() {
58                    return Ok(Op::Finite);
59                }
60                stream.set_position(saved_pos);
61            }
62            stream.set_position(saved_pos);
63            let saved_pos = stream.position();
64            // Try Number
65            {
66                let saved_pos = stream.position();
67                if stream.expect_string(".number").is_ok() {
68                    return Ok(Op::Number);
69                }
70                stream.set_position(saved_pos);
71            }
72            stream.set_position(saved_pos);
73            let saved_pos = stream.position();
74            // Try Normal
75            {
76                let saved_pos = stream.position();
77                if stream.expect_string(".normal").is_ok() {
78                    return Ok(Op::Normal);
79                }
80                stream.set_position(saved_pos);
81            }
82            stream.set_position(saved_pos);
83            let span = stream
84                .peek()
85                .map(|(_, s)| s.clone())
86                .unwrap_or(Span { start: 0, end: 0 });
87            let expected = &[
88                ".notanumber",
89                ".subnormal",
90                ".infinite",
91                ".finite",
92                ".number",
93                ".normal",
94            ];
95            let found = stream
96                .peek()
97                .map(|(t, _)| format!("{:?}", t))
98                .unwrap_or_else(|_| "<end of input>".to_string());
99            Err(crate::parser::unexpected_value(span, expected, found))
100        }
101    }
102
103    impl PtxParser for Type {
104        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
105            // Try F32
106            {
107                let saved_pos = stream.position();
108                if stream.expect_string(".f32").is_ok() {
109                    return Ok(Type::F32);
110                }
111                stream.set_position(saved_pos);
112            }
113            let saved_pos = stream.position();
114            // Try F64
115            {
116                let saved_pos = stream.position();
117                if stream.expect_string(".f64").is_ok() {
118                    return Ok(Type::F64);
119                }
120                stream.set_position(saved_pos);
121            }
122            stream.set_position(saved_pos);
123            let span = stream
124                .peek()
125                .map(|(_, s)| s.clone())
126                .unwrap_or(Span { start: 0, end: 0 });
127            let expected = &[".f32", ".f64"];
128            let found = stream
129                .peek()
130                .map(|(t, _)| format!("{:?}", t))
131                .unwrap_or_else(|_| "<end of input>".to_string());
132            Err(crate::parser::unexpected_value(span, expected, found))
133        }
134    }
135
136    impl PtxParser for TestpOpType {
137        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
138            stream.expect_string("testp")?;
139            let op = Op::parse(stream)?;
140            stream.expect_complete()?;
141            let type_ = Type::parse(stream)?;
142            stream.expect_complete()?;
143            let p = GeneralOperand::parse(stream)?;
144            stream.expect_complete()?;
145            stream.expect(&PtxToken::Comma)?;
146            let a = GeneralOperand::parse(stream)?;
147            stream.expect_complete()?;
148            stream.expect_complete()?;
149            stream.expect(&PtxToken::Semicolon)?;
150            Ok(TestpOpType { op, type_, p, a })
151        }
152    }
153}
ptx_parser/parser/instruction/testp.rs

ptx_parser/parser/instruction/
testp.rs
