/* lex.l                                                -*- C -*-

Copyright (C) 1992, 1993 John W. Eaton

This file is part of Octave.

Octave is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by the
Free Software Foundation; either version 2, or (at your option) any
later version.

Octave is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
for more details.

You should have received a copy of the GNU General Public License
along with GNU CC; see the file COPYING.  If not, write to the Free
Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.

*/

%x COMMENT
%x NEW_MATRIX
%x HELP_FCN
%s TEXT_FCN
%s DQSTRING
%s STRING
%s MATRIX

%{

// Arrange to get input via readline.

#ifdef YY_INPUT
#undef YY_INPUT
#define YY_INPUT(buf,result,max_size) \
  if ((result = octave_read (buf, max_size)) < 0) \
    YY_FATAL_ERROR ("octave_read () in flex scanner failed");
#endif

// Try to avoid crashing out completely on fatal scanner errors.

#ifdef YY_FATAL_ERROR
#undef YY_FATAL_ERROR
#define YY_FATAL_ERROR(msg) \
  do \
    { \
      error (msg); \
      jump_to_top_level (); \
    } \
  while (0)
#endif

#include "input.h"

// The type of an END token.  This declaration is repeated in parse.y.
// It must appear before y.tab.h is included.
enum end_tok_type
  {
    simple_end,
    for_end,
    function_end,
    if_end,
    while_end,
  };

// The type of a PLOT token.  This declaration is repeated in parse.y.
// It must appear before y.tab.h is included.
enum plot_tok_type
  {
    two_dee = 2,
    three_dee = 3,
  };

#include "SLStack.h"

#include "variables.h"
#include "symtab.h"
#include "error.h"
#include "utils.h"
#include "tree.h"
#include "y.tab.h"
#include "parse.h"
#include "lex.h"

// Nonzero means we thing we are looking at the beginning of a
// function definition.
static int beginning_of_function = 0;

// Nonzero means we think we are looking at a set command.
static int doing_set = 0;

// GAG.  Stupid kludge so that [[1,2][3,4]] will work.
static do_comma_insert = 0;

// Brace level count.
static int braceflag = 0;

// Return transpose or start a string?
static int quote_is_transpose = 0;

// Nonzero means that we should convert spaces to a comma inside a
// matrix definition.
static int convert_spaces_to_comma = 1;

// Another context hack, this time for the plot command's `using',
// `title', and `with' keywords.
static int cant_be_identifier = 0;

// Is the closest nesting level a square brace or a paren?
//
//  1 -> brace, spaces are important (they can turn into commas)
//  0 -> paren, spaces are not important
//
static SLStack <int> in_brace_or_paren;

static void do_string_escapes (char *s);
static void fixup_column_count (char *s);
static int do_comma_insert_check (void);
static int is_plot_keyword (char *s);
static int is_keyword (char *s);
static char *plot_style_token (char *s);
static symbol_record *lookup_identifier (char *s);
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);

#define DO_COMMA_INSERT_CHECK yyless (do_comma_insert_check ())

#define RETURN(token) \
  do \
    { \
      current_input_column += yyleng; \
      quote_is_transpose = 0; \
      cant_be_identifier = 0; \
      convert_spaces_to_comma = 1; \
      return (token); \
    } \
  while (0)

#define BIN_OP_RETURN(token) \
  do \
    { \
      current_input_column += yyleng; \
      quote_is_transpose = 0; \
      cant_be_identifier = 0; \
      convert_spaces_to_comma = 0; \
      return (token); \
    } \
  while (0)

%}

