octave-nkf: src/lex.l comparison

comparison src/lex.l @ 1001:641c05eaed01

[project @ 1994-12-23 06:17:30 by jwe]

author	jwe
date	Fri, 23 Dec 1994 06:17:30 +0000
parents	18be848f10a9
children	dfe01093f657

comparison

equal deleted inserted replaced

-:de0df9547e08
+:641c05eaed01
 static void grab_help_text (void);
 static int match_any (char c, char *s);
 static int next_token_is_bin_op (int spc_prev, char *yytext);
 static int next_token_is_postfix_unary_op (int spc_prev, char *yytext);
 static char *strip_trailing_whitespace (char *s);
-static void eat_whitespace (void);
 static void handle_number (char *yytext);
 static int handle_string (char delim, int text_style = 0);
-static int handle_close_brace (char *yytext);
+static int handle_close_brace (int spc_gobbled);
-static int handle_identifier (char *s, int next_tok_is_eq);
+static int handle_identifier (char *tok, int spc_gobbled);
+static int have_continuation (void);
+static int have_ellipsis_continuation (void);
+static int eat_whitespace (void);
+static int eat_continuation (void);
 %}
 D	[0-9]
 S	[ \t]
 // It's also a pain in the ass to decide whether to insert a comma
 // after seeing a ']' character...
 %}
 <MATRIX>{SNL}*\]{S}* {
-return handle_close_brace (yytext);
+fixup_column_count (yytext);
+int c = yytext[yyleng-1];
+int cont_is_spc = eat_continuation ();
+int spc_gobbled = (cont_is_spc || c == ' ' || c == '\t');
+return handle_close_brace (spc_gobbled);
 }
 %{
 // Commas are element separators in matrix constants.
 %}
 	  TOK_RETURN (',');
 }
 }
 %{
-// Semicolons are both handled as row seprators in matrix constants.
+// Semicolons are handled as row seprators in matrix constants.
 %}
 <MATRIX>{SNLCMT}*;{SNLCMT}* {
 fixup_column_count (yytext);
+eat_whitespace ();
 quote_is_transpose = 0;
 cant_be_identifier = 0;
 convert_spaces_to_comma = 1;
 return ';';
 }
 	TOK_RETURN ('[');
 }
 }
 \] {
-promptflag++;
 if (! nesting_level.empty ())
 nesting_level.pop ();
 if (plotting && ! past_plot_range)
 {
 {IDENT}{S}* {
 static char *tok = 0;
 delete [] tok;
 tok = strip_trailing_whitespace (yytext);
-int c = yyinput ();
+current_input_column += yyleng;
-unput (c);
+int c = yytext[yyleng-1];
-return handle_identifier (tok, (c == '='));
+int cont_is_spc = eat_continuation ();
+int spc_gobbled = (cont_is_spc || c == ' ' || c == '\t');
+return handle_identifier (tok, spc_gobbled);
 }
 %{
 // A new line character.  New line characters inside matrix constants
 // are handled by the <MATRIX> start state code above.  If closest
 TOK_RETURN ('(');
 }
 ")" {
 if (! nesting_level.empty ())
-{
+nesting_level.pop ();
-	nesting_level.pop ();
-	promptflag++;
-}
-do_comma_insert_check ();
 current_input_column++;
 cant_be_identifier = 1;
 quote_is_transpose = 1;
 convert_spaces_to_comma = (! nesting_level.empty ()
 			       && nesting_level.top () == BRACE);
+do_comma_insert_check ();
 return ')';
 }
 %{
 // We return everything else as single character tokens, which should
 // that we insert a comma ahead of it.
 void
 do_comma_insert_check (void)
 {
+int spc_gobbled = eat_continuation ();
 int c = yyinput ();
 yyunput (c, yytext);
+if (spc_gobbled)
+yyunput (' ', yytext);
 do_comma_insert = (braceflag && c == '[');
 }
 // Fix things up for errors or interrupts.  The parser is never called
 // recursively, so it is always safe to reinitialize its state before
 token_stack.push (yylval.tok_val);
 return ALL_VA_ARGS;
 }
 if (end_found)
-{
+return END;
-if (! defining_func && ! looping)
-	promptflag++;
-return END;
-}
 return 0;
 }
 // Try to find an identifier.  All binding to global or builtin
 *t = '\0';
 return retval;
 }
-static void
+// Discard whitespace, including comments and continuations.
+// Return 1 if whitespace appeared in the input, 0 otherwise.
+static int
 eat_whitespace (void)
 {
+int retval = 0;
 int in_comment = 0;
 int c;
 while ((c = yyinput ()) != EOF)
 {
 current_input_column++;
 switch (c)
 	{
 	case ' ':
 	case '\t':
+	  retval = 1;
 	  break;
 	case '\n':
+	  retval = 1;
 	  in_comment = 0;
 	  current_input_column = 0;
 	  break;
 	case '#':
 	case '%':
 	  in_comment = 1;
 	  break;
+	case '.':
+	  if (in_comment)
+	    break;
+	  else
+	    {
+	      if (have_ellipsis_continuation ())
+		break;
+	      else
+		goto done;
+	    }
+	case '\\':
+	  if (in_comment)
+	    break;
+	  else
+	    {
+	      if (have_continuation ())
+		break;
+	      else
+		goto done;
+	    }
 	default:
 	  if (in_comment)
 	    break;
 	  else
 	}
 }
 done:
 yyunput (c, yytext);
-return;
+return retval;
 }
 static void
 handle_number (char *yytext)
 {
 current_input_column += yyleng;
 do_comma_insert_check ();
 }
