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
77    impl PtxParser for CallUni1 {
78        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
79            stream.expect_string("call")?;
80            let saved_pos = stream.position();
81            let uni = stream.expect_string(".uni").is_ok();
82            if !uni {
83                stream.set_position(saved_pos);
84            }
85            stream.expect_complete()?;
86            let func = GeneralOperand::parse(stream)?;
87            stream.expect_complete()?;
88            stream.expect(&PtxToken::Comma)?;
89            stream.expect(&PtxToken::LParen)?;
90            let mut param_list = Vec::new();
91            // Parse comma-separated operands
92            loop {
93                // Try to parse an operand
94                let saved_pos = stream.position();
95                match GeneralOperand::parse(stream) {
96                    Ok(operand) => {
97                        param_list.push(operand);
98                        // Check for comma
99                        if stream.expect(&PtxToken::Comma).is_err() {
100                            break;
101                        }
102                    }
103                    Err(_) => {
104                        stream.set_position(saved_pos);
105                        break;
106                    }
107                }
108            }
109            stream.expect(&PtxToken::RParen)?;
110            stream.expect_complete()?;
111            stream.expect_complete()?;
112            stream.expect(&PtxToken::Semicolon)?;
113            Ok(CallUni1 {
114                uni,
115                func,
116                param_list,
117            })
118        }
119    }
120
121
122    impl PtxParser for CallUni2 {
123        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
124            stream.expect_string("call")?;
125            let saved_pos = stream.position();
126            let uni = stream.expect_string(".uni").is_ok();
127            if !uni {
128                stream.set_position(saved_pos);
129            }
130            stream.expect_complete()?;
131            let func = GeneralOperand::parse(stream)?;
132            stream.expect_complete()?;
133            stream.expect_complete()?;
134            stream.expect(&PtxToken::Semicolon)?;
135            Ok(CallUni2 {
136                uni,
137                func,
138            })
139        }
140    }
141
142
143    impl PtxParser for CallUni3 {
144        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
145            stream.expect_string("call")?;
146            let saved_pos = stream.position();
147            let uni = stream.expect_string(".uni").is_ok();
148            if !uni {
149                stream.set_position(saved_pos);
150            }
151            stream.expect_complete()?;
152            stream.expect(&PtxToken::LParen)?;
153            let ret_param = GeneralOperand::parse(stream)?;
154            stream.expect(&PtxToken::RParen)?;
155            stream.expect_complete()?;
156            stream.expect(&PtxToken::Comma)?;
157            let fptr = GeneralOperand::parse(stream)?;
158            stream.expect_complete()?;
159            stream.expect(&PtxToken::Comma)?;
160            stream.expect(&PtxToken::LParen)?;
161            let mut param_list = Vec::new();
162            // Parse comma-separated operands
163            loop {
164                // Try to parse an operand
165                let saved_pos = stream.position();
166                match GeneralOperand::parse(stream) {
167                    Ok(operand) => {
168                        param_list.push(operand);
169                        // Check for comma
170                        if stream.expect(&PtxToken::Comma).is_err() {
171                            break;
172                        }
173                    }
174                    Err(_) => {
175                        stream.set_position(saved_pos);
176                        break;
177                    }
178                }
179            }
180            stream.expect(&PtxToken::RParen)?;
181            stream.expect_complete()?;
182            stream.expect(&PtxToken::Comma)?;
183            let flist = GeneralOperand::parse(stream)?;
184            stream.expect_complete()?;
185            stream.expect_complete()?;
186            stream.expect(&PtxToken::Semicolon)?;
187            Ok(CallUni3 {
188                uni,
189                ret_param,
190                fptr,
191                param_list,
192                flist,
193            })
194        }
195    }
196
197
198    impl PtxParser for CallUni4 {
199        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
200            stream.expect_string("call")?;
201            let saved_pos = stream.position();
202            let uni = stream.expect_string(".uni").is_ok();
203            if !uni {
204                stream.set_position(saved_pos);
205            }
206            stream.expect_complete()?;
207            let fptr = GeneralOperand::parse(stream)?;
208            stream.expect_complete()?;
209            stream.expect(&PtxToken::Comma)?;
210            stream.expect(&PtxToken::LParen)?;
211            let mut param_list = Vec::new();
212            // Parse comma-separated operands
213            loop {
214                // Try to parse an operand
215                let saved_pos = stream.position();
216                match GeneralOperand::parse(stream) {
217                    Ok(operand) => {
218                        param_list.push(operand);
219                        // Check for comma
220                        if stream.expect(&PtxToken::Comma).is_err() {
221                            break;
222                        }
223                    }
224                    Err(_) => {
225                        stream.set_position(saved_pos);
226                        break;
227                    }
228                }
229            }
230            stream.expect(&PtxToken::RParen)?;
231            stream.expect_complete()?;
232            stream.expect(&PtxToken::Comma)?;
233            let flist = GeneralOperand::parse(stream)?;
234            stream.expect_complete()?;
235            stream.expect_complete()?;
236            stream.expect(&PtxToken::Semicolon)?;
237            Ok(CallUni4 {
238                uni,
239                fptr,
240                param_list,
241                flist,
242            })
243        }
244    }
245
246
247    impl PtxParser for CallUni5 {
248        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
249            stream.expect_string("call")?;
250            let saved_pos = stream.position();
251            let uni = stream.expect_string(".uni").is_ok();
252            if !uni {
253                stream.set_position(saved_pos);
254            }
255            stream.expect_complete()?;
256            let fptr = GeneralOperand::parse(stream)?;
257            stream.expect_complete()?;
258            stream.expect(&PtxToken::Comma)?;
259            let flist = GeneralOperand::parse(stream)?;
260            stream.expect_complete()?;
261            stream.expect_complete()?;
262            stream.expect(&PtxToken::Semicolon)?;
263            Ok(CallUni5 {
264                uni,
265                fptr,
266                flist,
267            })
268        }
269    }
270
271
272    impl PtxParser for CallUni6 {
273        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
274            stream.expect_string("call")?;
275            let saved_pos = stream.position();
276            let uni = stream.expect_string(".uni").is_ok();
277            if !uni {
278                stream.set_position(saved_pos);
279            }
280            stream.expect_complete()?;
281            stream.expect(&PtxToken::LParen)?;
282            let ret_param = GeneralOperand::parse(stream)?;
283            stream.expect(&PtxToken::RParen)?;
284            stream.expect_complete()?;
285            stream.expect(&PtxToken::Comma)?;
286            let fptr = GeneralOperand::parse(stream)?;
287            stream.expect_complete()?;
288            stream.expect(&PtxToken::Comma)?;
289            stream.expect(&PtxToken::LParen)?;
290            let mut param_list = Vec::new();
291            // Parse comma-separated operands
292            loop {
293                // Try to parse an operand
294                let saved_pos = stream.position();
295                match GeneralOperand::parse(stream) {
296                    Ok(operand) => {
297                        param_list.push(operand);
298                        // Check for comma
299                        if stream.expect(&PtxToken::Comma).is_err() {
300                            break;
301                        }
302                    }
303                    Err(_) => {
304                        stream.set_position(saved_pos);
305                        break;
306                    }
307                }
308            }
309            stream.expect(&PtxToken::RParen)?;
310            stream.expect_complete()?;
311            stream.expect(&PtxToken::Comma)?;
312            let fproto = GeneralOperand::parse(stream)?;
313            stream.expect_complete()?;
314            stream.expect_complete()?;
315            stream.expect(&PtxToken::Semicolon)?;
316            Ok(CallUni6 {
317                uni,
318                ret_param,
319                fptr,
320                param_list,
321                fproto,
322            })
323        }
324    }
325
326
327    impl PtxParser for CallUni7 {
328        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
329            stream.expect_string("call")?;
330            let saved_pos = stream.position();
331            let uni = stream.expect_string(".uni").is_ok();
332            if !uni {
333                stream.set_position(saved_pos);
334            }
335            stream.expect_complete()?;
336            let fptr = GeneralOperand::parse(stream)?;
337            stream.expect_complete()?;
338            stream.expect(&PtxToken::Comma)?;
339            stream.expect(&PtxToken::LParen)?;
340            let mut param_list = Vec::new();
341            // Parse comma-separated operands
342            loop {
343                // Try to parse an operand
344                let saved_pos = stream.position();
345                match GeneralOperand::parse(stream) {
346                    Ok(operand) => {
347                        param_list.push(operand);
348                        // Check for comma
349                        if stream.expect(&PtxToken::Comma).is_err() {
350                            break;
351                        }
352                    }
353                    Err(_) => {
354                        stream.set_position(saved_pos);
355                        break;
356                    }
357                }
358            }
359            stream.expect(&PtxToken::RParen)?;
360            stream.expect_complete()?;
361            stream.expect(&PtxToken::Comma)?;
362            let fproto = GeneralOperand::parse(stream)?;
363            stream.expect_complete()?;
364            stream.expect_complete()?;
365            stream.expect(&PtxToken::Semicolon)?;
366            Ok(CallUni7 {
367                uni,
368                fptr,
369                param_list,
370                fproto,
371            })
372        }
373    }
374
375
376    impl PtxParser for CallUni8 {
377        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
378            stream.expect_string("call")?;
379            let saved_pos = stream.position();
380            let uni = stream.expect_string(".uni").is_ok();
381            if !uni {
382                stream.set_position(saved_pos);
383            }
384            stream.expect_complete()?;
385            let fptr = GeneralOperand::parse(stream)?;
386            stream.expect_complete()?;
387            stream.expect(&PtxToken::Comma)?;
388            let fproto = GeneralOperand::parse(stream)?;
389            stream.expect_complete()?;
390            stream.expect_complete()?;
391            stream.expect(&PtxToken::Semicolon)?;
392            Ok(CallUni8 {
393                uni,
394                fptr,
395                fproto,
396            })
397        }
398    }
399
400
401}
402
ptx_parser/parser/instruction/call.rs

ptx_parser/parser/instruction/
call.rs