D	[0-9]
S	[ \t]
N	[\n]
SN	[ \t\n]
EL	(\.\.\.)
Im	[iIjJ]
QQ	(\'\')
ECHAR	(\\.)
QSTR	([^\n\'\\]*({QQ}|{ECHAR})*)
DQSTR	([^\n\"\\]*{ECHAR}*)
IDENT	([_a-zA-Z][_a-zA-Z0-9]*)
EXPON	([DdEe][+-]?{D}+)
%%

\%			|
\#			{
			  if (beginning_of_function)
			    {
			      grab_help_text ();
			      beginning_of_function = 0;
			    }

			  BEGIN COMMENT;
			  current_input_column += yyleng;
			}

<COMMENT>\n		{
			  BEGIN 0;
			  current_input_column = 0;
			  quote_is_transpose = 0;
			  cant_be_identifier = 0;
			  convert_spaces_to_comma = 1;
			  return '\n';
			}

<COMMENT><<EOF>>	{ RETURN (END_OF_INPUT); }

<COMMENT>.*$		{ current_input_column += yyleng; }

<NEW_MATRIX>[^ \t\n]	{
			  yyless (0);
			  BEGIN MATRIX;
			}

<NEW_MATRIX>{SN}*	{
			  fixup_column_count (yytext);
			  BEGIN MATRIX;
			}

<HELP_FCN>\n		|
<TEXT_FCN>\n		{
		          BEGIN 0;
			  current_input_column = 0;
			  quote_is_transpose = 0;
			  cant_be_identifier = 0;
			  convert_spaces_to_comma = 1;
			  return '\n';
			}

<TEXT_FCN>[\;\,]	{
			  if (doing_set)
			    {
			      yylval.string = strsave (yytext);
			      RETURN (TEXT);
			    }
			  else
			    {
			      BEGIN 0;
			      RETURN (',');
			    }
		        }

<HELP_FCN>[^ \t\n]*{S}*	    |
<TEXT_FCN>[^ \t\n\;\,]*{S}* {

			  static char *tok = (char *) NULL;
			  delete [] tok;
			  tok = strip_trailing_whitespace (yytext);

			  yylval.string = strsave (tok);
			  RETURN (TEXT);
			}

<TEXT_FCN>\'{QSTR}*[\n\'] {
			  if (yytext[yyleng-1] == '\n')
			    {
			      error ("unterminated string constant");
			      current_input_column = 0;
			      jump_to_top_level ();
			    }
			  else
			    {
			      int off1 = doing_set ? 0 : 1;
			      int off2 = doing_set ? 0 : 2;
			      yylval.string = strsave (&yytext[off1]);
			      yylval.string[yyleng-off2] = '\0';
			      current_input_column += yyleng;
			    }
			  do_string_escapes (yylval.string);
			  return TEXT;
			}

<TEXT_FCN>\"{DQSTR}*[\n\"] {
			  if (yytext[yyleng-1] == '\n')
			    {
			      error ("unterminated string constant");
			      current_input_column = 0;
			      jump_to_top_level ();
			    }
			  else
			    {
			      int off1 = doing_set ? 0 : 1;
			      int off2 = doing_set ? 0 : 2;
			      yylval.string = strsave (&yytext[off1]);
			      yylval.string[yyleng-off2] = '\0';
			      current_input_column += yyleng;
			    }
			  do_string_escapes (yylval.string);
			  return TEXT;
			}

<TEXT_FCN>{S}*		{ current_input_column += yyleng; }

<STRING>{QSTR}*[\n\']	{
			  if (braceflag)
			    BEGIN MATRIX;
			  else
			    BEGIN 0;

			  if (yytext[yyleng-1] == '\n')
			    {
			      error ("unterminated string constant");
			      current_input_column = 0;
			      jump_to_top_level ();
			    }
			  else
			    {
			      yylval.string = strsave (yytext);
			      yylval.string[yyleng-1] = '\0';
			      current_input_column += yyleng;
			    }
			  do_string_escapes (yylval.string);
			  quote_is_transpose = 1;
			  cant_be_identifier = 1;
			  convert_spaces_to_comma = 1;
			  return TEXT;
			}


<DQSTRING>{DQSTR}*[\n\"] {
			  if (braceflag)
			    BEGIN MATRIX;
			  else
			    BEGIN 0;

			  if (yytext[yyleng-1] == '\n')
			    {
			      error ("unterminated string constant");
			      current_input_column = 0;
			      jump_to_top_level ();
			    }
			  else
			    {
			      yylval.string = strsave (yytext);
			      yylval.string[yyleng-1] = '\0';
			      current_input_column += yyleng;
			    }
			  do_string_escapes (yylval.string);
			  quote_is_transpose = 1;
			  cant_be_identifier = 1;
			  convert_spaces_to_comma = 1;
			  return TEXT;
			}

<MATRIX>{SN}*\]{S}*/==	{

// For this and the next two rules, we're looking at ']', and we
// need to know if the next token is '='.
//
// All this so we can handle the bogus syntax 
//
//   [x,y]                % an expression by itself
//   [x,y] = expression   % assignment to a list of identifiers
//   [x,y] == expression  % test for equality
//
// It would have been so much easier if the delimiters were simply
// different for the expression on the left hand side of the equals
// operator.

			  in_brace_or_paren.pop ();
			  braceflag--;
			  if (braceflag == 0)
			    {
			      if (!defining_func)
				promptflag++;
			      BEGIN 0;
			    }
			  fixup_column_count (yytext);
			  quote_is_transpose = 0;
			  cant_be_identifier = 0;
			  convert_spaces_to_comma = 1;
			  return ']';
			}

<MATRIX>{SN}*\]{S}*/=	{
			  in_brace_or_paren.pop ();
			  braceflag--;
			  if (braceflag == 0)
			    {
			      BEGIN 0;
			      if (!defining_func)
				promptflag++;
			    }
			  fixup_column_count (yytext);
			  quote_is_transpose = 0;
			  cant_be_identifier = 0;
			  convert_spaces_to_comma = 1;
			  if (maybe_screwed_again)
			    return SCREW_TWO;
			  else
			    return ']';
			}

