GCC-3.4.6源代码学习笔记（82）

5.9. 试探性的解析器

5.9.1. 概观

当前GCC实现的是一个试探性的C++解析器，由于C++并不是严格的上下文无关文法，解析器可能需要多次尝试才能成功解析。因此解析器需要的是窥视功能——看看自己的理解对不对，不对从头重新解读。这个窥视功能可由cp_lexer_peek_token提供。

643 static cp_token *
644 cp_lexer_peek_token (cp_lexer * lexer) in parser.c
645 {
646 cp_token *token;
647
648 /* If there are no tokens, read one now. */
649 if (!lexer->next_token)
650 cp_lexer_read_token (lexer);
651
652 /* Provide debugging output. */
653 if (cp_lexer_debugging_p (lexer))
654 {
655 fprintf (cp_lexer_debug_stream, "cp_lexer: peeking at token: ");
656 cp_lexer_print_token (cp_lexer_debug_stream, lexer->next_token);
657 fprintf (cp_lexer_debug_stream, "/n");
658 }
659
660 token = lexer->next_token;
661 cp_lexer_set_source_position_from_token (lexer, token);
662 return token;
663 }

这里的C++解析器是LL（n）形式的，而不是传统的LL（1）形式。向前窥视第n个符号的功能由更为强大的函数cp_lexer_peek_nth_token提供。

702 static cp_token *
703 cp_lexer_peek_nth_token (cp_lexer* lexer, size_t n) in parser.c
704 {
705 cp_token *token;
706
707 /* N is 1-based, not zero-based. */
708 my_friendly_assert (n > 0, 20000224);
709
710 /* Skip ahead from NEXT_TOKEN, reading more tokens as necessary. */
711 token = lexer->next_token;
712 /* If there are no tokens in the buffer, get one now. */
713 if (!token)
714 {
715 cp_lexer_read_token (lexer);
716 token = lexer->next_token;
717 }
718
719 /* Now, read tokens until we have enough. */
720 while (--n > 0)
721 {
722 /* Advance to the next token. */
723 token = cp_lexer_next_token (lexer, token);
724 /* If that's all the tokens we have, read a new one. */
725 if (token == lexer->last_token)
726 token = cp_lexer_read_token (lexer);
727 }
728
729 return token;
730 }

函数cp_lexer_peek_token，cp_lexer_peek_nth_token及cp_lexer_read_token都不移动first_token。当我们确认无疑地知道某个符号的含义时（比如，关键字），这个符号就不应该再出现在下一次的尝试中。这意味着该符号已经被“消化了”，“消化”符号的函数就是cp_lexer_consume_token。

737 static cp_token *
738 cp_lexer_consume_token (cp_lexer* lexer) n parser.c
739 {
740 cp_token *token;
741
742 /* If there are no tokens, read one now. */
743 if (!lexer->next_token)
744 cp_lexer_read_token (lexer);
745
746 /* Remember the token we'll be returning. */
747 token = lexer->next_token;
748
749 /* Increment NEXT_TOKEN. */
750 lexer->next_token = cp_lexer_next_token (lexer,
751 lexer->next_token);
752 /* Check to see if we're all out of tokens. */
753 if (lexer->next_token == lexer->last_token)
754 lexer->next_token = NULL;
755
756 /* If we're not saving tokens, then move FIRST_TOKEN too. */
757 if (!cp_lexer_saving_tokens (lexer))
758 {
759 /* If there are no tokens available, set FIRST_TOKEN to NULL. */
760 if (!lexer->next_token)
761 lexer->first_token = NULL;
762 else
763 lexer->first_token = lexer->next_token;
764 }
765
766 /* Provide debugging output. */
767 if (cp_lexer_debugging_p (lexer))
768 {
769 fprintf (cp_lexer_debug_stream, "cp_lexer: consuming token: ");
770 cp_lexer_print_token (cp_lexer_debug_stream, token);
771 fprintf (cp_lexer_debug_stream, "/n");
772 }
773
774 return token;
775 }

cp_lexer 中的域next_token总是指向下一个被“消化”的符号，因此在750行，把该域指向的符号向前推进一个。而域last_token是所缓存符号的结尾标记，当next_token推进到这个位置时，next_token被设为NULL以表示没有符号剩下了。
而在757行，cp_lexer_saving_tokens检查cp_lexer中的可变长数组saved_tokens是否不为空。如果不空，表示符号按照解析器的要求要被保留（由cp_lexer_save_tokens触发），否则，推进域first_token来释放符号所占用的空间。
尝试性的解析由函数cp_parser_parse_tentatively拉开序幕。首先是为这次的尝试准备一个解析器上下文。在后面的操作中，编译器看到这个上下文，就知道正在进行尝试性解析。通过这样的上下文栈，尝试性解析可以多层嵌套。

