/*
 * The Spar Library - modular math parser
 * Copyright (C) 2000,2001 Davide Angelocola <davide178@inwind.it>
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License.
 *
 * This library 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
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA  02111-1307, USA.
 *
 */
#include <setjmp.h>
#include <string.h>

#include <spar/sl_parser.h>
#include <spar/sl_error.h>
#include <spar/sl_io.h>
#include <spar/sl_math.h>
#include <spar/sl_math_library.h>
#include <spar/sl_util.h>

/*
 *  The Token Type
 */
typedef enum
{
  TOKEN_TYPE_ALPHA,		/* token is a function or variable name */
  TOKEN_TYPE_DELIM,		/* token is a delimitator               */
  TOKEN_TYPE_NUMBER		/* token is a number                    */
}
token_type_t;

/*
 *  Token infos
 *  	type specifys the token type
 *  	token is a identifier (sl_conf.h)
 */
token_type_t type;
sl_identifier (token);

/*
 *  Expression to evaluate
 */
char *expression;

/*
 *  Used with throw_error
 *  return to the level0 function is any error occurs
 */
extern jmp_buf jb;

/* 
 *  Internal functions 
 *  declared as 'static'
 */
static void next_token (void);
static bool __is_a_identifier (const char[]);
static int level0 (const char[], double *, bool *);
static bool level1 (double *);
static void level2 (double *);
static void level3 (double *);
static void level4 (double *);
static void level5 (double *);
static void level6 (double *);

sl_error
sl_parser_evaluate (const char *str)
{
  int rc;
  bool assign;
  double result;

  memset (token, 0, SL_IDENTIFIER_LENGHT);
  rc = level0 (str, &result, &assign);

  switch (rc)
    {
    case SL_SUCCESS:
      {
	switch (assign)
	  {
	  case true:
	    break;

	  case false:
	    {
	      sl_write_value_with_label (str, result);
	      break;
	    }

	  default:
	    sl_writeln ("%s: %s: %u: bug: assign undefined", __FILE__,
			__FUNCTION__, __LINE__);

	    break;
	  }

	return SL_SUCCESS;
      }

    case SL_ERROR:
      return SL_ERROR;

    default:
      sl_writeln ("%s: %s: %u: bug: rc undefined", __FILE__, __FUNCTION__,
		  __LINE__);
    }
  return SL_ERROR;
}

double
sl_parser_evaluate_to_double (const char *str)
{
  bool assign;
  double result;

  memset (token, 0, SL_IDENTIFIER_LENGHT);
  (void) level0 (str, &result, &assign);

  return result;
}

static int
level0 (const char ete[], double *result, bool * assg)
{
  /* 
   *  if any parser error occurcs jump here 
   *  using the function throw_error with
   *  SL_ERROR_PARSER
   */
  if (setjmp (jb))
    return SL_ERROR;

  expression = (char *) ete;
  *result = ZERO;

  next_token ();

  if ((strlen (token)) > 0)
    *assg = level1 (result);
/*
 *  No errors, the string is correct
 */
  return SL_SUCCESS;
}

static bool
level1 (double *r)
{
  sl_identifier (t);

  if (type == TOKEN_TYPE_ALPHA)
    if (*expression == '=')
      {
	strcpy (t, token);
	next_token ();
	next_token ();
	level2 (r);

	if (sl_variable_set (t, *r) == SL_SUCCESS)
	  sl_writeln ("Variable '%s' added.", t);

	return true;
      }

  level2 (r);

  return false;
}


static void
level2 (double *r)
{
  double t = ZERO;
  char o;

  level3 (r);

  while ((o = *token) == '+' || o == '-')
    {
      next_token ();
      level3 (&t);

      switch (o)
	{
	case '+':
	  *r = *r + t;
	  break;

	case '-':
	  *r = *r - t;
	  break;
	}
    }

  return;
}

static void
level3 (double *r)
{
  double t = ZERO;
  char o;

  level4 (r);

  while ((o = *token) == '*' || o == '/' || o == '%')
    {
      next_token ();
      level4 (&t);

      switch (o)
	{
	case '*':
	  *r = *r * t;
	  break;

	case '/':
	  if (SL_IS_ZERO (t))
	    sl_error_throw (SL_ERROR_CLASS_PARSER, SL_ERROR_DIVZERO, "'%s'",
			    token);

	  *r = *r / t;
	  break;

	case '%':
	  {
	    if (SL_IS_ZERO (t))
	      sl_error_throw (SL_ERROR_CLASS_PARSER, SL_ERROR_DIVZERO, "'%s'",
			      token);

	    *r = sl_mod (*r, t);

	    break;
	  }
	}
    }

  return;
}


static void
level4 (double *r)
{
  double t = ZERO;

  level5 (r);

  if (*token == '^')
    {
      next_token ();
      level5 (&t);
      *r = sl_pow (*r, t);
    }

  return;
}