<MATRIX>{SN}*\]{S}*	{
			  fixup_column_count (yytext);

			  in_brace_or_paren.pop ();
			  braceflag--;
			  if (braceflag == 0)
			    {
			      if (!defining_func)
				promptflag++;
			      BEGIN 0;
			    }
			  else
			    {
			      int c0 = yytext[yyleng-1];
			      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);

			      int c1 = yyinput ();
			      unput (c1);
			      int other_op = match_any (c1, ",;\n]");

			      if (! (postfix_un_op || bin_op || other_op)
				     && in_brace_or_paren.top ()
				     && convert_spaces_to_comma)
				{
				  unput (',');
				  return ']';
				}
			    }

			  quote_is_transpose = 1;
			  cant_be_identifier = 0;
			  convert_spaces_to_comma = 1;
			  return ']';
			}

<MATRIX>{S}*\,{S}*	{ RETURN (','); }

<MATRIX>{S}+		{
			  int bin_op = next_token_is_bin_op (1, yytext);
			  int postfix_un_op
			    = next_token_is_postfix_unary_op (1, yytext);

 			  if (! (postfix_un_op || bin_op)
			      && in_brace_or_paren.top ()
			      && convert_spaces_to_comma)
			    RETURN (',');
			}

<MATRIX>{SN}*\;{SN}*	|
<MATRIX>{N}{SN}*	{
			  fixup_column_count (yytext);
			  quote_is_transpose = 0;
			  cant_be_identifier = 0;
			  convert_spaces_to_comma = 1;
			  return ';';
			}

\]			{
			  if (! in_brace_or_paren.empty ())
			    in_brace_or_paren.pop ();

			  if (plotting)
			    {
			      in_plot_range = 0;
			      RETURN (CLOSE_BRACE);
			    }
			  else
			    RETURN (']');
			}

{D}+{EXPON}?{Im}	|
{D}+\.{D}*{EXPON}?{Im}	|
\.{D}+{EXPON}?{Im}	{
			  int nread = sscanf (yytext, "%lf", &(yylval.number));
			  assert (nread == 1);
			  quote_is_transpose = 1;
			  cant_be_identifier = 1;
			  convert_spaces_to_comma = 1;
			  current_input_column += yyleng;
			  DO_COMMA_INSERT_CHECK;
			  return IMAG_NUM;
			}

{D}+{EXPON}?		|
{D}+\.{D}*{EXPON}?	|
\.{D}+{EXPON}?		|
			{
			  int nread = sscanf (yytext, "%lf", &(yylval.number));
			  assert (nread == 1);
			  quote_is_transpose = 1;
			  cant_be_identifier = 1;
			  convert_spaces_to_comma = 1;
			  current_input_column += yyleng;
			  DO_COMMA_INSERT_CHECK;
			  return NUM;
			}