15388 static void
15389 cp_parser_parse_tentatively (cp_parser* parser) in parser.c
15390 {
15391 /* Enter a new parsing context. */
15392 parser->context = cp_parser_context_new (parser->context);
15393 /* Begin saving tokens. */
15394 cp_lexer_save_tokens (parser->lexer);
15395 /* In order to avoid repetitive access control error messages,
15396 access checks are queued up until we are no longer parsing
15397 tentatively. */
15398 push_deferring_access_checks (dk_deferred);
15399 }

接下来在15398行，一个新的访问控制项被加入deferred_access_stack。这个一个延迟检查项，因为解析器将要到来的符号代表什么，只能尽各种可能来识别它们。其间可能会有多次尝试，在尝试期间不需要进行访问检查。访问检查将在完成尝试性解析时执行，在那个时候，解析器应该已经知道这些符号代表什么。
我们已经看到，在cp_lexer中，域first_token指向第一个被窥视的符号，而last_token指向最后一个缓存符号的位置，next_token则指向下一个将被窥视的符号。因此，在 first_token和next_token之间的符号是已经被窥视的，而在next_token和last_token之间的，是将要窥视的符号（如果first_token不等于next_token，这意味着我们在一个嵌套的尝试性解析中）。注意到在这次解析的过程中，first_token也不会被改变，因而如果我们需要重新解析，只要恢复next_token就足够了。这就是为什么cp_lexer_save_tokens只记录first_token到 next_token的距离（由函数cp_lexer_token_difference获得）。

844 static void
845 cp_lexer_save_tokens (cp_lexer* lexer) in parser.c
846 {
847 /* Provide debugging output. */
848 if (cp_lexer_debugging_p (lexer))
849 fprintf (cp_lexer_debug_stream, "cp_lexer: saving tokens/n");
850
851 /* Make sure that LEXER->NEXT_TOKEN is non-NULL so that we can
852 restore the tokens if required. */
853 if (!lexer->next_token)
854 cp_lexer_read_token (lexer);
855
856 VARRAY_PUSH_INT (lexer->saved_tokens,
857 cp_lexer_token_difference (lexer,
858 lexer->first_token,
859 lexer->next_token));
860 }

在调用了cp_lexer_save_tokens后，域saved_tokens不再是空的。回过去看函数cp_lexer_consume_token，save_tokens域不空，将使得没有符号被“消化”（first_token不像通常那样被推进）。
通过串接尝试性解析，我们可以把一个大的尝试性解析分成多个小的尝试性解析。例如，我们要解析一个由3个语法成分组成的语句，假定这3部分可能的组合如下图。



那么我们就可以把这个大的尝试分解为3个小的独立的尝试A，B和C。假如，现在输入的语句是a1b1c2，尝试A首先成功，接下来尝试B、C也成功，那么A，B，C构成的大尝试也就成功了。这时，通过cp_parser_commit_to_tentative_parse来提交这些尝试。假如输入的是a1b1c3，那么尝试C返回与a1b1不相容的c3，解析则失败。尝试C的上下文将被标记为CP_PARSER_STATUS_KIND_ERROR。

15403 static void
15404 cp_parser_commit_to_tentative_parse (cp_parser* parser) in parser.c
15405 {
15406 cp_parser_context *context;
15407 cp_lexer *lexer;
15408
15409 /* Mark all of the levels as committed. */
15410 lexer = parser->lexer;
15411 for (context = parser->context; context->next; context = context->next)
15412 {
15413 if (context->status == CP_PARSER_STATUS_KIND_COMMITTED)
15414 break;
15415 context->status = CP_PARSER_STATUS_KIND_COMMITTED;
15416 while (!cp_lexer_saving_tokens (lexer))
15417 lexer = lexer->next;
15418 cp_lexer_commit_tokens (lexer);
15419 }
15420 }

看到cp_lexer_commit_tokens将从save_tokens弹出一个对象，而15411行的FOR循环将横扫所有未提交的上下文，因此在cp_lexer_consume_token的下一次调用中，将把first_token更新为next_token。如果尝试性解析没有开始过，该FOR循环将不执行就退出，因为主上下文的next域总是为null。

864 static void
865 cp_lexer_commit_tokens (cp_lexer* lexer) in parser.c
866 {
867 /* Provide debugging output. */
868 if (cp_lexer_debugging_p (lexer))
869 fprintf (cp_lexer_debug_stream, "cp_lexer: committing tokens/n");
870
871 VARRAY_POP (lexer->saved_tokens);
872 }

注意到虽然提交了尝试性解析，但它们的上下文并没有释放。只有退出了它们的上下文，解析才被认为完成。另外，如果在解析过程中发生错误，我们需要停止解析，并回滚到解析开始的地方，准备下一次的尝试。要停止解析并从其上下文退出，我们需要调用函数cp_parser_parse_definitely。同样看到如果解析已经被提交，它几乎就是不活动的。

