octave-nkf: src/lex.l comparison

comparison src/lex.l @ 3246:a41cc560087a

[project @ 1999-06-19 06:46:20 by jwe]

author	jwe
date	Sat, 19 Jun 1999 06:46:35 +0000
parents	041ea33fbbf4
children	4964d5391acc

comparison

equal deleted inserted replaced

-:2270329efd14
+:a41cc560087a
 static int is_keyword (const string& s);
 static string plot_style_token (const string& s);
 static symbol_record *lookup_identifier (const string& s);
 static void grab_help_text (void);
 static bool match_any (char c, const char *s);
-static bool next_token_is_bin_op (int spc_prev, char *yytext);
+static bool next_token_is_bin_op (bool spc_prev);
-static bool next_token_is_postfix_unary_op (int spc_prev, char *yytext);
+static bool next_token_is_postfix_unary_op (bool spc_prev);
 static string strip_trailing_whitespace (char *s);
-static void handle_number (char *yytext);
+static void handle_number (void);
 static int handle_string (char delim, int text_style = 0);
 static int handle_close_brace (int spc_gobbled);
 static int handle_identifier (const string& tok, int spc_gobbled);
 static bool have_continuation (bool trailing_comments_ok = true);
 static bool have_ellipsis_continuation (bool trailing_comments_ok = true);
 }
 }
 <TEXT_FCN>[\"\'] {
 current_input_column++;
-return handle_string (yytext[0], 1);
+return handle_string (yytext[0], true);
 }
 <TEXT_FCN>[^ \t\n\;\,\"\'][^ \t\n\;\,]*{S}* {
 string tok = strip_trailing_whitespace (yytext);
 TOK_PUSH_AND_RETURN (tok, TEXT);
 <MATRIX>{S}+ {
 current_input_column += yyleng;
 if (Vwhitespace_in_literal_matrix != 2)
 {
 	int tmp = eat_continuation ();
-	int bin_op = next_token_is_bin_op (1, yytext);
+	int bin_op = next_token_is_bin_op (true);
-	int postfix_un_op = next_token_is_postfix_unary_op (1, yytext);
+	int postfix_un_op = next_token_is_postfix_unary_op (true);
 	if (! (postfix_un_op || bin_op)
 	    && nesting_level.is_brace ()
 	    && lexer_flags.convert_spaces_to_comma)
 	  {
 %{
 // Imaginary numbers.
 %}
 {NUMBER}{Im} {
-handle_number (yytext);
+handle_number ();
 return IMAG_NUM;
 }
 %{
 // Real numbers.  Don't grab the `.' part of a dot operator as part of
 // the constant.
 %}
 {D}+/\.[\*/\\^'] |
 {NUMBER} {
-handle_number (yytext);
+handle_number ();
 return NUM;
 }
 %{
 // Eat whitespace.  Whitespace inside matrix constants is handled by
 {
 int spc_gobbled = eat_continuation ();
 int c = yyinput ();
-yyunput (c, yytext);
+unput (c);
 if (spc_gobbled)
-yyunput (' ', yytext);
+unput (' ');
 lexer_flags.do_comma_insert = (lexer_flags.braceflag && c == '[');
 }
 // Fix things up for errors or interrupts.  The parser is never called
 }
 done:
 if (c)
-yyunput (c, yytext);
+unput (c);
 }
 // Return 1 if the given character matches any character in the given
 // string.
 // operator.  For example,
 //
 //   [ 1 + 2 ]  or  [ 1+ 2]  or  [ 1+2 ]  ==> binary
 static bool
-looks_like_bin_op (int spc_prev, int spc_next)
+looks_like_bin_op (bool spc_prev, int next_char)
 {
+bool spc_next = (next_char == ' ' || next_char == '\t');
 return ((spc_prev && spc_next) || ! spc_prev);
 }
 // 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.
 static bool
-next_token_is_postfix_unary_op (int spc_prev, char *yytext)
+next_token_is_postfix_unary_op (bool spc_prev)
 {
 bool un_op = false;
 int c0 = yyinput ();
-int c1 = yyinput ();
+if (c0 == '\'' && ! spc_prev)
-yyunput (c1, yytext);
+{
-yyunput (c0, yytext);
+un_op = true;
+}
-int transpose = (c0 == '.' && c1 == '\'');
+else if (c0 == '.')
-int hermitian = (c0 == '\'');
+{
+int c1 = yyinput ();
-un_op = (transpose || (hermitian && ! spc_prev));
+un_op = (c1 == '\'');
+unput (c1);
+}
+unput (c0);
 return un_op;
 }
 // Try to determine if the next token should be treated as a binary
-// operator.  This is even uglier, but it also seems to do the right
+// operator.
-// thing.  Note that it is only necessary to check the spacing for `+'
+//
-// and `-', since those are the only tokens that can appear as unary
+// This kluge exists because whitespace is not always ignored inside
-// ops too.
+// the square brackets that are used to create matrix objects.
 //
-// Note that this never returns true for `.', even though it can be a
+// Line continuations directly after the operator will cause this
-// binary operator (the structure reference thing).  The only time
+// function to return FALSE.
-// this appears to matter is for things like
-//
-//   [ a . b ]
-//
-// which probably doesn't occur that often, can be worked around by
-// eliminating the whitespace, putting the expression in parentheses,
-// or using `whitespace_in_literal_matrix = "ignored"', so I think it
-// is an acceptable change.  It would be quite a bit harder to `fix'
-// this.  (Well, maybe not.  the best fix would be to do away with the
-// specialness of whitespace inside of `[ ... ]').
-//
-// However, we still do check for `.+', `.*', etc.
 static bool
-next_token_is_bin_op (int spc_prev, char *yytext)
+next_token_is_bin_op (bool spc_prev)
 {
 bool bin_op = false;
 int c0 = yyinput ();
 switch (c0)
 {
+case ':':
 case '+':
 case '-':
+case '/':
+case '\\':
+case '^':
 {
 	int c1 = yyinput ();
-	yyunput (c1, yytext);
+	bin_op = looks_like_bin_op (spc_prev, c1);
-	int spc_next = (c1 == ' ' || c1 == '\t');
+	unput (c1);
-	bin_op = looks_like_bin_op (spc_prev, spc_next);
 }
 break;
+// .+ .- ./ .\ .^ .* .**
 case '.':
 {
 	int c1 = yyinput ();
-	yyunput (c1, yytext);
-	bin_op = match_any (c1, "+-*/\\^");
+	if (match_any (c1, "+-/\\^"))
+	  {
+	    int c2 = yyinput ();
+	    bin_op = looks_like_bin_op (spc_prev, c2);
+	    unput (c2);
+	  }
+	else if (c1 == '*')
+	  {
+	    int c2 = yyinput ();
+	    if (c2 == '*')
+	      {
+		int c3 = yyinput ();
+		bin_op = looks_like_bin_op (spc_prev, c3);
+		unput (c3);
+	      }
+	    else
+	      bin_op = looks_like_bin_op (spc_prev, c2);
+	    unput (c2);
+	  }
+	else if (! isdigit (c1) && c1 != ' ' && c1 != '\t')
+	  {
+	    bin_op = true;
+	  }
+	unput (c1);
 }
 break;
-case '/':
+// = == & && | || * **
-case ':':
+case '=':
-case '\\':
-case '^':
 case '&':
+case '|':
 case '*':
-case '|':
+{
+	int c1 = yyinput ();
+	if (c1 == c0)
+	  {
+	    int c2 = yyinput ();
+	    bin_op = looks_like_bin_op (spc_prev, c2);
+	    unput (c2);
+	  }
+	else
+	  bin_op = looks_like_bin_op (spc_prev, c1);
+	unput (c1);
+}
+break;
+// <= >= <> ~= != < >
 case '<':
 case '>':
 case '~':
 case '!':
-case '=':
+{
-bin_op = true;
+	int c1 = yyinput ();
+	if ((c1 == '=') || (c1 == '<' && c1 == '>'))
+	  {
+	    int c2 = yyinput ();
+	    bin_op = looks_like_bin_op (spc_prev, c2);
+	    unput (c2);
+	  }
+	else if (c1 != '~' && c1 != '!')
+	  bin_op = looks_like_bin_op (spc_prev, c1);
+	unput (c1);
+}
 break;
 default:
 break;
 }
-yyunput (c0, yytext);
+unput (c0);
 return bin_op;
 }
 // Used to delete trailing white space from tokens.
 	    goto done;
 	}
 }
 done:
-yyunput (c, yytext);
+unput (c);
 current_input_column--;
 return retval;
 }
 static inline bool
 {
 return (len > 2 && s[0] == '0' && (s[1] == 'x' || s[1] == 'X'));
 }
 static void
-handle_number (char *yytext)
+handle_number (void)
 {
 char *tmp = strsave (yytext);
 char *idx = strpbrk (tmp, "Dd");
 	    goto cleanup;
 	  break;
 	}
 }