\[{S}*		{
		  in_brace_or_paren.push (1);
		  if (plotting)
		    {
		      in_plot_range = 1;
		      RETURN (OPEN_BRACE);
		    }

		  if (do_comma_insert)
		    {
		      yyless (0);
		      do_comma_insert = 0;
		      quote_is_transpose = 0;
		      cant_be_identifier = 0;
		      convert_spaces_to_comma = 1;
		      return (',');
		    }
		  else
		    {
		      mlnm.push (1);
		      braceflag++;
		      promptflag--;
		      BEGIN NEW_MATRIX;
		      RETURN ('[');
		    }
		}

{S}*		{ current_input_column += yyleng; }

{EL}{S}*\n	{

// Line continuation.

		  promptflag--;
		  current_input_column = 0;
		}

<<EOF>>		RETURN (END_OF_INPUT);

{IDENT}{S}*	{

// Truncate the token at the first space or tab but don't write
// directly on yytext.

		  static char *tok = (char *) NULL;
		  delete [] tok;
		  tok = strip_trailing_whitespace (yytext);

		  int kw_token = is_keyword (tok);
		  if (kw_token)
		    RETURN (kw_token);

		  if (plotting && cant_be_identifier)
		    {
		      int plot_option_kw = is_plot_keyword (tok);
		      if (plot_option_kw)
			{
			  quote_is_transpose = 0;
			  cant_be_identifier = 0;
			  convert_spaces_to_comma = 1;
			  current_input_column += yyleng;
			  return plot_option_kw;
			}
		    }

		  if (plotting && in_plot_style)
		    {
		      char *sty = plot_style_token (&tok[1]);
		      if (sty != (char *) NULL)
			{
			  yylval.string = strsave (sty);
			  if (in_plot_style)
			    {
			      in_plot_style = 0;
			      RETURN (STYLE);
			    }
			}
		    }

		  cant_be_identifier = 1;

// If we are looking at a text style function, set up to gobble its
// arguments.  These are also reserved words, but only because it
// would be very difficult to do anything intelligent with them if
// they were not reserved.

		  if (is_text_function_name (tok))
		    {
		      BEGIN TEXT_FCN;

		      if (strcmp (tok, "clear") == 0)
			return CLEAR;
		      else if (strcmp (tok, "help") == 0)
			BEGIN HELP_FCN;
		      else if (strcmp (tok, "set") == 0)
			doing_set = 1;
		    }

		  yylval.sym_rec = lookup_identifier (tok);

		  quote_is_transpose = 1;
		  current_input_column += yyleng;
		  DO_COMMA_INSERT_CHECK;

		  if (! in_brace_or_paren.empty ()
		      && in_brace_or_paren.top ())
		    {
		      int c0 = yytext[yyleng-1];
		      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);

		      int c1 = yyinput ();
		      unput (c1);
		      int other_op = match_any (c1, ",;\n](");

		      if (! (postfix_un_op || bin_op || other_op))
			unput (',');
		    }

		  convert_spaces_to_comma = 1;
		  return NAME;
		}

{IDENT}/{S}*=	{

// We've found an identifier followed by some space and an equals
// sign.  If we are working on a function definition and the previous
// token was `function', we have something like this
//
//    function x = y <list> end
//
// which is a function named y returning a variable named x.  The
// symbol y belongs in the global symbol table (nested function
// definitions are illegal) and the symbol x belongs in the 
// symbol table local to the function. 
//
// If we're not defining a function, this should function exactly like
// the case above.  I suppose it would be nice to avoid duplicating
// all the code, eh?

		  int kw_token = is_keyword (yytext);
		  if (kw_token)
		    RETURN (kw_token);

		  if (plotting && cant_be_identifier)
		    {
		      int plot_option_kw = is_plot_keyword (yytext);
		      if (plot_option_kw)
			{
			  quote_is_transpose = 0;
		  	  convert_spaces_to_comma = 1;
			  current_input_column += yyleng;
			  return plot_option_kw;
			}
		    }
		
		  cant_be_identifier = 1;

// If we are looking at a text style function, set up to gobble its
// arguments.  These are also reserved words, but only because it
// would be very difficult to do anything intelligent with them if
// they were not reserved.

		  if (is_text_function_name (yytext))
		    {
		      BEGIN TEXT_FCN;

		      if (strcmp (yytext, "clear") == 0)
			return CLEAR;
		      else if (strcmp (yytext, "help") == 0)
			BEGIN HELP_FCN;
		      else if (strcmp (yytext, "set") == 0)
			doing_set = 1;
		    }

		  if (defining_func && maybe_screwed)
		    curr_sym_tab = tmp_local_sym_tab;

		  yylval.sym_rec = lookup_identifier (yytext);

		  convert_spaces_to_comma = 1;
		  current_input_column += yyleng;
		  if (defining_func && maybe_screwed)
		    {
		      return SCREW;
		    }
		  else
		    {
		      quote_is_transpose = 1;
		      DO_COMMA_INSERT_CHECK;
		      return NAME;
		    }
		}

