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::parser::{
19    PtxParseError, PtxParser, PtxTokenStream, Span,
20    util::{
21        between, comma_p, directive_p, exclamation_p, lbracket_p, lparen_p, map, minus_p, optional,
22        pipe_p, rbracket_p, rparen_p, semicolon_p, sep_by, string_p, try_map,
23    },
24};
25use crate::r#type::common::*;
26use crate::{alt, ok, seq_n};
27
28pub mod section_0 {
29    use super::*;
30    use crate::r#type::instruction::call::section_0::*;
31
32    impl PtxParser for CallUni {
33        fn parse() -> impl Fn(&mut PtxTokenStream) -> Result<(Self, Span), PtxParseError> {
34            try_map(
35                seq_n!(
36                    string_p("call"),
37                    map(optional(string_p(".uni")), |value, _| value.is_some()),
38                    between(lparen_p(), rparen_p(), GeneralOperand::parse()),
39                    comma_p(),
40                    GeneralOperand::parse(),
41                    comma_p(),
42                    between(
43                        lparen_p(),
44                        rparen_p(),
45                        sep_by(GeneralOperand::parse(), comma_p())
46                    ),
47                    semicolon_p()
48                ),
49                |(_, uni, ret_param, _, func, _, param_list, _), span| {
50                    ok!(CallUni {
51                        uni = uni,
52                        ret_param = ret_param,
53                        func = func,
54                        param_list = param_list,
55
56                    })
57                },
58            )
59        }
60    }
61
62    impl PtxParser for CallUni1 {
63        fn parse() -> impl Fn(&mut PtxTokenStream) -> Result<(Self, Span), PtxParseError> {
64            try_map(
65                seq_n!(
66                    string_p("call"),
67                    map(optional(string_p(".uni")), |value, _| value.is_some()),
68                    GeneralOperand::parse(),
69                    comma_p(),
70                    between(
71                        lparen_p(),
72                        rparen_p(),
73                        sep_by(GeneralOperand::parse(), comma_p())
74                    ),
75                    semicolon_p()
76                ),
77                |(_, uni, func, _, param_list, _), span| {
78                    ok!(CallUni1 {
79                        uni = uni,
80                        func = func,
81                        param_list = param_list,
82
83                    })
84                },
85            )
86        }
87    }
88
89    impl PtxParser for CallUni2 {
90        fn parse() -> impl Fn(&mut PtxTokenStream) -> Result<(Self, Span), PtxParseError> {
91            try_map(
92                seq_n!(
93                    string_p("call"),
94                    map(optional(string_p(".uni")), |value, _| value.is_some()),
95                    GeneralOperand::parse(),
96                    semicolon_p()
97                ),
98                |(_, uni, func, _), span| {
99                    ok!(CallUni2 {
100                        uni = uni,
101                        func = func,
102
103                    })
104                },
105            )
106        }
107    }
108
109    impl PtxParser for CallUni3 {
110        fn parse() -> impl Fn(&mut PtxTokenStream) -> Result<(Self, Span), PtxParseError> {
111            try_map(
112                seq_n!(
113                    string_p("call"),
114                    map(optional(string_p(".uni")), |value, _| value.is_some()),
115                    between(lparen_p(), rparen_p(), GeneralOperand::parse()),
116                    comma_p(),
117                    GeneralOperand::parse(),
118                    comma_p(),
119                    between(
120                        lparen_p(),
121                        rparen_p(),
122                        sep_by(GeneralOperand::parse(), comma_p())
123                    ),
124                    comma_p(),
125                    GeneralOperand::parse(),
126                    semicolon_p()
127                ),
128                |(_, uni, ret_param, _, fptr, _, param_list, _, flist, _), span| {
129                    ok!(CallUni3 {
130                        uni = uni,
131                        ret_param = ret_param,
132                        fptr = fptr,
133                        param_list = param_list,
134                        flist = flist,
135
136                    })
137                },
138            )
139        }
140    }
141
142    impl PtxParser for CallUni4 {
143        fn parse() -> impl Fn(&mut PtxTokenStream) -> Result<(Self, Span), PtxParseError> {
144            try_map(
145                seq_n!(
146                    string_p("call"),
147                    map(optional(string_p(".uni")), |value, _| value.is_some()),
148                    GeneralOperand::parse(),
149                    comma_p(),
150                    between(
151                        lparen_p(),
152                        rparen_p(),
153                        sep_by(GeneralOperand::parse(), comma_p())
154                    ),
155                    comma_p(),
156                    GeneralOperand::parse(),
157                    semicolon_p()
158                ),
159                |(_, uni, fptr, _, param_list, _, flist, _), span| {
160                    ok!(CallUni4 {
161                        uni = uni,
162                        fptr = fptr,
163                        param_list = param_list,
164                        flist = flist,
165
166                    })
167                },
168            )
169        }
170    }
171
172    impl PtxParser for CallUni5 {
173        fn parse() -> impl Fn(&mut PtxTokenStream) -> Result<(Self, Span), PtxParseError> {
174            try_map(
175                seq_n!(
176                    string_p("call"),
177                    map(optional(string_p(".uni")), |value, _| value.is_some()),
178                    GeneralOperand::parse(),
179                    comma_p(),
180                    GeneralOperand::parse(),
181                    semicolon_p()
182                ),
183                |(_, uni, fptr, _, flist, _), span| {
184                    ok!(CallUni5 {
185                        uni = uni,
186                        fptr = fptr,
187                        flist = flist,
188
189                    })
190                },
191            )
192        }
193    }
194
195    impl PtxParser for CallUni6 {
196        fn parse() -> impl Fn(&mut PtxTokenStream) -> Result<(Self, Span), PtxParseError> {
197            try_map(
198                seq_n!(
199                    string_p("call"),
200                    map(optional(string_p(".uni")), |value, _| value.is_some()),
201                    between(lparen_p(), rparen_p(), GeneralOperand::parse()),
202                    comma_p(),
203                    GeneralOperand::parse(),
204                    comma_p(),
205                    between(
206                        lparen_p(),
207                        rparen_p(),
208                        sep_by(GeneralOperand::parse(), comma_p())
209                    ),
210                    comma_p(),
211                    GeneralOperand::parse(),
212                    semicolon_p()
213                ),
214                |(_, uni, ret_param, _, fptr, _, param_list, _, fproto, _), span| {
215                    ok!(CallUni6 {
216                        uni = uni,
217                        ret_param = ret_param,
218                        fptr = fptr,
219                        param_list = param_list,
220                        fproto = fproto,
221
222                    })
223                },
224            )
225        }
226    }
227
228    impl PtxParser for CallUni7 {
229        fn parse() -> impl Fn(&mut PtxTokenStream) -> Result<(Self, Span), PtxParseError> {
230            try_map(
231                seq_n!(
232                    string_p("call"),
233                    map(optional(string_p(".uni")), |value, _| value.is_some()),
234                    GeneralOperand::parse(),
235                    comma_p(),
236                    between(
237                        lparen_p(),
238                        rparen_p(),
239                        sep_by(GeneralOperand::parse(), comma_p())
240                    ),
241                    comma_p(),
242                    GeneralOperand::parse(),
243                    semicolon_p()
244                ),
245                |(_, uni, fptr, _, param_list, _, fproto, _), span| {
246                    ok!(CallUni7 {
247                        uni = uni,
248                        fptr = fptr,
249                        param_list = param_list,
250                        fproto = fproto,
251
252                    })
253                },
254            )
255        }
256    }
257
258    impl PtxParser for CallUni8 {
259        fn parse() -> impl Fn(&mut PtxTokenStream) -> Result<(Self, Span), PtxParseError> {
260            try_map(
261                seq_n!(
262                    string_p("call"),
263                    map(optional(string_p(".uni")), |value, _| value.is_some()),
264                    GeneralOperand::parse(),
265                    comma_p(),
266                    GeneralOperand::parse(),
267                    semicolon_p()
268                ),
269                |(_, uni, fptr, _, fproto, _), span| {
270                    ok!(CallUni8 {
271                        uni = uni,
272                        fptr = fptr,
273                        fproto = fproto,
274
275                    })
276                },
277            )
278        }
279    }
280}
ptx_parser/parser/instruction/call.rs

ptx_parser/parser/instruction/
call.rs