static void
level5 (double *r)
{
  char o = '0';

  if (*token == '+' || *token == '-')
    {
      o = *token;
      next_token ();
    }

  level6 (r);

  if (o == '-')
    *r = *r * (-1);

  return;
}


static void
level6 (double *r)
{
  if (*token == '(')
    {
      next_token ();

      if (*token == ')')
	sl_error_throw (SL_ERROR_CLASS_PARSER, SL_ERROR_NOARG, "'%s'", token);

      level1 (r);

      if (*token != ')')
	sl_error_throw (SL_ERROR_CLASS_PARSER, SL_ERROR_UNBALAN, "'%s'",
			token);

      next_token ();
    }
  else
    {
      if (type == TOKEN_TYPE_NUMBER)
	{
	  sl_string_to_double (token, r);
	  next_token ();
	}
      else if (type == TOKEN_TYPE_ALPHA)
	{
	  if (*expression == '(')
	    {
	      int fnc_code = sl_function_check (token);

	      if (fnc_code != SL_SYMBOL_NOT_FOUND)
		{
		  sl_function_args_t argc = 0;
		  double argv[3];
		  const char *name = sl_function_get_name (fnc_code);

		  next_token ();

		  do
		    {
		      next_token ();

		      switch (*token)
			{
			case ')':
			  argv[argc] = 0;
			  break;

			case ',':
			  argv[argc] = 0;
			  break;

			default:
			  break;
			}

		      if (*token == ')' || *token == ',')
			argv[argc] = 0;

		      level1 (&argv[argc]);
		      argc += 1;
		    }
		  while (argc < 3 && *token == ',');

		  while ((*token) != ')')
		    {
		      if (*token == '(')
			sl_error_throw (SL_ERROR_CLASS_PARSER,
					SL_ERROR_UNBALAN, "'%s'", token);
		      next_token ();

		      if (*token != ')')
			sl_error_throw (SL_ERROR_CLASS_PARSER,
					SL_ERROR_UNBALAN, "'%s'", token);
		    }

		  if (argc != (sl_function_get_argc (fnc_code)))
		    sl_error_throw (SL_ERROR_CLASS_PARSER, SL_ERROR_NUMARGS,
				    "'%s'", name);

		  *r = sl_function_run (name, argv);

		  next_token ();
		  return;
		}
	      else
		sl_error_throw (SL_ERROR_CLASS_PARSER, SL_ERROR_BADFUNC,
				"'%s'", token);
	    }
	  else
	    {
	      double t;

	      if (sl_variable_get (token, &t) == SL_SUCCESS)
		goto success;
	      else if (sl_constant_get (token, &t) == SL_SUCCESS)
		goto success;
	      else
		goto error;

	    error:
	      sl_error_throw (SL_ERROR_CLASS_PARSER, SL_ERROR_UNKNOWN,
			      "'%s'", token);

	    success:
	      *r = t;
	      next_token ();

	      return;
	    }
	}
      else
	sl_error_throw (SL_ERROR_CLASS_PARSER, SL_ERROR_SYNTAX, "'%s'",
			token);
    }

  return;
}


static void
next_token (void)
{
  char *t;
  register int iden_len = 0;

  type = 0;
  t = token;

  while (sl_isblank (*expression) == 1)
    expression++;

  if (sl_isdelim (*expression) == 1)
    {
      type = TOKEN_TYPE_DELIM;

      *t++ = *expression++;
    }
  else if (sl_isnumber (*expression))
    {
      type = TOKEN_TYPE_NUMBER;

      while (sl_isnumber (*expression) || (*expression == 'E') || (*expression == 'e') || (*expression == '-') || (*expression == '+'))
	{
	  *t++ = *expression++;

//	  if (sl_isnumber (*expression))
//	    sl_error_throw (SL_ERROR_CLASS_PARSER, SL_ERROR_SYNTAX, expression);
	}
    }
  else if (sl_isalpha (*expression))
    {
      type = TOKEN_TYPE_ALPHA;

      while (sl_isalpha (*expression) == 1 || sl_isnumber (*expression) == 1)
	{
	  iden_len += 1;

	  if (iden_len >= SL_IDENTIFIER_LENGHT)
	    sl_error_throw (SL_ERROR_CLASS_PARSER, SL_ERROR_IDENF, "'%s'",
			    token);

	  *t++ = *expression++;
	}
      if (__is_a_identifier (t) == 0)
	sl_error_throw (SL_ERROR_CLASS_PARSER, SL_ERROR_SYNTAX, "'%s'", t);
    }
  else if (*expression != '\0')
    {
      *t++ = *expression++;
      *t = '\0';
      sl_error_throw (SL_ERROR_CLASS_PARSER, SL_ERROR_SYNTAX, "'%s'", token);
    }

  *t = '\0';

  while (sl_isblank (*expression) == 1)
    expression++;

  return;
}

bool
__is_a_identifier (const char iden[])
{
  return !(sl_isnumber (iden[0]));
}