"\n"		{
		  quote_is_transpose = 0;
		  cant_be_identifier = 0;
		  current_input_column = 0;
		  convert_spaces_to_comma = 1;
		  return '\n';
		}

"'"		{
		  current_input_column++;
		  convert_spaces_to_comma = 1;

		  if (quote_is_transpose)
		    {
		      DO_COMMA_INSERT_CHECK;
		      return QUOTE;
		    }
		  else
		    BEGIN STRING;
		}

":"		{
		  if (plotting && (in_plot_range || in_plot_using))
		    RETURN (COLON);
		  else
		    BIN_OP_RETURN (':');
		}

\"		{ BEGIN DQSTRING; }
".**"		{ BIN_OP_RETURN (EPOW); }
".*"		{ BIN_OP_RETURN (EMUL); }
"./"		{ BIN_OP_RETURN (EDIV); }
".\\"		{ BIN_OP_RETURN (ELEFTDIV); }
".^"		{ BIN_OP_RETURN (EPOW); }
".'"		{ DO_COMMA_INSERT_CHECK; RETURN (TRANSPOSE); }
"++"		{ DO_COMMA_INSERT_CHECK; RETURN (PLUS_PLUS); }
"--"		{ DO_COMMA_INSERT_CHECK; RETURN (MINUS_MINUS); }
"<="		{ BIN_OP_RETURN (EXPR_LE); }
"=="		{ BIN_OP_RETURN (EXPR_EQ); }
"~="		{ BIN_OP_RETURN (EXPR_NE); }
"!="		{ BIN_OP_RETURN (EXPR_NE); }
"<>"		{ BIN_OP_RETURN (EXPR_NE); }
">="		{ BIN_OP_RETURN (EXPR_GE); }
"||"		{ BIN_OP_RETURN (EXPR_OR); }
"&&"		{ BIN_OP_RETURN (EXPR_AND); }
"|"		{ BIN_OP_RETURN (EXPR_OR); }
"&"		{ BIN_OP_RETURN (EXPR_AND); }
"!"		{ RETURN (EXPR_NOT); }
"~"		{ BIN_OP_RETURN (EXPR_NOT); }
"<"		{ BIN_OP_RETURN (EXPR_LT); }
">"		{ BIN_OP_RETURN (EXPR_GT); }
"+"		{ BIN_OP_RETURN ('+'); }
"-"		{ BIN_OP_RETURN ('-'); }
"**"		{ BIN_OP_RETURN (POW); }
"*"		{ BIN_OP_RETURN ('*'); }
"/"		{ BIN_OP_RETURN ('/'); }
"\\"		{ BIN_OP_RETURN (LEFTDIV); }
";"		{ RETURN (';'); }
","		{ RETURN (','); }
"^"		{ BIN_OP_RETURN (POW); }
"="		{ RETURN ('='); }
"("		{
		  in_brace_or_paren.push (0);
		  RETURN ('(');
		}
")"		{
		  if (! in_brace_or_paren.empty ())
		    in_brace_or_paren.pop ();
		  DO_COMMA_INSERT_CHECK;
		  current_input_column++;
		  quote_is_transpose = 1;
		  return ')';
		}

.		{

// We return everything else as single character tokens, which should
// eventually result in a parse error.

		  RETURN (yytext[0]);
		}

%%

/*
 * GAG.
 *
 * If we're reading a matrix and the next character is '[', make sure
 * that we insert a comma ahead of it.
 */