15438 static bool
15439 cp_parser_parse_definitely (cp_parser* parser) in parser.c
15440 {
15441 bool error_occurred;
15442 cp_parser_context *context;
15443
15444 /* Remember whether or not an error occurred, since we are about to
15445 destroy that information. */
15446 error_occurred = cp_parser_error_occurred (parser);
15447 /* Remove the topmost context from the stack. */
15448 context = parser->context;
15449 parser->context = context->next;
15450 /* If no parse errors occurred, commit to the tentative parse. */
15451 if (!error_occurred)
15452 {
15453 /* Commit to the tokens read tentatively, unless that was
15454 already done. */
15455 if (context->status != CP_PARSER_STATUS_KIND_COMMITTED)
15456 cp_lexer_commit_tokens (parser->lexer);
15457
15458 pop_to_parent_deferring_access_checks ();
15459 }
15460 /* Otherwise, if errors occurred, roll back our state so that things
15461 are just as they were before we began the tentative parse. */
15462 else
15463 {
15464 cp_lexer_rollback_tokens (parser->lexer);
15465 pop_deferring_access_checks ();
15466 }
15467 /* Add the context to the front of the free list. */
15468 context->next = cp_parser_context_free_list;
15469 cp_parser_context_free_list = context;
15470
15471 return !error_occurred;
15472 }

在cp_parser_parse_tentatively中，在开始尝试性解析时，我们推迟了访问控制检查。现在在停止该解析时，如果解析成功，那么是时候执行这个延迟的检查；如果解析失败，仍然需要移除这个延迟检查，让下一次尝试自己来处理访问控制。

216 void
217 pop_to_parent_deferring_access_checks (void) in semantics.c
218 {
219 tree deferred_check = get_deferred_access_checks ();
220 deferred_access *d1 = deferred_access_stack;
221 deferred_access *d2 = deferred_access_stack->next;
222 deferred_access *d3 = deferred_access_stack->next->next;
223
224 /* Temporary swap the order of the top two states, just to make
225 sure the garbage collector will not reclaim the memory during
226 processing below. */
227 deferred_access_stack = d2;
228 d2->next = d1;
229 d1->next = d3;
230
231 for ( ; deferred_check; deferred_check = TREE_CHAIN (deferred_check))
232 /* Perform deferred check if required. */
233 perform_or_defer_access_check (TREE_PURPOSE (deferred_check),
234 TREE_VALUE (deferred_check));
235
236 deferred_access_stack = d1;
237 d1->next = d2;
238 d2->next = d3;
239 pop_deferring_access_checks ();
240 }

我们已经看到deferred_access_stack是类型为deferred_access的栈。栈中的每个节点分别代表应用了延迟访问检查的作用域，而节点中的域deferred_access_checks记录了该作用域中所请求的延迟检查。函数get_deferred_access_checks返回当前作用域的延迟检查。

206 tree
207 get_deferred_access_checks (void) in semantics.c
208 {
209 return deferred_access_stack->deferred_access_checks;
210 }

在下一节我们再来看函数perform_or_defer_access_check。在执行完这些延迟检查后，从该栈中弹出这些检查。

187 void
188 pop_deferring_access_checks (void) in semantics.c
189 {
190 deferred_access *d = deferred_access_stack;
191 deferred_access_stack = d->next;
192
193 /* Remove references to access checks TREE_LIST. */
194 d->deferred_access_checks = NULL_TREE;
195
196 /* Store in free list for later use. */
197 d->next = deferred_access_free_list;
198 deferred_access_free_list = d;
199 }

在出错时回滚到起点由cp_lexer_rollback_tokens完成。

877 static void
878 cp_lexer_rollback_tokens (cp_lexer* lexer) in parser.c
879 {
880 size_t delta;
881
882 /* Provide debugging output. */
883 if (cp_lexer_debugging_p (lexer))
884 fprintf (cp_lexer_debug_stream, "cp_lexer: restoring tokens/n");
885
886 /* Find the token that was the NEXT_TOKEN when we started saving
887 tokens. */
888 delta = VARRAY_TOP_INT(lexer->saved_tokens);
889 /* Make it the next token again now. */
890 lexer->next_token = cp_lexer_advance_token (lexer,
891 lexer->first_token,
892 delta);
893 /* It might be the case that there were no tokens when we started
894 saving tokens, but that there are some tokens now. */
895 if (!lexer->next_token && lexer->first_token)
896 lexer->next_token = lexer->first_token;
897
898 /* Stop saving tokens. */
899 VARRAY_POP (lexer->saved_tokens);
900 }

因为在尝试性解析的过程中没有符号被真正“消化”，first_token总是不变的，获取起点时的next_token可谓直截了当。

449 static cp_token *
450 cp_lexer_advance_token (cp_lexer *lexer, cp_token *token, ptrdiff_t n) in parser.c
451 {
452 token += n;
453 if (token >= lexer->buffer_end)
454 token = lexer->buffer + (token - lexer->buffer_end);
455 return token;
456 }

在这里，可以很清楚地看到，cp_parser_parse_tentatively及cp_parser_parse_definitely的调用必需一一对应，以维护延迟检查栈的良好状态。