octave-lyh: libinterp/parse-tree/lex.ll comparison

comparison libinterp/parse-tree/lex.ll @ 16158:7eb614760ddb

rename lexical_feedback to octave_lexer * lex.h (octave_lexer): Rename from lexical_feedback. * lex.h, lex.ll, parse.h, oct-parse.yy: Change all uses.

author	John W. Eaton <jwe@octave.org>
date	Thu, 28 Feb 2013 11:24:38 -0500
parents	aa5e1e8dce66
children	c5bfdc4c0963

comparison

equal deleted inserted replaced

-:335041cc657a
+:7eb614760ddb
 && defined (YY_FLEX_MAJOR_VERSION) && YY_FLEX_MAJOR_VERSION >= 2 \
 && defined (YY_FLEX_MINOR_VERSION) && YY_FLEX_MINOR_VERSION >= 5)
 #error lex.l requires flex version 2.5.4 or later
 #endif
-#define YY_EXTRA_TYPE lexical_feedback *
+#define YY_EXTRA_TYPE octave_lexer *
 #define curr_lexer yyextra
 // Arrange to get input via readline.
 #ifdef YY_INPUT
 curr_lexer->looking_for_object_index = true;
 curr_lexer->at_beginning_of_statement = false;
 int c = yytext[yyleng-1];
-bool cont_is_spc = (curr_lexer->eat_continuation () != lexical_feedback::NO_WHITESPACE);
+bool cont_is_spc = (curr_lexer->eat_continuation () != octave_lexer::NO_WHITESPACE);
 bool spc_gobbled = (cont_is_spc || c == ' ' || c == '\t');
 int tok_to_return = curr_lexer->handle_close_bracket (spc_gobbled, ']');
 if (spc_gobbled)
 curr_lexer->xunput (' ');
 curr_lexer->looking_for_object_index = true;
 curr_lexer->at_beginning_of_statement = false;
 int c = yytext[yyleng-1];