int
do_comma_insert_check (void)
{
  int tmp_len = yyleng;
  int c = yyinput ();
  do_comma_insert = (braceflag && c == '[');
  return tmp_len;
}

/*
 * Fix things up for errors or interrupts.
 */
void
reset_parser (void)
{
  BEGIN 0;
  promptflag = 1;
  doing_set = 0;
  braceflag = 0;
  maybe_screwed = 0;
  maybe_screwed_again = 0;
  looping = 0;
  iffing = 0;
  ml.clear ();
  mlnm.clear ();
  defining_func = 0;
  curr_sym_tab = top_level_sym_tab;
  get_input_from_eval_string = 0;
  quote_is_transpose = 0;
  current_input_column = 0;
  do_comma_insert = 0;
  plotting = 0;
  in_plot_range = 0;
  in_plot_using = 0;
  in_plot_style = 0;
  cant_be_identifier = 0;
  convert_spaces_to_comma = 1;
  beginning_of_function = 0;
  in_brace_or_paren.clear ();
  yyrestart (stdin);
}

static void
do_string_escapes (char *s)
{
  char *p1 = s;
  char *p2 = s;
  while (*p2 != '\0')
    {
      if (*p2 == '\\' && *(p2+1) != '\0')
	{
	  switch (*++p2)
	    {
	    case 'a':
	      *p1 = '\a';
	      break;
	    case 'b': // backspace
	      *p1 = '\b';
	      break;
	    case 'f': // formfeed
	      *p1 = '\f';
	      break;
	    case 'n': // newline
	      *p1 = '\n';
	      break;
	    case 'r': // carriage return
	      *p1 = '\r';
	      break;
	    case 't': // horizontal tab
	      *p1 = '\t';
	      break;
	    case 'v': // vertical tab
	      *p1 = '\v';
	      break;
	    case '\\': // backslash
	      *p1 = '\\';
	      break;
	    case '\'': // quote
	      *p1 = '\'';
	      break;
	    case '"': // double quote
	      *p1 = '"';
	      break;
	    default:
          warning ("unrecognized escape sequence `\\%c' -- converting to `%c'",
		   *p2, *p2);
	      *p1 = *p2;
	      break;
	    }
	}
      else if (*p2 == '\'' && *(p2+1) == '\'')
	{
	  *p1 = '\'';
	  p2++;
	}
      else
	{
	  *p1 = *p2;
	}

      p1++;
      p2++;
    }

  *p1 = '\0';
}

static void
fixup_column_count (char *s)
{
  char c;
  while ((c = *s++) != '\0')
    {
      if (c == '\n')
	  current_input_column = 0;
      else
	current_input_column++;
    }
}

#ifdef yywrap
#undef yywrap
#endif
int
yywrap (void)
{
  return 0;
}

/*
 * Tell us all what the current buffer is.
 */
YY_BUFFER_STATE
current_buffer (void)
{
  return YY_CURRENT_BUFFER;
}

/*
 * Create a new buffer.
 */
YY_BUFFER_STATE
create_buffer (FILE *f)
{
  return yy_create_buffer (f, YY_BUF_SIZE);
}

/*
 * Start reading a new buffer.
 */
void
switch_to_buffer (YY_BUFFER_STATE buf)
{
  yy_switch_to_buffer (buf);
}

/*
 * Delete a buffer.
 */
void
delete_buffer (YY_BUFFER_STATE buf)
{
  yy_delete_buffer (buf);
}

/*
 * Restore a buffer (for unwind-prot).
 */
void
restore_input_buffer (void *buf)
{
  switch_to_buffer ((YY_BUFFER_STATE) buf);
}

/*
 * Delete a buffer (for unwind-prot).
 */
void
delete_input_buffer (void *buf)
{
  delete_buffer ((YY_BUFFER_STATE) buf);
}

static char *plot_styles[] = 
  {
    "dots",
    "dots",
    "errorbars",
    "impulses",
    "lines",
    "linespoints",
    "points",
    (char *) NULL,
  };

static char *
plot_style_token (char *s)
{
  char **tmp = plot_styles;
  while (*tmp != (char *) NULL)
    {
      if (almost_match (*tmp, s))
	return *tmp;

      tmp++;
    }

  return (char *) NULL;
}

