Branch data Line data Source code
1 : : // Copyright (C) 2020-2025 Free Software Foundation, Inc.
2 : :
3 : : // This file is part of GCC.
4 : :
5 : : // GCC is free software; you can redistribute it and/or modify it under
6 : : // the terms of the GNU General Public License as published by the Free
7 : : // Software Foundation; either version 3, or (at your option) any later
8 : : // version.
9 : :
10 : : // GCC is distributed in the hope that it will be useful, but WITHOUT ANY
11 : : // WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 : : // FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
13 : : // for more details.
14 : :
15 : : // You should have received a copy of the GNU General Public License
16 : : // along with GCC; see the file COPYING3. If not see
17 : : // <http://www.gnu.org/licenses/>.
18 : :
19 : : #include "rust-macro-builtins-helpers.h"
20 : :
21 : : namespace Rust {
22 : :
23 : : std::string
24 : 7 : make_macro_path_str (BuiltinMacro kind)
25 : : {
26 : 7 : auto str = MacroBuiltin::builtins.lookup (kind);
27 : 7 : rust_assert (str.has_value ());
28 : :
29 : 7 : return str.value ();
30 : : }
31 : :
32 : : std::vector<std::unique_ptr<AST::MacroInvocation>>
33 : 86 : check_for_eager_invocations (
34 : : std::vector<std::unique_ptr<AST::Expr>> &expressions)
35 : : {
36 : 86 : std::vector<std::unique_ptr<AST::MacroInvocation>> pending;
37 : :
38 : 261 : for (auto &expr : expressions)
39 : 175 : if (expr->get_ast_kind () == AST::Kind::MACRO_INVOCATION)
40 : 20 : pending.emplace_back (std::unique_ptr<AST::MacroInvocation> (
41 : 20 : static_cast<AST::MacroInvocation *> (expr->clone_expr ().release ())));
42 : :
43 : 86 : return pending;
44 : : }
45 : :
46 : : //
47 : : // Shorthand function for creating unique_ptr tokens
48 : : //
49 : : std::unique_ptr<AST::Token>
50 : 2424 : make_token (const TokenPtr tok)
51 : : {
52 : 2424 : return std::unique_ptr<AST::Token> (new AST::Token (tok));
53 : : }
54 : :
55 : : std::unique_ptr<AST::Expr>
56 : 89 : make_string (location_t locus, std::string value)
57 : : {
58 : 89 : return std::unique_ptr<AST::Expr> (
59 : : new AST::LiteralExpr (value, AST::Literal::STRING,
60 : 89 : PrimitiveCoreType::CORETYPE_STR, {}, locus));
61 : : }
62 : :
63 : : // TODO: Is this correct?
64 : : AST::Fragment
65 : 6 : make_eager_builtin_invocation (
66 : : BuiltinMacro kind, location_t locus, AST::DelimTokenTree arguments,
67 : : std::vector<std::unique_ptr<AST::MacroInvocation>> &&pending_invocations)
68 : : {
69 : 6 : auto path_str = make_macro_path_str (kind);
70 : :
71 : 12 : std::unique_ptr<AST::Expr> node = AST::MacroInvocation::Builtin (
72 : : kind,
73 : 6 : AST::MacroInvocData (AST::SimplePath (
74 : 24 : {AST::SimplePathSegment (path_str, locus)}),
75 : 18 : std::move (arguments)),
76 : 6 : {}, locus, std::move (pending_invocations));
77 : :
78 : 12 : return AST::Fragment ({AST::SingleASTNode (std::move (node))},
79 : 18 : arguments.to_token_stream ());
80 : 6 : }
81 : :
82 : : /* Match the end token of a macro given the start delimiter of the macro */
83 : : TokenId
84 : 126 : macro_end_token (AST::DelimTokenTree &invoc_token_tree,
85 : : Parser<MacroInvocLexer> &parser)
86 : : {
87 : 126 : auto last_token_id = TokenId::RIGHT_CURLY;
88 : 126 : switch (invoc_token_tree.get_delim_type ())
89 : : {
90 : 126 : case AST::DelimType::PARENS:
91 : 126 : last_token_id = TokenId::RIGHT_PAREN;
92 : 126 : rust_assert (parser.skip_token (LEFT_PAREN));
93 : : break;
94 : :
95 : 0 : case AST::DelimType::CURLY:
96 : 0 : rust_assert (parser.skip_token (LEFT_CURLY));
97 : : break;
98 : :
99 : 0 : case AST::DelimType::SQUARE:
100 : 0 : last_token_id = TokenId::RIGHT_SQUARE;
101 : 0 : rust_assert (parser.skip_token (LEFT_SQUARE));
102 : : break;
103 : : }
104 : :
105 : 126 : return last_token_id;
106 : : }
107 : :
108 : : // Expand and then extract a string literal from the macro
109 : : std::unique_ptr<AST::LiteralExpr>
110 : 30 : try_extract_string_literal_from_fragment (const location_t &parent_locus,
111 : : std::unique_ptr<AST::Expr> &node)
112 : : {
113 : 30 : auto maybe_lit = static_cast<AST::LiteralExpr *> (node.get ());
114 : 30 : if (!node || !node->is_literal ()
115 : 59 : || maybe_lit->get_lit_type () != AST::Literal::STRING)
116 : : {
117 : 4 : rust_error_at (parent_locus, "argument must be a string literal");
118 : 4 : if (node)
119 : 4 : rust_inform (node->get_locus (), "expanded from here");
120 : 4 : return nullptr;
121 : : }
122 : 26 : return std::unique_ptr<AST::LiteralExpr> (
123 : 26 : static_cast<AST::LiteralExpr *> (node->clone_expr ().release ()));
124 : : }
125 : :
126 : : std::vector<std::unique_ptr<AST::Expr>>
127 : 88 : try_expand_many_expr (Parser<MacroInvocLexer> &parser,
128 : : const TokenId last_token_id, MacroExpander *expander,
129 : : bool &has_error)
130 : : {
131 : 88 : auto restrictions = Rust::ParseRestrictions ();
132 : : // stop parsing when encountered a braces/brackets
133 : 88 : restrictions.expr_can_be_null = true;
134 : : // we can't use std::optional, so...
135 : 88 : auto result = std::vector<std::unique_ptr<AST::Expr>> ();
136 : 88 : auto empty_expr = std::vector<std::unique_ptr<AST::Expr>> ();
137 : :
138 : 88 : auto first_token = parser.peek_current_token ()->get_id ();
139 : 88 : if (first_token == COMMA)
140 : : {
141 : 2 : rust_error_at (parser.peek_current_token ()->get_locus (),
142 : : "expected expression, found %<,%>");
143 : 2 : has_error = true;
144 : 2 : return empty_expr;
145 : : }
146 : :
147 : 522 : while (parser.peek_current_token ()->get_id () != last_token_id
148 : 876 : && parser.peek_current_token ()->get_id () != END_OF_FILE)
149 : : {
150 : 177 : auto expr = parser.parse_expr (AST::AttrVec (), restrictions);
151 : : // something must be so wrong that the expression could not be parsed
152 : 177 : rust_assert (expr);
153 : 177 : result.push_back (std::move (expr));
154 : :
155 : 177 : auto next_token = parser.peek_current_token ();
156 : 177 : if (!parser.skip_token (COMMA) && next_token->get_id () != last_token_id)
157 : : {
158 : 2 : rust_error_at (next_token->get_locus (), "expected token: %<,%>");
159 : : // TODO: is this recoverable? to avoid crashing the parser in the next
160 : : // fragment we have to exit early here
161 : 2 : has_error = true;
162 : 2 : return empty_expr;
163 : : }
164 : 177 : }
165 : :
166 : 84 : return result;
167 : 88 : }
168 : :
169 : : // Parse a single string literal from the given delimited token tree,
170 : : // and return the LiteralExpr for it. Allow for an optional trailing comma,
171 : : // but otherwise enforce that these are the only tokens.
172 : : // FIXME(Arthur): This function needs a rework - it should not emit errors, it
173 : : // should probably be smaller
174 : : std::unique_ptr<AST::Expr>
175 : 37 : parse_single_string_literal (BuiltinMacro kind,
176 : : AST::DelimTokenTree &invoc_token_tree,
177 : : location_t invoc_locus, MacroExpander *expander)
178 : : {
179 : 37 : MacroInvocLexer lex (invoc_token_tree.to_token_stream ());
180 : 37 : Parser<MacroInvocLexer> parser (lex);
181 : :
182 : 37 : auto last_token_id = macro_end_token (invoc_token_tree, parser);
183 : :
184 : 37 : std::unique_ptr<AST::LiteralExpr> lit_expr = nullptr;
185 : 37 : std::unique_ptr<AST::MacroInvocation> macro_invoc = nullptr;
186 : :
187 : 74 : if (parser.peek_current_token ()->get_id () == STRING_LITERAL)
188 : : {
189 : 30 : lit_expr = parser.parse_literal_expr ();
190 : 30 : parser.maybe_skip_token (COMMA);
191 : 60 : if (parser.peek_current_token ()->get_id () != last_token_id)
192 : : {
193 : 3 : lit_expr = nullptr;
194 : 3 : rust_error_at (invoc_locus, "macro takes 1 argument");
195 : : }
196 : : }
197 : 14 : else if (parser.peek_current_token ()->get_id () == last_token_id)
198 : 3 : rust_error_at (invoc_locus, "macro takes 1 argument");
199 : : else
200 : : {
201 : 4 : macro_invoc = parser.parse_macro_invocation (AST::AttrVec ());
202 : :
203 : 4 : parser.maybe_skip_token (COMMA);
204 : 8 : if (parser.peek_current_token ()->get_id () != last_token_id)
205 : : {
206 : 0 : lit_expr = nullptr;
207 : 0 : rust_error_at (invoc_locus, "macro takes 1 argument");
208 : : }
209 : :
210 : 4 : if (macro_invoc != nullptr)
211 : : {
212 : 1 : auto path_str = make_macro_path_str (kind);
213 : :
214 : 1 : auto pending_invocations
215 : 1 : = std::vector<std::unique_ptr<AST::MacroInvocation>> ();
216 : :
217 : 1 : pending_invocations.push_back (std::move (macro_invoc));
218 : :
219 : 2 : return AST::MacroInvocation::Builtin (
220 : : kind,
221 : 1 : AST::MacroInvocData (AST::SimplePath ({AST::SimplePathSegment (
222 : 4 : path_str, invoc_locus)}),
223 : 3 : std::move (invoc_token_tree)),
224 : 1 : {}, invoc_locus, std::move (pending_invocations));
225 : 1 : }
226 : : else
227 : : {
228 : 3 : rust_error_at (invoc_locus, "argument must be a string literal or a "
229 : : "macro which expands to a string");
230 : : }
231 : : }
232 : :
233 : 36 : parser.skip_token (last_token_id);
234 : :
235 : 36 : return std::unique_ptr<AST::Expr> (std::move (lit_expr));
236 : 74 : }
237 : :
238 : : /* Treat PATH as a path relative to the source file currently being
239 : : compiled, and return the absolute path for it. */
240 : : std::string
241 : 25 : source_relative_path (std::string path, location_t locus)
242 : : {
243 : 25 : std::string compile_fname = LOCATION_FILE (locus);
244 : :
245 : 25 : auto dir_separator_pos = compile_fname.rfind (file_separator);
246 : :
247 : : /* If there is no file_separator in the path, use current dir ('.'). */
248 : 25 : std::string dirname;
249 : 25 : if (dir_separator_pos == std::string::npos)
250 : 0 : dirname = std::string (".") + file_separator;
251 : : else
252 : 50 : dirname = compile_fname.substr (0, dir_separator_pos) + file_separator;
253 : :
254 : 25 : return dirname + path;
255 : 25 : }
256 : :
257 : : /* Read the full contents of the file FILENAME and return them in a vector.
258 : : FIXME: platform specific. */
259 : : tl::optional<std::vector<uint8_t>>
260 : 24 : load_file_bytes (location_t invoc_locus, const char *filename)
261 : : {
262 : 24 : RAIIFile file_wrap (filename);
263 : 24 : if (file_wrap.get_raw () == nullptr)
264 : : {
265 : 4 : rust_error_at (invoc_locus, "cannot open filename %s: %m", filename);
266 : 4 : return tl::nullopt;
267 : : }
268 : :
269 : 20 : FILE *f = file_wrap.get_raw ();
270 : 20 : fseek (f, 0L, SEEK_END);
271 : 20 : long fsize = ftell (f);
272 : 20 : fseek (f, 0L, SEEK_SET);
273 : :
274 : 20 : std::vector<uint8_t> buf (fsize);
275 : :
276 : 20 : if (fsize > 0 && fread (&buf[0], fsize, 1, f) != 1)
277 : : {
278 : 0 : rust_error_at (invoc_locus, "error reading file %s: %m", filename);
279 : 0 : return std::vector<uint8_t> ();
280 : : }
281 : :
282 : 20 : return buf;
283 : 20 : }
284 : : } // namespace Rust
|
