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

来源：互联网发布：spss数据分析方法编辑：程序博客网时间：2024/05/18 02:35

5.9.3. 错误恢复

错误恢复是一个重要而又相当困难的议题。当遇到错误时，如何使解析器可以在错误点后的有效符号处重新解析，从来都不是一个简单的事。在C++的前端中，尝试性解析器提供了一个优雅的方法，当我们在尝试中发现了错误，则回滚进行下一个尝试。但是当所有的可能都尝试过而不能成功，我们不得不丢弃符号直到解析器可以重新开始。在C++的前端中，有几个函数用于此目的。第一个函数cp_parser_skip_to_closing_parenthesis将跳过符号直到找到非嵌套的右括号（“)”），或非嵌套的逗号（如果or_comma是true），或者分号，或者到文件末尾。

2024 static int

2025 cp_parser_skip_to_closing_parenthesis (cp_parser *parser, in parser.c

2026 bool recovering,

2027 bool or_comma,

2028 bool consume_paren)

2029 {

2030 unsigned paren_depth = 0;

2031 unsigned brace_depth = 0;

2032

2033 if (recovering && !or_comma && cp_parser_parsing_tentatively (parser)

2034 && !cp_parser_committed_to_tentative_parse (parser))

2035 return 0;

2036

2037 while (true)

2038 {

2039 cp_token *token;

2040

2041 /* If we've run out of tokens, then there is no closing `)'. */

2042 if (cp_lexer_next_token_is (parser->lexer, CPP_EOF))

2043 return 0;

2044

2045 token = cp_lexer_peek_token (parser->lexer);

2046

2047 /* This matches the processing in skip_to_end_of_statement. */

2048 if (token->type == CPP_SEMICOLON && !brace_depth)

2049 return 0;

2050 if (token->type == CPP_OPEN_BRACE)

2051 ++brace_depth;

2052 if (token->type == CPP_CLOSE_BRACE)

2053 {

2054 if (!brace_depth--)

2055 return 0;

2056 }

2057 if (recovering && or_comma && token->type == CPP_COMMA

2058 && !brace_depth && !paren_depth)

2059 return -1;

2060

2061 if (!brace_depth)

2062 {

2063 /* If it is an `(', we have entered another level of nesting. */

2064 if (token->type == CPP_OPEN_PAREN)

2065 ++paren_depth;

2066 /* If it is a `)', then we might be done. */

2067 else if (token->type == CPP_CLOSE_PAREN && !paren_depth--)

2068 {

2069 if (consume_paren)

2070 cp_lexer_consume_token (parser->lexer);

2071 return 1;

2072 }

2073 }

2074

2075 /* Consume the token. */

2076 cp_lexer_consume_token (parser->lexer);

2077 }

2078 }

从上面的代码中看到，所谓非嵌套，举例言之，例如{ .. ( .. ( .., ); .. ), ( ..;);}之中黑体且有下划线的符号即是非嵌套者。参数recovering如果是true，表示我们正在进行错误恢复；如果or_comma是false，表示我们不考虑非嵌套逗号，也即我们要跑到非嵌套的分号，右括号，或右大括号处，其中分号及右大括号都意味着语句的结束。这样，如果我们之前在尝试性解析之中，在开始解析前，前端会向延迟访问检查栈压入保存该次解析中可能出现的延迟访问检查的节点，在错误恢复之前（不考虑非嵌套逗号），必须确保尝试性解析已经安全停止（调用cp_parser_parse_definitely，但它只会移除当前解析的上下文，不确保清空上下文列表），否则我们没有机会恢复延迟访问检查栈。条件cp_parser_parsing_tentatively (parser) && cp_parser_committed_to_tentative_parse (parser)对于已停止的尝试性解析或非尝试性解析成立。对于2033行条件不能成立的情况，我们宁愿不处理，把它留给前端。

可以想见cp_parser_skip_to_closing_parenthesis更多时候是跑到右括号处。为了确保跳过一个语句，可以使用cp_parser_skip_to_end_of_statement。这里不考虑尝试性解析是否已经停止。这是因为，调用这个函数时，解析器已经没有办法再继续解析当前的语句，必须无条件执行，而且通常这时前端已经停止了尝试性解析。

2084 static void

2085 cp_parser_skip_to_end_of_statement (cp_parser* parser) in parser.c