static int
is_plot_keyword (char *s)
{
  if (almost_match ("title", s))
    return TITLE;
  else if (almost_match ("using", s))
    { in_plot_using = 1; return USING; }
  else if (almost_match ("with", s))
    { in_plot_style = 1; return WITH; }
  else
    return 0;
}

/*
 * Handle keywords.  Could probably be more efficient...
 */
static int
is_keyword (char *s)
{
  if (plotting && in_plot_style)
    {
      char *sty = plot_style_token (s);
      if (sty != (char *) NULL)
	{
	  in_plot_style = 0;
	  yylval.string = strsave (sty);
	  return STYLE;
	}
    }

  int end_found = 0;
  if (strcmp ("break", s) == 0)
    return BREAK;
  else if (strcmp ("continue", s) == 0)
    return CONTINUE;
  else if (strcmp ("else", s) == 0)
    { return ELSE; }
  else if (strcmp ("elseif", s) == 0)
    { return ELSEIF; }
  else if (strcmp ("end", s) == 0)
    { end_found = 1; yylval.ettype = simple_end; }
  else if (strcmp ("endfor", s) == 0)
    { end_found = 1; yylval.ettype = for_end; }
  else if (strcmp ("endfunction", s) == 0)
    { end_found = 1; yylval.ettype = function_end; }
  else if (strcmp ("endif", s) == 0)
    { end_found = 1; yylval.ettype = if_end; }
  else if (strcmp ("endwhile", s) == 0)
    { end_found = 1; yylval.ettype = while_end; }
  else if (strcmp ("for", s) == 0)
    { promptflag--; looping++; return FOR; }
  else if (strcmp ("function", s) == 0)
    {
      if (defining_func)
	{
	  error ("sorry, nested functions are a no-no...");
	  jump_to_top_level ();
	}
      else
	{
	  tmp_local_sym_tab = new symbol_table ();
	  curr_sym_tab = tmp_local_sym_tab;
	  defining_func = 1;
	  promptflag--;
	  beginning_of_function = 1;
	  help_buf[0] = '\0';
	  return FCN;
	}
    }
  else if (strcmp ("global", s) == 0)
    return GLOBAL;
  else if (strcmp ("gplot", s) == 0)
    { plotting = 1; yylval.pttype = two_dee; return PLOT; }
  else if (strcmp ("gsplot", s) == 0)
    { plotting = 1; yylval.pttype = three_dee; return PLOT; }
  else if (strcmp ("if", s) == 0)
    { iffing++; promptflag--; return IF; }
  else if (strcmp ("return", s) == 0)
    return FUNC_RET;
  else if (strcmp ("while", s) == 0)
    { promptflag--; looping++; return WHILE; }

  if (end_found)
    {
      if (!defining_func && !looping)
	promptflag++;
      return END;
    }

  return 0;
}

static symbol_record *
lookup_identifier (char *name)
{
  symbol_record *gsr = global_sym_tab->lookup (name, 0, 0);

  if (curr_sym_tab == top_level_sym_tab && gsr != (symbol_record *) NULL)
    return gsr;

  return curr_sym_tab->lookup (name, 1, 0);
}

static void
grab_help_text (void)
{
  int max_len = HELP_BUF_LENGTH - 1;

  int in_comment = 1;
  int len = 0;
  int c;

  while ((c = yyinput ()) != EOF)
    {
      if (in_comment)
	{
	  help_buf[len++] = c;
	  if (c == '\n')
	    in_comment = 0;
	}
      else
	{
	  switch (c)
	    {
	    case '%':
	    case '#':
	      in_comment = 1;
	    case ' ':
	    case '\t':
	      break;
	    default:
	      goto done;
	    }
	}

      if (len > max_len)
	{
	  message ("grab_help_text",
		   "buffer overflow after caching %d characters",
		   max_len);

	  goto done;
	}
    }

 done:

// Make sure there's an end of line so yylex sees an end to the
// comment immediately.

  yyunput (c, yytext);
  if (c != '\n')
    yyunput ('\n', yytext);

  help_buf[len] =  '\0';
}

static int
match_any (char c, char *s)
{
  char tmp;
  while ((tmp = *s++) != '\0')
    {
      if (c == tmp)
	return 1;
    }
  return 0;
}

