ptx_parser/parser/instruction/
call.rs

1//! Original PTX specification:
2//!
3//! // direct call to named function, func is a symbol
4//! call{.uni} (ret-param), func, (param-list);
5//! call{.uni} func, (param-list);
6//! call{.uni} func;
7//! // indirect call via pointer, with full list of call targets
8//! call{.uni} (ret-param), fptr, (param-list), flist;
9//! call{.uni} fptr, (param-list), flist;
10//! call{.uni} fptr, flist;
11//! // indirect call via pointer, with no knowledge of call targets
12//! call{.uni} (ret-param), fptr, (param-list), fproto;
13//! call{.uni} fptr, (param-list), fproto;
14//! call{.uni} fptr, fproto;
15
16#![allow(unused)]
17
18use crate::lexer::PtxToken;
19use crate::parser::{PtxParseError, PtxParser, PtxTokenStream, Span};
20use crate::r#type::common::*;
21
22pub mod section_0 {
23    use super::*;
24    use crate::r#type::instruction::call::section_0::*;
25
26    impl PtxParser for CallUni {
27        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
28            stream.expect_string("call")?;
29            let saved_pos = stream.position();
30            let uni = stream.expect_string(".uni").is_ok();
31            if !uni {
32                stream.set_position(saved_pos);
33            }
34            stream.expect_complete()?;
35            stream.expect(&PtxToken::LParen)?;
36            let ret_param = GeneralOperand::parse(stream)?;
37            stream.expect(&PtxToken::RParen)?;
38            stream.expect_complete()?;
39            stream.expect(&PtxToken::Comma)?;
40            let func = GeneralOperand::parse(stream)?;
41            stream.expect_complete()?;
42            stream.expect(&PtxToken::Comma)?;
43            stream.expect(&PtxToken::LParen)?;
44            let mut param_list = Vec::new();
45            // Parse comma-separated operands
46            loop {
47                // Try to parse an operand
48                let saved_pos = stream.position();
49                match GeneralOperand::parse(stream) {
50                    Ok(operand) => {
51                        param_list.push(operand);
52                        // Check for comma
53                        if stream.expect(&PtxToken::Comma).is_err() {
54                            break;
55                        }
56                    }
57                    Err(_) => {
58                        stream.set_position(saved_pos);
59                        break;
60                    }
61                }
62            }
63            stream.expect(&PtxToken::RParen)?;
64            stream.expect_complete()?;
65            stream.expect_complete()?;
66            stream.expect(&PtxToken::Semicolon)?;
67            Ok(CallUni {
68                uni,
69                ret_param,
70                func,
71                param_list,
72            })
73        }
74    }
75
76    impl PtxParser for CallUni1 {
77        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
78            stream.expect_string("call")?;
79            let saved_pos = stream.position();
80            let uni = stream.expect_string(".uni").is_ok();
81            if !uni {
82                stream.set_position(saved_pos);
83            }
84            stream.expect_complete()?;
85            let func = GeneralOperand::parse(stream)?;
86            stream.expect_complete()?;
87            stream.expect(&PtxToken::Comma)?;
88            stream.expect(&PtxToken::LParen)?;
89            let mut param_list = Vec::new();
90            // Parse comma-separated operands
91            loop {
92                // Try to parse an operand
93                let saved_pos = stream.position();
94                match GeneralOperand::parse(stream) {
95                    Ok(operand) => {
96                        param_list.push(operand);
97                        // Check for comma
98                        if stream.expect(&PtxToken::Comma).is_err() {
99                            break;
100                        }
101                    }
102                    Err(_) => {
103                        stream.set_position(saved_pos);
104                        break;
105                    }
106                }
107            }
108            stream.expect(&PtxToken::RParen)?;
109            stream.expect_complete()?;
110            stream.expect_complete()?;
111            stream.expect(&PtxToken::Semicolon)?;
112            Ok(CallUni1 {
113                uni,
114                func,
115                param_list,
116            })
117        }
118    }
119
120    impl PtxParser for CallUni2 {
121        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
122            stream.expect_string("call")?;
123            let saved_pos = stream.position();
124            let uni = stream.expect_string(".uni").is_ok();
125            if !uni {
126                stream.set_position(saved_pos);
127            }
128            stream.expect_complete()?;
129            let func = GeneralOperand::parse(stream)?;
130            stream.expect_complete()?;
131            stream.expect_complete()?;
132            stream.expect(&PtxToken::Semicolon)?;
133            Ok(CallUni2 { uni, func })
134        }
135    }
136
137    impl PtxParser for CallUni3 {
138        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
139            stream.expect_string("call")?;
140            let saved_pos = stream.position();
141            let uni = stream.expect_string(".uni").is_ok();
142            if !uni {
143                stream.set_position(saved_pos);
144            }
145            stream.expect_complete()?;
146            stream.expect(&PtxToken::LParen)?;
147            let ret_param = GeneralOperand::parse(stream)?;
148            stream.expect(&PtxToken::RParen)?;
149            stream.expect_complete()?;
150            stream.expect(&PtxToken::Comma)?;
151            let fptr = GeneralOperand::parse(stream)?;
152            stream.expect_complete()?;
153            stream.expect(&PtxToken::Comma)?;
154            stream.expect(&PtxToken::LParen)?;
155            let mut param_list = Vec::new();
156            // Parse comma-separated operands
157            loop {
158                // Try to parse an operand
159                let saved_pos = stream.position();
160                match GeneralOperand::parse(stream) {
161                    Ok(operand) => {
162                        param_list.push(operand);
163                        // Check for comma
164                        if stream.expect(&PtxToken::Comma).is_err() {
165                            break;
166                        }
167                    }
168                    Err(_) => {
169                        stream.set_position(saved_pos);
170                        break;
171                    }
172                }
173            }
174            stream.expect(&PtxToken::RParen)?;
175            stream.expect_complete()?;
176            stream.expect(&PtxToken::Comma)?;
177            let flist = GeneralOperand::parse(stream)?;
178            stream.expect_complete()?;
179            stream.expect_complete()?;
180            stream.expect(&PtxToken::Semicolon)?;
181            Ok(CallUni3 {
182                uni,
183                ret_param,
184                fptr,
185                param_list,
186                flist,
187            })
188        }
189    }
190
191    impl PtxParser for CallUni4 {
192        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
193            stream.expect_string("call")?;
194            let saved_pos = stream.position();
195            let uni = stream.expect_string(".uni").is_ok();
196            if !uni {
197                stream.set_position(saved_pos);
198            }
199            stream.expect_complete()?;
200            let fptr = GeneralOperand::parse(stream)?;
201            stream.expect_complete()?;
202            stream.expect(&PtxToken::Comma)?;
203            stream.expect(&PtxToken::LParen)?;
204            let mut param_list = Vec::new();
205            // Parse comma-separated operands
206            loop {
207                // Try to parse an operand
208                let saved_pos = stream.position();
209                match GeneralOperand::parse(stream) {
210                    Ok(operand) => {
211                        param_list.push(operand);
212                        // Check for comma
213                        if stream.expect(&PtxToken::Comma).is_err() {
214                            break;
215                        }
216                    }
217                    Err(_) => {
218                        stream.set_position(saved_pos);
219                        break;
220                    }
221                }
222            }
223            stream.expect(&PtxToken::RParen)?;
224            stream.expect_complete()?;
225            stream.expect(&PtxToken::Comma)?;
226            let flist = GeneralOperand::parse(stream)?;
227            stream.expect_complete()?;
228            stream.expect_complete()?;
229            stream.expect(&PtxToken::Semicolon)?;
230            Ok(CallUni4 {
231                uni,
232                fptr,
233                param_list,
234                flist,
235            })
236        }
237    }
238
239    impl PtxParser for CallUni5 {
240        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
241            stream.expect_string("call")?;
242            let saved_pos = stream.position();
243            let uni = stream.expect_string(".uni").is_ok();
244            if !uni {
245                stream.set_position(saved_pos);
246            }
247            stream.expect_complete()?;
248            let fptr = GeneralOperand::parse(stream)?;
249            stream.expect_complete()?;
250            stream.expect(&PtxToken::Comma)?;
251            let flist = GeneralOperand::parse(stream)?;
252            stream.expect_complete()?;
253            stream.expect_complete()?;
254            stream.expect(&PtxToken::Semicolon)?;
255            Ok(CallUni5 { uni, fptr, flist })
256        }
257    }
258
259    impl PtxParser for CallUni6 {
260        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
261            stream.expect_string("call")?;
262            let saved_pos = stream.position();
263            let uni = stream.expect_string(".uni").is_ok();
264            if !uni {
265                stream.set_position(saved_pos);
266            }
267            stream.expect_complete()?;
268            stream.expect(&PtxToken::LParen)?;
269            let ret_param = GeneralOperand::parse(stream)?;
270            stream.expect(&PtxToken::RParen)?;
271            stream.expect_complete()?;
272            stream.expect(&PtxToken::Comma)?;
273            let fptr = GeneralOperand::parse(stream)?;
274            stream.expect_complete()?;
275            stream.expect(&PtxToken::Comma)?;
276            stream.expect(&PtxToken::LParen)?;
277            let mut param_list = Vec::new();
278            // Parse comma-separated operands
279            loop {
280                // Try to parse an operand
281                let saved_pos = stream.position();
282                match GeneralOperand::parse(stream) {
283                    Ok(operand) => {
284                        param_list.push(operand);
285                        // Check for comma
286                        if stream.expect(&PtxToken::Comma).is_err() {
287                            break;
288                        }
289                    }
290                    Err(_) => {
291                        stream.set_position(saved_pos);
292                        break;
293                    }
294                }
295            }
296            stream.expect(&PtxToken::RParen)?;
297            stream.expect_complete()?;
298            stream.expect(&PtxToken::Comma)?;
299            let fproto = GeneralOperand::parse(stream)?;
300            stream.expect_complete()?;
301            stream.expect_complete()?;
302            stream.expect(&PtxToken::Semicolon)?;
303            Ok(CallUni6 {
304                uni,
305                ret_param,
306                fptr,
307                param_list,
308                fproto,
309            })
310        }
311    }
312
313    impl PtxParser for CallUni7 {
314        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
315            stream.expect_string("call")?;
316            let saved_pos = stream.position();
317            let uni = stream.expect_string(".uni").is_ok();
318            if !uni {
319                stream.set_position(saved_pos);
320            }
321            stream.expect_complete()?;
322            let fptr = GeneralOperand::parse(stream)?;
323            stream.expect_complete()?;
324            stream.expect(&PtxToken::Comma)?;
325            stream.expect(&PtxToken::LParen)?;
326            let mut param_list = Vec::new();
327            // Parse comma-separated operands
328            loop {
329                // Try to parse an operand
330                let saved_pos = stream.position();
331                match GeneralOperand::parse(stream) {
332                    Ok(operand) => {
333                        param_list.push(operand);
334                        // Check for comma
335                        if stream.expect(&PtxToken::Comma).is_err() {
336                            break;
337                        }
338                    }
339                    Err(_) => {
340                        stream.set_position(saved_pos);
341                        break;
342                    }
343                }
344            }
345            stream.expect(&PtxToken::RParen)?;
346            stream.expect_complete()?;
347            stream.expect(&PtxToken::Comma)?;
348            let fproto = GeneralOperand::parse(stream)?;
349            stream.expect_complete()?;
350            stream.expect_complete()?;
351            stream.expect(&PtxToken::Semicolon)?;
352            Ok(CallUni7 {
353                uni,
354                fptr,
355                param_list,
356                fproto,
357            })
358        }
359    }
360
361    impl PtxParser for CallUni8 {
362        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
363            stream.expect_string("call")?;
364            let saved_pos = stream.position();
365            let uni = stream.expect_string(".uni").is_ok();
366            if !uni {
367                stream.set_position(saved_pos);
368            }
369            stream.expect_complete()?;
370            let fptr = GeneralOperand::parse(stream)?;
371            stream.expect_complete()?;
372            stream.expect(&PtxToken::Comma)?;
373            let fproto = GeneralOperand::parse(stream)?;
374            stream.expect_complete()?;
375            stream.expect_complete()?;
376            stream.expect(&PtxToken::Semicolon)?;
377            Ok(CallUni8 { uni, fptr, fproto })
378        }
379    }
380}
ptx_parser/parser/instruction/call.rs

ptx_parser/parser/instruction/
call.rs