-bool cont_is_spc = (curr_lexer->eat_continuation () != lexical_feedback::NO_WHITESPACE);
+bool cont_is_spc = (curr_lexer->eat_continuation () != octave_lexer::NO_WHITESPACE);
 bool spc_gobbled = (cont_is_spc || c == ' ' || c == '\t');
 int tok_to_return = curr_lexer->handle_close_bracket (spc_gobbled, '}');
 if (spc_gobbled)
 curr_lexer->xunput (' ');
 curr_lexer->looking_for_object_index = false;
 curr_lexer->at_beginning_of_statement = false;
 if (! curr_lexer->looking_at_object_index.front ())
 {
-if ((tmp & lexical_feedback::NEWLINE) == lexical_feedback::NEWLINE)
+if ((tmp & octave_lexer::NEWLINE) == octave_lexer::NEWLINE)
 {
 curr_lexer->maybe_warn_separator_insert (';');
 curr_lexer->xunput (';');
 }
 if (! (postfix_un_op || bin_op || sep_op)
 && curr_lexer->nesting_level.is_bracket_or_brace ()
 && curr_lexer->convert_spaces_to_comma)
 {
-if ((tmp & lexical_feedback::NEWLINE) == lexical_feedback::NEWLINE)
+if ((tmp & octave_lexer::NEWLINE) == octave_lexer::NEWLINE)
 {
 curr_lexer->maybe_warn_separator_insert (';');
 curr_lexer->xunput (';');
 }
 class
 flex_stream_reader : public stream_reader
 {
 public:
-flex_stream_reader (lexical_feedback *l, char *buf_arg)
+flex_stream_reader (octave_lexer *l, char *buf_arg)
 : stream_reader (), lexer (l), buf (buf_arg)
 { }
 int getc (void) { return lexer->text_yyinput (); }
 int ungetc (int c) { lexer->xunput (c, buf); return 0; }
 flex_stream_reader (const flex_stream_reader&);
 flex_stream_reader& operator = (const flex_stream_reader&);
-lexical_feedback *lexer;
+octave_lexer *lexer;
 char *buf;
 };
-lexical_feedback::~lexical_feedback (void)
+octave_lexer::~octave_lexer (void)
 {
 // Clear out the stack of token info used to track line and
 // column numbers.
 while (! token_stack.empty ())
 yylex_destroy (scanner);
 }
 void
-lexical_feedback::init (void)
+octave_lexer::init (void)
 {
 // The closest paren, brace, or bracket nesting is not an object
 // index.
 looking_at_object_index.push_front (false);
 yylex_init (&scanner);
-// Make lexical_feedback object available through yyextra in
+// Make octave_lexer object available through yyextra in
 // flex-generated lexer.
 yyset_extra (this, scanner);
 }
 // Inside Flex-generated functions, yyg is the scanner cast to its real
 // type.  The BEGIN macro uses yyg and we want to use that in
-// lexical_feedback member functions.  If we could set the start state
+// octave_lexer member functions.  If we could set the start state
 // by calling a function instead of using the BEGIN macro, we could
 // eliminate the OCTAVE_YYG macro.
 #define OCTAVE_YYG \
 struct yyguts_t *yyg = static_cast<struct yyguts_t*> (scanner)
 void
-lexical_feedback::reset (void)
+octave_lexer::reset (void)
 {
 OCTAVE_YYG;
 // Start off on the right foot.
 BEGIN (INITIAL);
 while (! help_buf.empty ())
 help_buf.pop ();
 }
 void
-lexical_feedback::prep_for_script_file (void)
+octave_lexer::prep_for_script_file (void)
 {
 OCTAVE_YYG;
 BEGIN (SCRIPT_FILE_BEGIN);
 }
 void
-lexical_feedback::prep_for_function_file (void)
+octave_lexer::prep_for_function_file (void)
 {
 OCTAVE_YYG;
 BEGIN (FUNCTION_FILE_BEGIN);
 }
 int
-lexical_feedback::octave_read (char *buf, unsigned max_size)
+octave_lexer::octave_read (char *buf, unsigned max_size)
 {
 static const char * const eol = "\n";
 static std::string input_buf;
 static const char *pos = 0;
 static size_t chars_left = 0;
 return status;
 }
 char *
-lexical_feedback::flex_yytext (void)
+octave_lexer::flex_yytext (void)
 {
 return yyget_text (scanner);
 }
 int
-lexical_feedback::flex_yyleng (void)
+octave_lexer::flex_yyleng (void)
 {
 return yyget_leng (scanner);
 }
 // GAG.
 //
 // If we're reading a matrix and the next character is '[', make sure
 // that we insert a comma ahead of it.
 void
-lexical_feedback::do_comma_insert_check (void)
+octave_lexer::do_comma_insert_check (void)
 {
-bool spc_gobbled = (eat_continuation () != lexical_feedback::NO_WHITESPACE);
+bool spc_gobbled = (eat_continuation () != octave_lexer::NO_WHITESPACE);
 int c = text_yyinput ();
 xunput (c);
 do_comma_insert = (! looking_at_object_index.front ()
 && bracketflag && c == '[');
 }
 int
-lexical_feedback::text_yyinput (void)
+octave_lexer::text_yyinput (void)
 {
 int c = yyinput (scanner);
 if (lexer_debug_flag)
 {
 return c;
 }
 void
-lexical_feedback::xunput (char c, char *buf)
+octave_lexer::xunput (char c, char *buf)
 {
 if (lexer_debug_flag)
 {
 std::cerr << "U: ";
 display_character (c);
 yyunput (c, buf, scanner);
 }
 void
-lexical_feedback::xunput (char c)
+octave_lexer::xunput (char c)
 {
 char *yytxt = flex_yytext ();
 xunput (c, yytxt);
 }
 // If we read some newlines, we need figure out what column we're
 // really looking at.
 void
-lexical_feedback::fixup_column_count (char *s)
+octave_lexer::fixup_column_count (char *s)
 {
 char c;
 while ((c = *s++) != '\0')
 {
 if (c == '\n')
 current_input_column++;
 }
 }
 bool
-lexical_feedback::inside_any_object_index (void)
+octave_lexer::inside_any_object_index (void)
 {
 bool retval = false;
 for (std::list<bool>::const_iterator i = looking_at_object_index.begin ();
 i != looking_at_object_index.end (); i++)
 }
 // Handle keywords.  Return -1 if the keyword should be ignored.
 int
-lexical_feedback::is_keyword_token (const std::string& s)
+octave_lexer::is_keyword_token (const std::string& s)
 {
 int l = input_line_number;
 int c = current_input_column;
 int len = s.length ();
 return 0;
 }
 bool
-lexical_feedback::is_variable (const std::string& name)
+octave_lexer::is_variable (const std::string& name)
 {
 return (symbol_table::is_variable (name)
 || (pending_local_variables.find (name)
 != pending_local_variables.end ()));
 }
 std::string
-lexical_feedback::grab_block_comment (stream_reader& reader, bool& eof)
+octave_lexer::grab_block_comment (stream_reader& reader, bool& eof)
 {
 std::string buf;
 bool at_bol = true;
 bool look_for_marker = false;
 return buf;
 }
 std::string
-lexical_feedback::grab_comment_block (stream_reader& reader, bool at_bol,
+octave_lexer::grab_comment_block (stream_reader& reader, bool at_bol,
 bool& eof)
 {
 std::string buf;
 // TRUE means we are at the beginning of a comment block.
 bool begin_comment = false;
 return buf;
 }
 int
-lexical_feedback::process_comment (bool start_in_block, bool& eof)
+octave_lexer::process_comment (bool start_in_block, bool& eof)
 {
 OCTAVE_YYG;
 eof = false;
 // Recognize separators.  If the separator is a CRLF pair, it is
 // replaced by a single LF.
 bool
-lexical_feedback::next_token_is_sep_op (void)
+octave_lexer::next_token_is_sep_op (void)
 {
 bool retval = false;
 int c = text_yyinput ();
 // Try to determine if the next token should be treated as a postfix
 // unary operator.  This is ugly, but it seems to do the right thing.
 bool
-lexical_feedback::next_token_is_postfix_unary_op (bool spc_prev)
+octave_lexer::next_token_is_postfix_unary_op (bool spc_prev)
 {
 bool un_op = false;
 int c0 = text_yyinput ();
 // Note that a line continuation directly following a + or - operator
 // (e.g., the characters '[' 'a' ' ' '+' '\' LFD 'b' ']') will be
 // parsed as a binary operator.
 bool
-lexical_feedback::next_token_is_bin_op (bool spc_prev)
+octave_lexer::next_token_is_bin_op (bool spc_prev)
 {
 bool bin_op = false;
 int c0 = text_yyinput ();
 }
 // FIXME -- we need to handle block comments here.
 void
-lexical_feedback::scan_for_comments (const char *text)
+octave_lexer::scan_for_comments (const char *text)
 {
 std::string comment_buf;
 bool in_comment = false;
 bool beginning_of_comment = false;
 // Discard whitespace, including comments and continuations.
 // FIXME -- we need to handle block comments here.
 int
-lexical_feedback::eat_whitespace (void)
+octave_lexer::eat_whitespace (void)
 {
-int retval = lexical_feedback::NO_WHITESPACE;
+int retval = octave_lexer::NO_WHITESPACE;
 std::string comment_buf;
 bool in_comment = false;
 bool beginning_of_comment = false;
 if (in_comment)
 {
 comment_buf += static_cast<char> (c);
 beginning_of_comment = false;
 }
-retval |= lexical_feedback::SPACE_OR_TAB;
+retval |= octave_lexer::SPACE_OR_TAB;
 break;
 case '\n':
-retval |= lexical_feedback::NEWLINE;
+retval |= octave_lexer::NEWLINE;
 if (in_comment)
 {
 comment_buf += static_cast<char> (c);
 octave_comment_buffer::append (comment_buf);
 comment_buf.resize (0);
 {
 return (len > 2 && s[0] == '0' && (s[1] == 'x' || s[1] == 'X'));
 }
 void
-lexical_feedback::handle_number (void)
+octave_lexer::handle_number (void)
 {
 double value = 0.0;
 int nread = 0;
 char *yytxt = flex_yytext ();
 // characters, return 0.  Otherwise, return 1.
 // FIXME -- we need to handle block comments here.
 bool
-lexical_feedback::have_continuation (bool trailing_comments_ok)
+octave_lexer::have_continuation (bool trailing_comments_ok)
 {
 std::ostringstream buf;
 std::string comment_buf;
 // We have seen a '.' and need to see if it is the start of a
 // continuation.  If so, this eats it, up to and including the new
 // line character.
 bool
-lexical_feedback::have_ellipsis_continuation (bool trailing_comments_ok)
+octave_lexer::have_ellipsis_continuation (bool trailing_comments_ok)
 {
 char c1 = text_yyinput ();
 if (c1 == '.')
 {
 char c2 = text_yyinput ();
 // See if we have a continuation line.  If so, eat it and the leading
 // whitespace on the next line.
 int
-lexical_feedback::eat_continuation (void)
+octave_lexer::eat_continuation (void)
 {
-int retval = lexical_feedback::NO_WHITESPACE;
+int retval = octave_lexer::NO_WHITESPACE;
 int c = text_yyinput ();
 if ((c == '.' && have_ellipsis_continuation ())
 || (c == '\\' && have_continuation ()))
 return retval;
 }
 int
-lexical_feedback::handle_string (char delim)
+octave_lexer::handle_string (char delim)
 {
 std::ostringstream buf;
 int bos_line = input_line_number;
 int bos_col = current_input_column;
 return LEXICAL_ERROR;
 }
 bool
-lexical_feedback::next_token_is_assign_op (void)
+octave_lexer::next_token_is_assign_op (void)
 {
 bool retval = false;
 int c0 = text_yyinput ();
 return retval;
 }
 bool
-lexical_feedback::next_token_is_index_op (void)
+octave_lexer::next_token_is_index_op (void)
 {
 int c = text_yyinput ();
 xunput (c);
 return c == '(' || c == '{';
 }
 int
-lexical_feedback::handle_close_bracket (bool spc_gobbled, int bracket_type)
+octave_lexer::handle_close_bracket (bool spc_gobbled, int bracket_type)
 {
 OCTAVE_YYG;
 int retval = bracket_type;
 return retval;
 }
 void
-lexical_feedback::maybe_unput_comma (int spc_gobbled)
+octave_lexer::maybe_unput_comma (int spc_gobbled)
 {
 if (nesting_level.is_bracket ()
 || (nesting_level.is_brace ()
 && ! looking_at_object_index.front ()))
 {
 xunput (',');
 }
 }
 bool
-lexical_feedback::next_token_can_follow_bin_op (void)
+octave_lexer::next_token_can_follow_bin_op (void)
 {
 std::stack<char> buf;
 int c = EOF;
 || tok == "Inf" || tok == "inf"
 || tok == "NaN" || tok == "nan");
 }
 bool
-lexical_feedback::looks_like_command_arg (void)
+octave_lexer::looks_like_command_arg (void)
 {
 bool retval = true;
 int c0 = text_yyinput ();
 return retval;
 }
 int
-lexical_feedback::handle_superclass_identifier (void)
+octave_lexer::handle_superclass_identifier (void)
 {
 eat_continuation ();
 std::string pkg;
 char *yytxt = flex_yytext ();
 return SUPERCLASSREF;
 }
 int
-lexical_feedback::handle_meta_identifier (void)
+octave_lexer::handle_meta_identifier (void)
 {
 eat_continuation ();
 std::string pkg;
 char *yytxt = flex_yytext ();
 // Figure out exactly what kind of token to return when we have seen
 // an identifier.  Handles keywords.  Return -1 if the identifier
 // should be ignored.
 int
-lexical_feedback::handle_identifier (void)
+octave_lexer::handle_identifier (void)
 {
 OCTAVE_YYG;
 bool at_bos = at_beginning_of_statement;
 std::string tok = strip_trailing_whitespace (yytxt);
 int c = yytxt[flex_yyleng()-1];
-bool cont_is_spc = (eat_continuation () != lexical_feedback::NO_WHITESPACE);
+bool cont_is_spc = (eat_continuation () != octave_lexer::NO_WHITESPACE);
 int spc_gobbled = (cont_is_spc || c == ' ' || c == '\t');
 // If we are expecting a structure element, avoid recognizing
 // keywords and other special names and return STRUCT_ELT, which is
 return NAME;
 }
 void
-lexical_feedback::maybe_warn_separator_insert (char sep)
+octave_lexer::maybe_warn_separator_insert (char sep)
 {
 std::string nm = curr_fcn_file_full_name;
 if (nm.empty ())
 warning_with_id ("Octave:separator-insert",
 "potential auto-insertion of '%c' near line %d of file %s",
 sep, input_line_number, nm.c_str ());
 }
 void
-lexical_feedback::gripe_single_quote_string (void)
+octave_lexer::gripe_single_quote_string (void)
 {
 std::string nm = curr_fcn_file_full_name;
 if (nm.empty ())
 warning_with_id ("Octave:single-quote-string",
 "single quote delimited string near line %d of file %s",
 input_line_number, nm.c_str ());
 }
 void
-lexical_feedback::gripe_matlab_incompatible (const std::string& msg)
+octave_lexer::gripe_matlab_incompatible (const std::string& msg)
 {
 std::string nm = curr_fcn_file_full_name;
 if (nm.empty ())
 warning_with_id ("Octave:matlab-incompatible",
 "potential Matlab compatibility problem: %s near line %d offile %s",
 msg.c_str (), input_line_number, nm.c_str ());
 }
 void
-lexical_feedback::maybe_gripe_matlab_incompatible_comment (char c)
+octave_lexer::maybe_gripe_matlab_incompatible_comment (char c)
 {
 if (c == '#')
 gripe_matlab_incompatible ("# used as comment character");
 }
 void
-lexical_feedback::gripe_matlab_incompatible_continuation (void)
+octave_lexer::gripe_matlab_incompatible_continuation (void)
 {
 gripe_matlab_incompatible ("\\ used as line continuation marker");
 }
 void
-lexical_feedback::gripe_matlab_incompatible_operator (const std::string& op)
+octave_lexer::gripe_matlab_incompatible_operator (const std::string& op)
 {
 std::string t = op;
 int n = t.length ();
 if (t[n-1] == '\n')
 t.resize (n-1);
 gripe_matlab_incompatible (t + " used as operator");
 }
 void
-lexical_feedback::push_token (token *tok)
+octave_lexer::push_token (token *tok)
 {
 YYSTYPE *lval = yyget_lval (scanner);
 lval->tok_val = tok;
 token_stack.push (tok);
 }
 token *
-lexical_feedback::current_token (void)
+octave_lexer::current_token (void)
 {
 YYSTYPE *lval = yyget_lval (scanner);
 return lval->tok_val;
 }
 void
-lexical_feedback::display_token (int tok)
+octave_lexer::display_token (int tok)
 {
 switch (tok)
 {
 case '=': std::cerr << "'='\n"; break;
 case ':': std::cerr << "':'\n"; break;
 break;
 }
 }
 void
-lexical_feedback::fatal_error (const char *msg)
+octave_lexer::fatal_error (const char *msg)
 {
 error (msg);
 OCTAVE_QUIT;
 yy_fatal_error (msg, scanner);
 }
 void
-lexical_feedback::lexer_debug (const char *pattern, const char *text)
+octave_lexer::lexer_debug (const char *pattern, const char *text)
 {
 OCTAVE_YYG;
 std::cerr << std::endl;

Mercurial > hg > octave-lyh

comparison libinterp/parse-tree/lex.ll @ 16158:7eb614760ddb