static int
looks_like_bin_op (int spc_prev, int spc_next)
{
  return ((spc_prev && spc_next) || ! (spc_prev || spc_next));
}

static int
next_char_is_space (void)
{
  int c = yyinput ();
  yyunput (c, yytext);
  return (c == ' ' || c == '\t');
}

static int
next_token_is_postfix_unary_op (int spc_prev, char *yytext)
{
  int un_op = 0;

  int c0 = yyinput ();
  int c1 = yyinput ();

  yyunput (c1, yytext);
  yyunput (c0, yytext);

  int transpose = (c0 == '.' && c1 == '\'');
  int hermitian = (c0 == '\'');

  un_op = (transpose || (hermitian && ! spc_prev));

  return un_op;
}

static int
next_token_is_bin_op (int spc_prev, char *yytext)
{
  int bin_op = 0;
  int spc_next = 0;

  int c0 = yyinput ();
  int c1 = yyinput ();

  switch (c0)
    {
    case '+':  case '-':  case '/':
    case ':':  case '\\': case '^':
      spc_next = (c1 == ' ' || c1 == '\t');
      break;

    case '&':
      if (c1 == '&')
	spc_next = next_char_is_space ();
      else
	spc_next = (c1 == ' ' || c1 == '\t');
      break;

    case '*':
      if (c1 == '*')
	spc_next = next_char_is_space ();
      else
	spc_next = (c1 == ' ' || c1 == '\t');
      break;
	
    case '|':
      if (c1 == '|')
	spc_next = next_char_is_space ();
      else
	spc_next = (c1 == ' ' || c1 == '\t');
      break;

    case '<':
      if (c1 == '=' || c1 == '>')
	spc_next = next_char_is_space ();
      else
	spc_next = (c1 == ' ' || c1 == '\t');
      break;

    case '>':
      if (c1 == '=')
	spc_next = next_char_is_space ();
      else
	spc_next = (c1 == ' ' || c1 == '\t');
      break;

    case '~':  case '!':  case '=':
      if (c1 == '=')
	spc_next = next_char_is_space ();
      else
	goto done;
      break;

    case '.':
      if (c1 == '*')
	{
	  int c2 = yyinput ();
	  if (c2 == '*')
	    spc_next = next_char_is_space ();
	  else
	    spc_next = (c2 == ' ' || c2 == '\t');
	  yyunput (c2, yytext);
	}
      else if (c1 == '/' || c1 == '\\' || c1 == '^')
	spc_next = next_char_is_space ();
      else
	goto done;
      break;

    default:
      goto done;
    }

  bin_op = looks_like_bin_op (spc_prev, spc_next);

 done:
  yyunput (c1, yytext);
  yyunput (c0, yytext);

  return bin_op;
}

char *
strip_trailing_whitespace (char *s)
{
  char *retval = strsave (s);

  char *t = strchr (retval, ' ');
  if (t != (char *) NULL)
    *t = '\0';

  t = strchr (retval, '\t');
  if (t != (char *) NULL)
    *t = '\0';

  return retval;
}

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...

  int in_comment = 0;
  int lineno = input_line_number;
  int c;
  while ((c = yyinput ()) != EOF)
    {
      switch (c)
	{
	case ' ':
	case '\t':
	case ';':
	case ',':
	  break;
	case '\n':
	  if (in_comment)
	    in_comment = 0;
	  break;
	case '%':
	case '#':
	  in_comment = 1;
	  break;
	default:
	  if (in_comment)
	    break;
	  else
	    {
	      warning ("ignoring trailing garbage after end of function\n\
         near line %d of file `%s.m'", lineno, curr_m_file_name);
	      
	      yyunput ('\n', yytext);
	      return;
	    }
	}
    }
  yyunput ('\n', yytext);
}

/* Maybe someday...

"+="		return ADD_EQ;
"-="		return SUB_EQ;
"*="		return MUL_EQ;
"/="		return DIV_EQ;
"\\="		return LEFTDIV_EQ;
".+="		return ADD_EQ;
".-="		return SUB_EQ;
".*="		return EMUL_EQ;
"./="		return EDIV_EQ;
".\\="		return ELEFTDIV_EQ;

*/