-yyunput (c, yytext);
+unput (c);
 return false;
 cleanup:
 buf << ends;
 char *s = buf.str ();
 if (s)
 {
 int len = strlen (s);
 while (len--)
-	yyunput (s[len], yytext);
+	unput (s[len]);
 }
 delete [] s;
 return false;
 }
 char c2 = yyinput ();
 if (c2 == '.' && have_continuation (trailing_comments_ok))
 	return true;
 else
 	{
-	  yyunput (c2, yytext);
+	  unput (c2);
-	  yyunput (c1, yytext);
+	  unput (c1);
 	}
 }
 else
-yyunput (c1, yytext);
+unput (c1);
 return false;
 }
 // See if we have a continuation line.  If so, eat it and the leading
 int c = yyinput ();
 if ((c == '.' && have_ellipsis_continuation ())
 || (c == '\\' && have_continuation ()))
 retval = eat_whitespace ();
 else
-yyunput (c, yytext);
+unput (c);
 return retval;
 }
 static int
 	      c = yyinput ();
 	      if (c == delim)
 		buf << (char) c;
 	      else
 		{
-		  yyunput (c, yytext);
+		  unput (c);
 		  buf << ends;
 		  char *t = buf.str ();
 		  string s = do_string_escapes (t);
 		  delete [] t;
 int c1 = yyinput ();
 unput (c1);
 if (lexer_flags.braceflag && Vwhitespace_in_literal_matrix != 2)
 	{
-	  int bin_op = next_token_is_bin_op (spc_gobbled, yytext);
+	  int bin_op = next_token_is_bin_op (spc_gobbled);
-	  int postfix_un_op = next_token_is_postfix_unary_op
+	  int postfix_un_op = next_token_is_postfix_unary_op (spc_gobbled);
-	    (spc_gobbled, yytext);
 	  int other_op = match_any (c1, ",;\n]");
 	  if (! (postfix_un_op || bin_op || other_op)
 	      && nesting_level.is_brace ()
 static void
 maybe_unput_comma (int spc_gobbled)
 {
 if (Vwhitespace_in_literal_matrix != 2 && nesting_level.is_brace ())
 {
-int bin_op = next_token_is_bin_op (spc_gobbled, yytext);
+int bin_op = next_token_is_bin_op (spc_gobbled);
-int postfix_un_op
+int postfix_un_op = next_token_is_postfix_unary_op (spc_gobbled);
-	= next_token_is_postfix_unary_op (spc_gobbled, yytext);
 int c1 = yyinput ();
 int c2 = yyinput ();
 unput (c2);
 if (lexer_flags.cant_be_identifier && plot_option_kw)
 	TOK_RETURN (plot_option_kw);
 }
 int c = yyinput ();
-yyunput (c, yytext);
+unput (c);
 bool next_tok_is_eq = (c == '=');
+bool next_tok_is_dot = (c == '.');
 bool next_tok_is_paren = (c == '(');
 // Make sure we put the return values of a function in the symbol
 // table that is local to the function.
 if (is_text_function_name (tok) && ! is_variable (tok))
 {
 if (next_tok_is_eq
 	  || lexer_flags.looking_at_return_list
 	  || lexer_flags.looking_at_parameter_list
-	  || lexer_flags.looking_at_matrix_or_assign_lhs)
+	  || lexer_flags.looking_at_matrix_or_assign_lhs
+	  || (next_tok_is_dot && next_token_is_bin_op (spc_gobbled)))
 	{
 	  force_local_variable (tok);
 	}
 else if (! next_tok_is_paren)
 	{
 void
 check_for_garbage_after_fcn_def (void)
 {
 // By making a newline be the next character to be read, we will
 // force the parser to return after reading the function.  Calling
-// yyunput with EOF seems not to work...
+// unput with EOF does not work.
 bool in_comment = false;
 int lineno = input_line_number;
 int c;
 while ((c = yyinput ()) != EOF)
 	  else
 	    {
 	      warning ("ignoring trailing garbage after end of function\n\
 near line %d of file `%s.m'", lineno, curr_fcn_file_name.c_str ());
-	      yyunput ('\n', yytext);
+	      unput ('\n');
 	      return;
 	    }
 	}
 }
-yyunput ('\n', yytext);
+unput ('\n');
 }
 void
 lexical_feedback::init (void)
 {
 // Quote marks strings intially.
 quote_is_transpose = false;
 }
-int
+static int
 whitespace_in_literal_matrix (void)
 {
 int pref = 0;
 string val = builtin_string_variable ("whitespace_in_literal_matrix");

Mercurial > hg > octave-nkf

comparison src/lex.l @ 3246:a41cc560087a