5.3.1.3. 内建宏—pragma指示的处理
所谓的内建宏，也即是标准所定义的宏，计有：__TIME__，__DATE__，__FILE__，__BASE_FILE__，__LINE__，__INCLUDE_LEVEL__，_Pragma及__STDC__（参考builtin_array），其处理函数为builtin_macro。
249 static int
250 builtin_macro (cpp_reader *pfile, cpp_hashnode *node) in cppmacro.c
251 {
252 const uchar *buf;
253 size_t len;
254 char *nbuf;
255
256 if (node->value.builtin == BT_PRAGMA)
257 {
258 /* Don't interpret _Pragma within directives. The standard is
259 not clear on this, but to me this makes most sense. */
260 if (pfile->state.in_directive)
261 return 0;
262
263 _cpp_do__Pragma (pfile);
264 return 1;
265 }
C99引入了_Pragma操作符。该特性针对#pragma的主要问题：作为一个指示，它不能作为宏扩展的结果中产生。_Pragma是一个操作符，非常像sizeof或defined，可以嵌入到宏里。
它的语法是_Pragma (STRING-LITERAL)，其中STRING-LITERAL可以是普通的或宽字符串。通过用“//”替换“/”，以及“/"”替换“"”，来去字符化。其结果，就像放在#pragma指示右边那样，得到处理。例如，
_Pragma ("GCC dependency /"parse.y/"")
和#pragma GCC dependency "parse.y"的效果相同。这个效果也可以使用宏实现，例如（我们亦把它作为下面代码学习的例子）
#define DO_PRAGMA(x) _Pragma (#x)
DO_PRAGMA (GCC dependency "parse.y")
标准没有澄清_Pragma操作符可以出现在何处。预处理器在预处理条件指示，如#if中，不接受它。为了安全起见，你最好不要在除#define以外的指示中使用它，并且让它独占一行。
1369 void
1370 _cpp_do__Pragma (cpp_reader *pfile) in cpplib.c
1371 {
1372 const cpp_token *string = get__Pragma_string (pfile);
1373
1374 if (string)
1375 destringize_and_run (pfile, &string->val.str);
1376 else
1377 cpp_error (pfile, CPP_DL_ERROR,
1378 "_Pragma takes a parenthesized string literal");
1379 }
_Pragma的内容是字符串，例程get__Pragma_string提取这个内容。
1289 static const cpp_token *
1290 get__Pragma_string (cpp_reader *pfile) in cpplib.c
1291{
1292 const cpp_token *string;
1293
1294 if (get_token_no_padding (pfile)->type != CPP_OPEN_PAREN)
1295 return NULL;
1296
1297 string = get_token_no_padding (pfile);
1298 if (string->type != CPP_STRING && string->type != CPP_WSTRING)
1299 return NULL;
1300
1301 if (get_token_no_padding (pfile)->type != CPP_CLOSE_PAREN)
1302 return NULL;
1303
1304 return string;
1305}
这个语句中的符号由get_token_no_padding获取，它只返回非空白符。
1276 static const cpp_token *
1277 get_token_no_padding (cpp_reader *pfile) in cpplib.c
1278 {
1279 for (;;)
1280 {
1281 const cpp_token *result = cpp_get_token (pfile);
1282 if (result->type != CPP_PADDING)
1283 return result;
1284 }
1285 }
这个字符串就是应该跟在#pragma后的部分。在执行对应的#pragma操作符之前，这个字符串还要字符化，以“/”替换“//”，以“.”替换“/””。
1309 static void
1310 destringize_and_run (cpp_reader *pfile, const cpp_string *in) in cpplib.c
1311 {
1312 const unsigned char *src, *limit;
1313 char *dest, *result;
1314
1315 dest = result = alloca (in->len - 1);
1316 src = in->text + 1 + (in->text[0] == 'L');
1317 limit = in->text + in->len - 1;
1318 while (src < limit)
1319 {
1320 /* We know there is a character following the backslash. */
1321 if (*src == '//' && (src[1] == '//' || src[1] == '"'))
1322 src++;
1323 *dest++ = *src++;
1324 }
1325 *dest = '/n';
1326
1327 /* Ugh; an awful kludge. We are really not set up to be lexing
1328 tokens when in the middle of a macro expansion. Use a new
1329 context to force cpp_get_token to lex, and so skip_rest_of_line
1330 doesn't go beyond the end of the text. Also, remember the
1331 current lexing position so we can return to it later.
1332
1333 Something like line-at-a-time lexing should remove the need for
1334 this. */
1335 {
1336 cpp_context *saved_context = pfile->context;
1337 cpp_token *saved_cur_token = pfile->cur_token;
1338 tokenrun *saved_cur_run = pfile->cur_run;
1339
1340 pfile->context = xnew (cpp_context);
1341 pfile->context->macro = 0;
1342 pfile->context->prev = 0;
1343 run_directive (pfile, T_PRAGMA, result, dest - result);
1344 free (pfile->context);
1345 pfile->context = saved_context;
1346 pfile->cur_token = saved_cur_token;
1347 pfile->cur_run = saved_cur_run;
1348 pfile->line--;
1349 }
1350
1351 /* See above comment. For the moment, we'd like
1352
1353 token1 _Pragma ("foo") token2
1354
1355 to be output as
1356
1357 token1
1358 # 7 "file.c"
1359 #pragma foo
1360 # 7 "file.c"
1361 token2
1362
1363 Getting the line markers is a little tricky. */
1364 if (pfile->cb.line_change)
1365 pfile->cb.line_change (pfile, pfile->cur_token, false);
1366 }
在上面1343行的run_directive中，这个经过还原的字符串由cpp_push_buffer压入当前cpp_reader的读入缓存。但是在cpp_get_token里看到，如果当前的上下文不是基本上下文的话，是由当前上下文读入符号，而不是从读入缓存读入符号。为了确保能从读入缓存读入符号，这里伪造了一个基本上下文（1342行的prev为0）。同时也要保存原来基本上下文的cur_token及cur_run。注意这意味着#pragma指示执行完后，其符号是会被挪作他用的。
1136 static void
1137 do_pragma (cpp_reader *pfile) in cpplib.c
1138 {
1139 const struct pragma_entry *p = NULL;
1140 const cpp_token *token, *pragma_token = pfile->cur_token;
1141 unsigned int count = 1;
1142
1143 pfile->state.prevent_expansion++;
1144
1145 token = cpp_get_token (pfile);
1146 if (token->type == CPP_NAME)
1147 {
1148 p = lookup_pragma_entry (pfile->pragmas, token->val.node);
1149 if (p && p->is_nspace)
1150 {
1151 count = 2;
1152 token = cpp_get_token (pfile);
1153 if (token->type == CPP_NAME)
1154 p = lookup_pragma_entry (p->u.space, token->val.node);
1155 else
1156 p = NULL;
1157 }
1158 }
1159
1160 if (p)
1161 {
1162 /* Since the handler below doesn't get the line number, that it
1163 might need for diagnostics, make sure it has the right
1164 numbers in place. */
1165 if (pfile->cb.line_change)
1166 (*pfile->cb.line_change) (pfile, pragma_token, false);
1167 (*p->u.handler) (pfile);
1168 }
1169 else if (pfile->cb.def_pragma)
1170 {
1171 _cpp_backup_tokens (pfile, count);
1172 pfile->cb.def_pragma (pfile, pfile->directive_line);
1173 }
1174
1175 pfile->state.prevent_expansion--;
1176 }
系统支持的#pragma操作符已经由cpp_register_pragma注册，而lookup_pragma_entry将为已注册的操作符返回其登记入口。这些注册的句柄构成了一个层级结构，以我们的例子来说，在1152行cpp_get_token提取了符号dependency，这是注册在句柄GCC下的。注意到当处理#pragma操作符时，宏是不允许展开的（通过1143行设置prevent_expansion）。
如果操作符没有注册，1169行的钩子def_pragma将被调用，它将给出一个警告消息。对于我们的例子，这个操作符由do_pragma_dependency来完成。
5.3.1.3.1. #pragma GCC dependency的句柄
当在文件中声明#pragma GCC dependency parse.y，这表示该文件依赖于parse.y，如果parse.y有更新，该文件也要更新。
1248 static void
1249 do_pragma_dependency (cpp_reader *pfile) in cpplib.c
1250 {
1251 const char *fname;
1252 int angle_brackets, ordering;
1253
1254 fname = parse_include (pfile, &angle_brackets);
1255 if (!fname)
1256 return;
1257
1258 ordering = _cpp_compare_file_date (pfile, fname, angle_brackets);
1259 if (ordering < 0)
1260 cpp_error (pfile, CPP_DL_WARNING, "cannot find source file %s", fname);
1261 else if (ordering > 0)
1262 {
1263 cpp_error (pfile, CPP_DL_WARNING,
1264 "current file is older than %s", fname);
1265 if (cpp_get_token (pfile)->type != CPP_EOF)
1266 {
1267 _cpp_backup_tokens (pfile, 1);
1268 do_diagnostic (pfile, CPP_DL_WARNING, 0);
1269 }
1270 }
1271
1272 free ((void *) fname);
1273 }
在指示中指定的文件名可以是形式<file>，这被认为是系统头文件，而且将在对应的查找路径下查找。函数parse_include收集这个文件名并确定它是否为系统头文件。
634 static const char *
635 parse_include (cpp_reader *pfile, int *pangle_brackets) in cpplib.c
636 {
637 char *fname;
638 const cpp_token *header;
639
640 /* Allow macro expansion. */
641 header = get_token_no_padding (pfile);
642 if (header->type == CPP_STRING || header->type == CPP_HEADER_NAME)
643 {
644 fname = xmalloc (header->val.str.len - 1);
645 memcpy (fname, header->val.str.text + 1, header->val.str.len - 2);
646 fname[header->val.str.len - 2] = '/0';
647 *pangle_brackets = header->type == CPP_HEADER_NAME;
648 }
649 else if (header->type == CPP_LESS)
650 {
651 fname = glue_header_name (pfile);
652 *pangle_brackets = 1;
653 }
654 else
655 {
656 const unsigned char *dir;
657
658 if (pfile->directive == &dtable[T_PRAGMA])
659 dir = U"pragma dependency";
660 else
661 dir = pfile->directive->name;
662 cpp_error(pfile, CPP_DL_ERROR, "#%s expects /"FILENAME/" or <FILENAME>",
663 dir);
664
665 return NULL;
666 }
667
668 check_eol (pfile);
669 return fname;
670 }
显然，只有字母，‘<’及‘>’可以出现在文件名里，否则将给出一个错误消息。收集完文件名的信息，_cpp_compare_file_date将按包含文件的查找规则，找出这个文件，并返回时间戳比较的结果。
1023 int
1024 _cpp_compare_file_date (cpp_reader *pfile, const char *fname, in cppfiles.c
1025 int angle_brackets)
1026 {
1027 _cpp_file *file;
1028 struct cpp_dir *dir;
1029
1030 dir = search_path_head (pfile, fname, angle_brackets, IT_INCLUDE);
1031 if (!dir)
1032 return -1;
1033
1034 file = _cpp_find_file (pfile, fname, dir, false, angle_brackets);
1035 if (file->err_no)
1036 return -1;
1037
1038 if (file->fd != -1)
1039 {
1040 close (file->fd);
1041 file->fd = -1;
1042 }
1043
1044 return file->st.st_mtime > pfile->buffer->file->st.st_mtime;
1045 }
当发现当前文件更旧时，这个#pragma操作符将给出警告。
5.3.1.4. 其它内建宏的处理
如果是其它的内建宏，下面部分的builtin_macro将得到执行。
builtin_macro (continue)
267 buf = _cpp_builtin_macro_text (pfile, node);
268 len = ustrlen (buf);
269 nbuf = alloca (len + 1);
270 memcpy (nbuf, buf, len);
271 nbuf[len]='/n';
272
273 cpp_push_buffer (pfile, (uchar *) nbuf, len, /* from_stage3 */ true);
274 _cpp_clean_line (pfile);
275
276 /* Set pfile->cur_token as required by _cpp_lex_direct. */
277 pfile->cur_token = _cpp_temp_token (pfile);
278 push_token_context (pfile, NULL, _cpp_lex_direct (pfile), 1);
279 if (pfile->buffer->cur != pfile->buffer->rlimit)
280 cpp_error (pfile, CPP_DL_ICE, "invalid built-in macro /"%s/"",
281 NODE_NAME (node));
282 _cpp_pop_buffer (pfile);
283
284 return 1;
285 }
所有这些内建宏是信息性的。更换文件一节详细描述了line_map结构的文件包含链。其中，宏__BASE_FILE__将被展开为主输入文件名。
116 const uchar *
117 _cpp_builtin_macro_text (cpp_reader *pfile, cpp_hashnode *node) in cppmacro.c
118 {
119 const uchar *result = NULL;
120 unsigned int number = 1;
121
122 switch (node->value.builtin)
123 {
124 default:
125 cpp_error (pfile, CPP_DL_ICE, "invalid built-in macro /"%s/"",
126 NODE_NAME (node));
127 break;
128
129 case BT_FILE:
130 case BT_BASE_FILE:
131 {
132 unsigned int len;
133 const char *name;
134 uchar *buf;
135 const struct line_map *map = pfile->map;
136
137 if (node->value.builtin == BT_BASE_FILE)
138 while (!MAIN_FILE_P (map))
139 map = INCLUDED_FROM (&pfile->line_maps, map);
140
141 name = map->to_file;
142 len = strlen (name);
143 buf = _cpp_unaligned_alloc (pfile, len * 4 + 3);
144 result = buf;
145 *buf = '"';
146 buf = cpp_quote_string (buf + 1, (const unsigned char *) name, len);
147 *buf++ = '"';
148 *buf = '/0';
149 }
150 break;
151
152 case BT_INCLUDE_LEVEL:
153 /* The line map depth counts the primary source as level 1, but
154 historically __INCLUDE_DEPTH__ has called the primary source
155 level 0. */
156 number = pfile->line_maps.depth - 1;
157 break;
158
159 case BT_SPECLINE:
160 /* If __LINE__ is embedded in a macro, it must expand to the
161 line of the macro's invocation, not its definition.
162 Otherwise things like assert() will not work properly. */
163 if (CPP_OPTION (pfile, traditional))
164 number = pfile->line;
165 else
166 number = pfile->cur_token[-1].line;
167 number = SOURCE_LINE (pfile->map, number);
168 break;
169
170 /* __STDC__ has the value 1 under normal circumstances.
171 However, if (a) we are in a system header, (b) the option
172 stdc_0_in_system_headers is true (set by target config), and
173 (c) we are not in strictly conforming mode, then it has the
174 value 0. */
175 case BT_STDC:
176 {
177 if (CPP_IN_SYSTEM_HEADER (pfile)
178 && CPP_OPTION (pfile, stdc_0_in_system_headers)
179 && !CPP_OPTION (pfile,std))
180 number = 0;
181 else
182 number = 1;
183 }
184 break;
185
186 case BT_DATE:
187 case BT_TIME:
188 if (pfile->date == NULL)
189 {
190 /* Allocate __DATE__ and __TIME__ strings from permanent
191 storage. We only do this once, and don't generate them
192 at init time, because time() and localtime() are very
193 slow on some systems. */
194 time_t tt;
195 struct tm *tb = NULL;
196
197 /* (time_t) -1 is a legitimate value for "number of seconds
198 since the Epoch", so we have to do a little dance to
199 distinguish that from a genuine error. */
200 errno = 0;
201 tt = time(NULL);
202 if (tt != (time_t)-1 || errno == 0)
203 tb = localtime (&tt);
204
205 if (tb)
206 {
207 pfile->date = _cpp_unaligned_alloc (pfile,
208 sizeof ("/"Oct 11 1347/""));
209 sprintf ((char *) pfile->date, "/"%s %2d %4d/"",
210 monthnames[tb->tm_mon], tb->tm_mday,
211 tb->tm_year + 1900);
212
213 pfile->time = _cpp_unaligned_alloc (pfile,
214 sizeof ("/"12:34:56/""));
215 sprintf ((char *) pfile->time, "/"%02d:%02d:%02d/"",
216 tb->tm_hour, tb->tm_min, tb->tm_sec);
217 }
218 else
219 {
220 cpp_errno (pfile, CPP_DL_WARNING,
221 "could not determine date and time");
222
223 pfile->date = U"/"??? ?? ????/"";
224 pfile->time = U"/"??:??:??/"";
225 }
226 }
227
228 if (node->value.builtin == BT_DATE)
229 result = pfile->date;
230 else
231 result = pfile->time;
232 break;
233 }
234
235 if (result == NULL)
236 {
237 /* 21 bytes holds all NUL-terminated unsigned 64-bit numbers. */
238 result = _cpp_unaligned_alloc (pfile, 21);
239 sprintf ((char *) result, "%u", number);
240 }
241
242 return result;
243 }
2636
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