+// We have seen a backslash and need to find out if it should be
+// treated as a continuation character.  If so, this eats it, up to
+// and including the new line character.
+//
 // Match whitespace only, followed by a comment character or newline.
 // Once a comment character is found, discard all input until newline.
 // If non-whitespace characters are found before comment
 // characters, return 0.  Otherwise, return 1.
 	  in_comment = 1;
 	  break;
 	case '\n':
 	  current_input_column = 0;
+	  promptflag--;
 	  return 1;
 	default:
 	  if (in_comment)
 	    break;
 yyunput (c, yytext);
 return 0;
 }
+// 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.
 static int
 have_ellipsis_continuation (void)
 {
 char c1 = yyinput ();
 if (c1 == '.')
 yyunput (c1, yytext);
 return 0;
 }
+// See if we have a continuation line.  If so, eat it and the leading
+// whitespace on the next line.
+// Return 1 if whitespace appeared in the input, 0 otherwise.
+static int
+eat_continuation (void)
+{
+int retval = 0;
+int c = yyinput ();
+if ((c == '.' && have_ellipsis_continuation ())
+|| (c == '\\' && have_continuation ()))
+retval = eat_whitespace ();
+else
+yyunput (c, yytext);
+return retval;
+}
 static int
 handle_string (char delim, int text_style)
 {
 ostrstream buf;
 {
 current_input_column++;
 if (c == '\\')
 	{
-	  if (have_continuation ())
+	  if (! have_continuation ())
-	    promptflag--;
-	  else
 	    buf << (char) c;
 	  goto next;
 	}
 else if (c == '.')
 	{
-	  if (have_ellipsis_continuation ())
+	  if (! have_ellipsis_continuation ())
-	    promptflag--;
-	  else
 	    buf << (char) c;
 	  goto next;
 	}
 else if (c == '\n')
 	{
 return LEXICAL_ERROR;
 }
 static int
-handle_close_brace (char *yytext)
+handle_close_brace (int spc_gobbled)
 {
-fixup_column_count (yytext);
 if (! nesting_level.empty ())
 {
 nesting_level.pop ();
 braceflag--;
 }
 if (braceflag == 0)
-{
+BEGIN 0;
-if (! defining_func)
-	promptflag++;
-BEGIN 0;
-}
 int c1 = yyinput ();
 if (c1 == '=')
 {
 quote_is_transpose = 0;
 cant_be_identifier = 0;
 convert_spaces_to_comma = 1;
 {
 unput (c1);
 if (braceflag && user_pref.whitespace_in_literal_matrix != 2)
 	{
-	  int c0 = yytext[yyleng-1];
+	  int bin_op = next_token_is_bin_op (spc_gobbled, yytext);
-	  int spc_prev = (c0 == ' ' || c0 == '\t');
-	  int bin_op = next_token_is_bin_op (spc_prev, yytext);
 	  int postfix_un_op = next_token_is_postfix_unary_op
-	    (spc_prev, yytext);
+	    (spc_gobbled, yytext);
 	  int other_op = match_any (c1, ",;\n]");
 	  if (! (postfix_un_op || bin_op || other_op
 		 || nesting_level.empty ())
 // Figure out exactly what kind of token to return when we have seen
 // an identifier.  Handles keywords.
 static int
-handle_identifier (char *tok, int next_tok_is_eq)
+handle_identifier (char *tok, int spc_gobbled)
 {
 // It is almost always an error for an identifier to be followed
 // directly by another identifier.  Special cases are handled below.
 cant_be_identifier = 1;
 int kw_token = is_keyword (tok);
 if (kw_token)
 {
 if (kw_token == STYLE)
 	{
-	  current_input_column += yyleng;
 	  quote_is_transpose = 0;
 	  convert_spaces_to_comma = 1;
 	  return kw_token;
 	}
 else
 	BEGIN HELP_FCN;
 else if (strcmp (tok, "set") == 0)
 	doing_set = 1;
 }
+int c = yyinput ();
+yyunput (c, yytext);
+int next_tok_is_eq = (c == '=');
 // Make sure we put the return values of a function in the symbol
 // table that is local to the function.
 if (next_tok_is_eq && defining_func && maybe_screwed)
 curr_sym_tab = tmp_local_sym_tab;
 // After seeing an identifer, it is ok to convert spaces to a comma
 // (if needed).
 convert_spaces_to_comma = 1;
-current_input_column += yyleng;
 // If we are defining a function and we have not seen the parameter
 // list yet and the next token is `=', return a token that represents
 // the only return value for the function.  For example,
 //
 if (user_pref.whitespace_in_literal_matrix != 2
 && ! nesting_level.empty ()
 && nesting_level.top () == BRACE)
 {
-int c0 = yytext[yyleng-1];
+int bin_op = next_token_is_bin_op (spc_gobbled, yytext);
-int spc_prev = (c0 == ' ' || c0 == '\t');
-int bin_op = next_token_is_bin_op (spc_prev, yytext);
+int postfix_un_op = next_token_is_postfix_unary_op (spc_gobbled,
-int postfix_un_op = next_token_is_postfix_unary_op (spc_prev,
 							  yytext);
 int c1 = yyinput ();
 unput (c1);
 int other_op = match_any (c1, ".,;\n]");
 int index_op = (c1 == '('
 		      && (user_pref.whitespace_in_literal_matrix == 0
-			  || ! spc_prev));
+			  || ! spc_gobbled));
 if (! (postfix_un_op || bin_op || other_op || index_op))
 	unput (',');
 }

Mercurial > octave-nkf

comparison src/lex.l @ 1001:641c05eaed01