Mercurial > hg > octave-nkf

comparison libinterp/parse-tree/lex.ll @ 16126:5c885c13bfa3

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
localize use of yylval.tok_val in lexical_feedback member functions * lex.h, lex.ll (lexical_feedback::push_token): New function. (lexical_feedback::current_token): New function. (lexical_feedback::token_stack): Now private. * lex.ll (TOK_PUSH_AND_RETURN, BIN_OP_RETURN_INTERNAL, lexical_feedback::is_keyword_token, lexical_feedback::handle_number, lexical_feedback::handle_string, lexical_feedback::handle_superclass_identifier, lexical_feedback::handle_meta_identifier, lexical_feedback::handle_identifier, lexical_feedback::display_token): Use push_token and current_token instead of accessing yylval.tok_val directly.
author John W. Eaton <jwe@octave.org>
date Tue, 26 Feb 2013 15:13:43 -0500
parents 96a58f197f93
children 210039e91ad6
comparison
equal deleted inserted replaced
16125:96a58f197f93 16126:5c885c13bfa3
156 while (0) 156 while (0)
157 157
158 #define TOK_PUSH_AND_RETURN(name, tok) \ 158 #define TOK_PUSH_AND_RETURN(name, tok) \
159 do \ 159 do \
160 { \ 160 { \
161 yylval.tok_val = new token (name, curr_lexer->input_line_number, \ 161 curr_lexer->push_token \
162 curr_lexer->current_input_column); \ 162 (new token (name, curr_lexer->input_line_number, \
163 curr_lexer->token_stack.push (yylval.tok_val); \ 163 curr_lexer->current_input_column)); \
164 TOK_RETURN (tok); \ 164 TOK_RETURN (tok); \
165 } \ 165 } \
166 while (0) 166 while (0)
167 167
168 #define BIN_OP_RETURN_INTERNAL(tok, convert, bos, qit) \ 168 #define BIN_OP_RETURN_INTERNAL(tok, convert, bos, qit) \
169 do \ 169 do \
170 { \ 170 { \
171 yylval.tok_val = new token (curr_lexer->input_line_number, \ 171 curr_lexer->push_token \
172 curr_lexer->current_input_column); \ 172 (new token (curr_lexer->input_line_number, \
173 curr_lexer->token_stack.push (yylval.tok_val); \ 173 curr_lexer->current_input_column)); \
174 curr_lexer->current_input_column += yyleng; \ 174 curr_lexer->current_input_column += yyleng; \
175 curr_lexer->quote_is_transpose = qit; \ 175 curr_lexer->quote_is_transpose = qit; \
176 curr_lexer->convert_spaces_to_comma = convert; \ 176 curr_lexer->convert_spaces_to_comma = convert; \
177 curr_lexer->looking_for_object_index = false; \ 177 curr_lexer->looking_for_object_index = false; \
178 curr_lexer->at_beginning_of_statement = bos; \ 178 curr_lexer->at_beginning_of_statement = bos; \
1615 1615
1616 const octave_kw *kw = octave_kw_hash::in_word_set (s.c_str (), len); 1616 const octave_kw *kw = octave_kw_hash::in_word_set (s.c_str (), len);
1617 1617
1618 if (kw) 1618 if (kw)
1619 { 1619 {
1620 yylval.tok_val = 0; 1620 token *tok_val = 0;
1621 1621
1622 switch (kw->kw_id) 1622 switch (kw->kw_id)
1623 { 1623 {
1624 case break_kw: 1624 case break_kw:
1625 case catch_kw: 1625 case catch_kw:
1660 && (defining_func 1660 && (defining_func
1661 && ! (looking_at_return_list 1661 && ! (looking_at_return_list
1662 || parsed_function_name.top ())))) 1662 || parsed_function_name.top ()))))
1663 return 0; 1663 return 0;
1664 1664
1665 yylval.tok_val = new token (token::simple_end, l, c); 1665 tok_val = new token (token::simple_end, l, c);
1666 at_beginning_of_statement = true; 1666 at_beginning_of_statement = true;
1667 break; 1667 break;
1668 1668
1669 case end_try_catch_kw: 1669 case end_try_catch_kw:
1670 yylval.tok_val = new token (token::try_catch_end, l, c); 1670 tok_val = new token (token::try_catch_end, l, c);
1671 at_beginning_of_statement = true; 1671 at_beginning_of_statement = true;
1672 break; 1672 break;
1673 1673
1674 case end_unwind_protect_kw: 1674 case end_unwind_protect_kw:
1675 yylval.tok_val = new token (token::unwind_protect_end, l, c); 1675 tok_val = new token (token::unwind_protect_end, l, c);
1676 at_beginning_of_statement = true; 1676 at_beginning_of_statement = true;
1677 break; 1677 break;
1678 1678
1679 case endfor_kw: 1679 case endfor_kw:
1680 yylval.tok_val = new token (token::for_end, l, c); 1680 tok_val = new token (token::for_end, l, c);
1681 at_beginning_of_statement = true; 1681 at_beginning_of_statement = true;
1682 break; 1682 break;
1683 1683
1684 case endfunction_kw: 1684 case endfunction_kw:
1685 yylval.tok_val = new token (token::function_end, l, c); 1685 tok_val = new token (token::function_end, l, c);
1686 at_beginning_of_statement = true; 1686 at_beginning_of_statement = true;
1687 break; 1687 break;
1688 1688
1689 case endif_kw: 1689 case endif_kw:
1690 yylval.tok_val = new token (token::if_end, l, c); 1690 tok_val = new token (token::if_end, l, c);
1691 at_beginning_of_statement = true; 1691 at_beginning_of_statement = true;
1692 break; 1692 break;
1693 1693
1694 case endparfor_kw: 1694 case endparfor_kw:
1695 yylval.tok_val = new token (token::parfor_end, l, c); 1695 tok_val = new token (token::parfor_end, l, c);
1696 at_beginning_of_statement = true; 1696 at_beginning_of_statement = true;
1697 break; 1697 break;
1698 1698
1699 case endswitch_kw: 1699 case endswitch_kw:
1700 yylval.tok_val = new token (token::switch_end, l, c); 1700 tok_val = new token (token::switch_end, l, c);
1701 at_beginning_of_statement = true; 1701 at_beginning_of_statement = true;
1702 break; 1702 break;
1703 1703
1704 case endwhile_kw: 1704 case endwhile_kw:
1705 yylval.tok_val = new token (token::while_end, l, c); 1705 tok_val = new token (token::while_end, l, c);
1706 at_beginning_of_statement = true; 1706 at_beginning_of_statement = true;
1707 break; 1707 break;
1708 1708
1709 case endclassdef_kw: 1709 case endclassdef_kw:
1710 yylval.tok_val = new token (token::classdef_end, l, c); 1710 tok_val = new token (token::classdef_end, l, c);
1711 at_beginning_of_statement = true; 1711 at_beginning_of_statement = true;
1712 break; 1712 break;
1713 1713
1714 case endenumeration_kw: 1714 case endenumeration_kw:
1715 yylval.tok_val = new token (token::enumeration_end, l, c); 1715 tok_val = new token (token::enumeration_end, l, c);
1716 at_beginning_of_statement = true; 1716 at_beginning_of_statement = true;
1717 break; 1717 break;
1718 1718
1719 case endevents_kw: 1719 case endevents_kw:
1720 yylval.tok_val = new token (token::events_end, l, c); 1720 tok_val = new token (token::events_end, l, c);
1721 at_beginning_of_statement = true; 1721 at_beginning_of_statement = true;
1722 break; 1722 break;
1723 1723
1724 case endmethods_kw: 1724 case endmethods_kw:
1725 yylval.tok_val = new token (token::methods_end, l, c); 1725 tok_val = new token (token::methods_end, l, c);
1726 at_beginning_of_statement = true; 1726 at_beginning_of_statement = true;
1727 break; 1727 break;
1728 1728
1729 case endproperties_kw: 1729 case endproperties_kw:
1730 yylval.tok_val = new token (token::properties_end, l, c); 1730 tok_val = new token (token::properties_end, l, c);
1731 at_beginning_of_statement = true; 1731 at_beginning_of_statement = true;
1732 break; 1732 break;
1733 1733
1734 1734
1735 case for_kw: 1735 case for_kw:
1793 case magic_file_kw: 1793 case magic_file_kw:
1794 { 1794 {
1795 if ((reading_fcn_file || reading_script_file 1795 if ((reading_fcn_file || reading_script_file
1796 || reading_classdef_file) 1796 || reading_classdef_file)
1797 && ! curr_fcn_file_full_name.empty ()) 1797 && ! curr_fcn_file_full_name.empty ())
1798 yylval.tok_val = new token (curr_fcn_file_full_name, l, c); 1798 tok_val = new token (curr_fcn_file_full_name, l, c);
1799 else 1799 else
1800 yylval.tok_val = new token ("stdin", l, c); 1800 tok_val = new token ("stdin", l, c);
1801 } 1801 }
1802 break; 1802 break;
1803 1803
1804 case magic_line_kw: 1804 case magic_line_kw:
1805 yylval.tok_val = new token (static_cast<double> (l), "", l, c); 1805 tok_val = new token (static_cast<double> (l), "", l, c);
1806 break; 1806 break;
1807 1807
1808 default: 1808 default:
1809 panic_impossible (); 1809 panic_impossible ();
1810 } 1810 }
1811 1811
1812 if (! yylval.tok_val) 1812 if (! tok_val)
1813 yylval.tok_val = new token (l, c); 1813 tok_val = new token (l, c);
1814 1814
1815 token_stack.push (yylval.tok_val); 1815 curr_lexer->push_token (tok_val);
1816 1816
1817 return kw->tok; 1817 return kw->tok;
1818 } 1818 }
1819 1819
1820 return 0; 1820 return 0;
2499 quote_is_transpose = true; 2499 quote_is_transpose = true;
2500 convert_spaces_to_comma = true; 2500 convert_spaces_to_comma = true;
2501 looking_for_object_index = false; 2501 looking_for_object_index = false;
2502 at_beginning_of_statement = false; 2502 at_beginning_of_statement = false;
2503 2503
2504 yylval.tok_val = new token (value, yytext, input_line_number, 2504 curr_lexer->push_token (new token (value, yytext, input_line_number,
2505 current_input_column); 2505 current_input_column));
2506
2507 token_stack.push (yylval.tok_val);
2508 2506
2509 current_input_column += yyleng; 2507 current_input_column += yyleng;
2510 2508
2511 do_comma_insert_check (); 2509 do_comma_insert_check ();
2512 } 2510 }
2716 s = do_string_escapes (buf.str ()); 2714 s = do_string_escapes (buf.str ());
2717 2715
2718 quote_is_transpose = true; 2716 quote_is_transpose = true;
2719 convert_spaces_to_comma = true; 2717 convert_spaces_to_comma = true;
2720 2718
2721 yylval.tok_val = new token (s, bos_line, bos_col); 2719 curr_lexer->push_token (new token (s, bos_line, bos_col));
2722 token_stack.push (yylval.tok_val);
2723 2720
2724 if (delim == '"') 2721 if (delim == '"')
2725 gripe_matlab_incompatible ("\" used as string delimiter"); 2722 gripe_matlab_incompatible ("\" used as string delimiter");
2726 else if (delim == '\'') 2723 else if (delim == '\'')
2727 gripe_single_quote_string (); 2724 gripe_single_quote_string ();
3229 { 3226 {
3230 error ("method, class and package names may not be keywords"); 3227 error ("method, class and package names may not be keywords");
3231 return LEXICAL_ERROR; 3228 return LEXICAL_ERROR;
3232 } 3229 }
3233 3230
3234 yylval.tok_val 3231 curr_lexer->push_token
3235 = new token (meth.empty () ? 0 : &(symbol_table::insert (meth)), 3232 (new token (meth.empty () ? 0 : &(symbol_table::insert (meth)),
3236 cls.empty () ? 0 : &(symbol_table::insert (cls)), 3233 cls.empty () ? 0 : &(symbol_table::insert (cls)),
3237 pkg.empty () ? 0 : &(symbol_table::insert (pkg)), 3234 pkg.empty () ? 0 : &(symbol_table::insert (pkg)),
3238 input_line_number, 3235 input_line_number, current_input_column));
3239 current_input_column);
3240 token_stack.push (yylval.tok_val);
3241 3236
3242 convert_spaces_to_comma = true; 3237 convert_spaces_to_comma = true;
3243 current_input_column += yyleng; 3238 current_input_column += yyleng;
3244 3239
3245 return SUPERCLASSREF; 3240 return SUPERCLASSREF;
3265 { 3260 {
3266 error ("class and package names may not be keywords"); 3261 error ("class and package names may not be keywords");
3267 return LEXICAL_ERROR; 3262 return LEXICAL_ERROR;
3268 } 3263 }
3269 3264
3270 yylval.tok_val 3265 curr_lexer->push_token
3271 = new token (cls.empty () ? 0 : &(symbol_table::insert (cls)), 3266 (new token (cls.empty () ? 0 : &(symbol_table::insert (cls)),
3272 pkg.empty () ? 0 : &(symbol_table::insert (pkg)), 3267 pkg.empty () ? 0 : &(symbol_table::insert (pkg)),
3273 input_line_number, 3268 input_line_number, current_input_column));
3274 current_input_column);
3275
3276 token_stack.push (yylval.tok_val);
3277 3269
3278 convert_spaces_to_comma = true; 3270 convert_spaces_to_comma = true;
3279 current_input_column += yyleng; 3271 current_input_column += yyleng;
3280 3272
3281 return METAQUERY; 3273 return METAQUERY;
3307 { 3299 {
3308 do_comma_insert_check (); 3300 do_comma_insert_check ();
3309 3301
3310 maybe_unput_comma (spc_gobbled); 3302 maybe_unput_comma (spc_gobbled);
3311 3303
3312 yylval.tok_val = new token (tok, input_line_number, 3304 curr_lexer->push_token (new token (tok, input_line_number,
3313 current_input_column); 3305 current_input_column));
3314
3315 token_stack.push (yylval.tok_val);
3316 3306
3317 quote_is_transpose = true; 3307 quote_is_transpose = true;
3318 convert_spaces_to_comma = true; 3308 convert_spaces_to_comma = true;
3319 looking_for_object_index = true; 3309 looking_for_object_index = true;
3320 3310
3344 3334
3345 return LEXICAL_ERROR; 3335 return LEXICAL_ERROR;
3346 } 3336 }
3347 else 3337 else
3348 { 3338 {
3349 yylval.tok_val = new token (tok, input_line_number, 3339 curr_lexer->push_token (new token (tok, input_line_number,
3350 current_input_column); 3340 current_input_column));
3351
3352 token_stack.push (yylval.tok_val);
3353 3341
3354 current_input_column += yyleng; 3342 current_input_column += yyleng;
3355 quote_is_transpose = false; 3343 quote_is_transpose = false;
3356 convert_spaces_to_comma = true; 3344 convert_spaces_to_comma = true;
3357 looking_for_object_index = true; 3345 looking_for_object_index = true;
3427 // transformation of the end keyword... 3415 // transformation of the end keyword...
3428 3416
3429 if (tok == "end") 3417 if (tok == "end")
3430 tok = "__end__"; 3418 tok = "__end__";
3431 3419
3432 yylval.tok_val = new token (&(symbol_table::insert (tok)), 3420 curr_lexer->push_token (new token (&(symbol_table::insert (tok)),
3433 input_line_number, 3421 input_line_number, current_input_column));
3434 current_input_column);
3435
3436 token_stack.push (yylval.tok_val);
3437 3422
3438 // After seeing an identifer, it is ok to convert spaces to a comma 3423 // After seeing an identifer, it is ok to convert spaces to a comma
3439 // (if needed). 3424 // (if needed).
3440 3425
3441 convert_spaces_to_comma = true; 3426 convert_spaces_to_comma = true;
3521 std::string t = op; 3506 std::string t = op;
3522 int n = t.length (); 3507 int n = t.length ();
3523 if (t[n-1] == '\n') 3508 if (t[n-1] == '\n')
3524 t.resize (n-1); 3509 t.resize (n-1);
3525 gripe_matlab_incompatible (t + " used as operator"); 3510 gripe_matlab_incompatible (t + " used as operator");
3511 }
3512
3513 void
3514 lexical_feedback::push_token (token *tok)
3515 {
3516 yylval.tok_val = tok;
3517 token_stack.push (tok);
3518 }
3519
3520 token *
3521 lexical_feedback::current_token (void)
3522 {
3523 return yylval.tok_val;
3526 } 3524 }
3527 3525
3528 void 3526 void
3529 lexical_feedback::display_token (int tok) 3527 lexical_feedback::display_token (int tok)
3530 { 3528 {
3576 case POW: std::cerr << "POW\n"; break; 3574 case POW: std::cerr << "POW\n"; break;
3577 case EPOW: std::cerr << "EPOW\n"; break; 3575 case EPOW: std::cerr << "EPOW\n"; break;
3578 3576
3579 case NUM: 3577 case NUM:
3580 case IMAG_NUM: 3578 case IMAG_NUM:
3581 std::cerr << (tok == NUM ? "NUM" : "IMAG_NUM") 3579 {
3582 << " [" << yylval.tok_val->number () << "]\n"; 3580 token *tok_val = curr_lexer->current_token ();
3581 std::cerr << (tok == NUM ? "NUM" : "IMAG_NUM")
3582 << " [" << tok_val->number () << "]\n";
3583 }
3583 break; 3584 break;
3584 3585
3585 case STRUCT_ELT: 3586 case STRUCT_ELT:
3586 std::cerr << "STRUCT_ELT [" << yylval.tok_val->text () << "]\n"; break; 3587 {
3588 token *tok_val = curr_lexer->current_token ();
3589 std::cerr << "STRUCT_ELT [" << tok_val->text () << "]\n";
3590 }
3591 break;
3587 3592
3588 case NAME: 3593 case NAME:
3589 { 3594 {
3590 symbol_table::symbol_record *sr = yylval.tok_val->sym_rec (); 3595 token *tok_val = curr_lexer->current_token ();
3596 symbol_table::symbol_record *sr = tok_val->sym_rec ();
3591 std::cerr << "NAME"; 3597 std::cerr << "NAME";
3592 if (sr) 3598 if (sr)
3593 std::cerr << " [" << sr->name () << "]"; 3599 std::cerr << " [" << sr->name () << "]";
3594 std::cerr << "\n"; 3600 std::cerr << "\n";
3595 } 3601 }
3597 3603
3598 case END: std::cerr << "END\n"; break; 3604 case END: std::cerr << "END\n"; break;
3599 3605
3600 case DQ_STRING: 3606 case DQ_STRING:
3601 case SQ_STRING: 3607 case SQ_STRING:
3602 std::cerr << (tok == DQ_STRING ? "DQ_STRING" : "SQ_STRING") 3608 {
3603 << " [" << yylval.tok_val->text () << "]\n"; 3609 token *tok_val = curr_lexer->current_token ();
3610
3611 std::cerr << (tok == DQ_STRING ? "DQ_STRING" : "SQ_STRING")
3612 << " [" << tok_val->text () << "]\n";
3613 }
3604 break; 3614 break;
3605 3615
3606 case FOR: std::cerr << "FOR\n"; break; 3616 case FOR: std::cerr << "FOR\n"; break;
3607 case WHILE: std::cerr << "WHILE\n"; break; 3617 case WHILE: std::cerr << "WHILE\n"; break;
3608 case DO: std::cerr << "DO\n"; break; 3618 case DO: std::cerr << "DO\n"; break;