2086 {

2087 unsigned nesting_depth = 0;

2088

2089 while (true)

2090 {

2091 cp_token *token;

2092

2093 /* Peek at the next token. */

2094 token = cp_lexer_peek_token (parser->lexer);

2095 /* If we've run out of tokens, stop. */

2096 if (token->type == CPP_EOF)

2097 break;

2098 /* If the next token is a `;', we have reached the end of the

2099 statement. */

2100 if (token->type == CPP_SEMICOLON && !nesting_depth)

2101 break;

2102 /* If the next token is a non-nested `}', then we have reached

2103 the end of the current block. */

2104 if (token->type == CPP_CLOSE_BRACE)

2105 {

2106 /* If this is a non-nested `}', stop before consuming it.

2107 That way, when confronted with something like:

2108

2109 { 3 + }

2110

2111 we stop before consuming the closing `}', even though we

2112 have not yet reached a `;'. */

2113 if (nesting_depth == 0)

2114 break;

2115 /* If it is the closing `}' for a block that we have

2116 scanned, stop -- but only after consuming the token.

2117 That way given:

2118

2119 void f g () { ... }

2120 typedef int I;

2121

2122 we will stop after the body of the erroneously declared

2123 function, but before consuming the following `typedef'

2124 declaration. */

2125 if (--nesting_depth == 0)

2126 {

2127 cp_lexer_consume_token (parser->lexer);

2128 break;

2129 }

2130 }

2131 /* If it the next token is a `{', then we are entering a new

2132 block. Consume the entire block. */

2133 else if (token->type == CPP_OPEN_BRACE)

2134 ++nesting_depth;

2135 /* Consume the token. */

2136 cp_lexer_consume_token (parser->lexer);

2137 }

2138 }

接下来，cp_parser_skip_to_end_of_block_or_statement也是类似的，不过它瞄准以分号结尾的语句块，如DO..WHILE循环。因此它仅考虑非嵌套分号，以及非嵌套的右大括号。

2162 static void

2163 cp_parser_skip_to_end_of_block_or_statement (cp_parser* parser) in parser.c

2164 {

2165 unsigned nesting_depth = 0;

2166

2167 while (true)

2168 {

2169 cp_token *token;

2170

2171 /* Peek at the next token. */

2172 token = cp_lexer_peek_token (parser->lexer);

2173 /* If we've run out of tokens, stop. */

2174 if (token->type == CPP_EOF)

2175 break;

2176 /* If the next token is a `;', we have reached the end of the

2177 statement. */

2178 if (token->type == CPP_SEMICOLON && !nesting_depth)

2179 {

2180 /* Consume the `;'. */

2181 cp_lexer_consume_token (parser->lexer);

2182 break;

2183 }

2184 /* Consume the token. */

2185 token = cp_lexer_consume_token (parser->lexer);

2186 /* If the next token is a non-nested `}', then we have reached

2187 the end of the current block. */

2188 if (token->type == CPP_CLOSE_BRACE

2189 && (nesting_depth == 0 || --nesting_depth == 0))

2190 break;

2191 /* If it the next token is a `{', then we are entering a new

2192 block. Consume the entire block. */

2193 if (token->type == CPP_OPEN_BRACE)

2194 ++nesting_depth;

2195 }

2196 }

毫不奇怪，还有一个函数专用于像FOR循环这样的不以分号结尾的语句块。

2201 static void

2202 cp_parser_skip_to_closing_brace (cp_parser *parser) in parser.c

2203 {

2204 unsigned nesting_depth = 0;

2205

2206 while (true)

2207 {

2208 cp_token *token;

2209

2210 /* Peek at the next token. */

2211 token = cp_lexer_peek_token (parser->lexer);

2212 /* If we've run out of tokens, stop. */

2213 if (token->type == CPP_EOF)

2214 break;

2215 /* If the next token is a non-nested `}', then we have reached

2216 the end of the current block. */

2217 if (token->type == CPP_CLOSE_BRACE && nesting_depth-- == 0)

2218 break;

2219 /* If it the next token is a `{', then we are entering a new

2220 block. Consume the entire block. */

2221 else if (token->type == CPP_OPEN_BRACE)

2222 ++nesting_depth;

2223 /* Consume the token. */

2224 cp_lexer_consume_token (parser->lexer);

2225 }

2226 }

有些时候，这些方法丢弃了太多的符号，更有甚者，它们可能是不合适的。比如在处理模板声明时，在其尖括号对（< >）中发生了错误，前进到右括号是不正确的，但前进至语句结尾则丢掉了太多的符号。最好是只丢掉直到“>”之前的符号。为了顾及这些情况， cp_parser_skip_until_found 将在指定符号处停住。

15109 static void

15110 cp_parser_skip_until_found (cp_parser* parser, in parser.c

15111 enum cpp_ttype type,

15112 const char* token_desc)

15113 {

15114 cp_token *token;

15115 unsigned nesting_depth = 0;

15116

15117 if (cp_parser_require (parser, type, token_desc))

15118 return;

15119

15120 /* Skip tokens until the desired token is found. */

15121 while (true)

15122 {

15123 /* Peek at the next token. */

15124 token = cp_lexer_peek_token (parser->lexer);

15125 /* If we've reached the token we want, consume it and

15126 stop. */

15127 if (token->type == type && !nesting_depth)

15128 {

15129 cp_lexer_consume_token (parser->lexer);

15130 return;

15131 }

15132 /* If we've run out of tokens, stop. */

15133 if (token->type == CPP_EOF)

15134 return;

15135 if (token->type == CPP_OPEN_BRACE

15136 || token->type == CPP_OPEN_PAREN

15137 || token->type == CPP_OPEN_SQUARE)

15138 ++nesting_depth;

15139 else if (token->type == CPP_CLOSE_BRACE

15140 || token->type == CPP_CLOSE_PAREN

15141 || token->type == CPP_CLOSE_SQUARE)

15142 {

15143 if (nesting_depth-- == 0)

15144 return;

15145 }

15146 /* Consume this token. */

15147 cp_lexer_consume_token (parser->lexer);

15148 }

15149 }

而且，当遇到可能标记着语句结尾的符号，保险起见，该函数也会退出。

5.10. 解析器用到的辅助函数

解析器有数以十计的辅助函数，它们帮助解析器提取及验证符号。例程cp_lexer_next_token_is可以告知符号是否为期望的类型。

667 static bool

668 cp_lexer_next_token_is (cp_lexer* lexer, enum cpp_ttype type) in parser.c

669 {

670 cp_token *token;

671

672 /* Peek at the next token. */

673 token = cp_lexer_peek_token (lexer);

674 /* Check to see if it has the indicated TYPE. */

675 return token->type == type;

676 }

例程cp_parser_require如果发现符号是期望的类型，就“消化”它；否则发出错误消息。

15085 static cp_token *

15086 cp_parser_require (cp_parser* parser, in parser.c

15087 enum cpp_ttype type,

15088 const char* token_desc)

15089 {

15090 if (cp_lexer_next_token_is (parser->lexer, type))

15091 return cp_lexer_consume_token (parser->lexer);

15092 else

15093 {

15094 /* Output the MESSAGE -- unless we're parsing tentatively. */

15095 if (!cp_parser_simulate_error (parser))

15096 {

15097 char *message = concat ("expected ", token_desc, NULL);

15098 cp_parser_error (parser, message);

15099 free (message);

15100 }

15101 return NULL;

15102 }

15103 }

例程cp_parser_require_keyword类似于cp_parser_require，不过，期望的符号是语言的关键字。

15157 static cp_token *

15158 cp_parser_require_keyword (cp_parser* parser, in parser.c

15159 enum rid keyword,

15160 const char* token_desc)

15161 {

15162 cp_token *token = cp_parser_require (parser, CPP_KEYWORD, token_desc);

15163

15164 if (token && token->keyword != keyword)

15165 {

15166 dyn_string_t error_msg;

15167

15168 /* Format the error message. */

15169 error_msg = dyn_string_new (0);

15170 dyn_string_append_cstr (error_msg, "expected ");

15171 dyn_string_append_cstr (error_msg, token_desc);

15172 cp_parser_error (parser, error_msg->s);

15173 dyn_string_delete (error_msg);

15174 return NULL;

15175 }

15176

15177 return token;

15178 }

另一个类似的函数是cp_lexer_next_token_is_keyword。

688 static bool

689 cp_lexer_next_token_is_keyword (cp_lexer* lexer, enum rid keyword) in parser.c

690 {

691 cp_token *token;

692

693 /* Peek at the next token. */

694 token = cp_lexer_peek_token (lexer);

695 /* Check to see if it is the indicated keyword. */

696 return token->keyword == keyword;

697 }

例程cp_parser_identifier则期望标识符（identifier）。

2299 static tree

2300 cp_parser_identifier (cp_parser* parser) in parser.c

2301 {

2302 cp_token *token;

2303

2304 /* Look for the identifier. */

2305 token = cp_parser_require (parser, CPP_NAME, "identifier");

2306 /* Return the value. */

2307 return token ? token->value : error_mark_node;

2308 }