/* GLIB - Library of useful routines for C programming

 * Copyright (C) 1995-1997  Peter Mattis, Spencer Kimball and Josh MacDonald

 *

 * GScanner: Flexible lexical scanner for general purpose.

 * Copyright (C) 1997, 1998 Tim Janik

 * Portions copyright (c) 2006-2009 Nokia Corporation.  All rights reserved.

 *

 * 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 of the License, or (at your option) any later version.

 *

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

 */

/*

 * Modified by the GLib Team and others 1997-2000.  See the AUTHORS

 * file for a list of people on the GLib Team.  See the ChangeLog

 * files for a list of changes.  These files are distributed with

 * GLib at ftp://ftp.gtk.org/pub/gtk/. 

 */

/* 

 * MT safe

 */

#include "config.h"

#include	<errno.h>

#include	<stdlib.h>

#include	<stdarg.h>

#include	<string.h>

#include	<stdio.h>

#ifdef HAVE_UNISTD_H

#include	<unistd.h>

#endif

#include	"glib.h"

#include	"gprintfint.h"

#include        "galias.h"

#ifdef G_OS_WIN32

#include	<io.h>		/* For _read() */

#endif

/* --- defines --- */

#define	to_lower(c)				( \

	(guchar) (							\

	  ( (((guchar)(c))>='A' && ((guchar)(c))<='Z') * ('a'-'A') ) |	\

	  ( (((guchar)(c))>=192 && ((guchar)(c))<=214) * (224-192) ) |	\

	  ( (((guchar)(c))>=216 && ((guchar)(c))<=222) * (248-216) ) |	\

	  ((guchar)(c))							\

	)								\

)

#define	READ_BUFFER_SIZE	(4000)

/* --- typedefs --- */

typedef	struct	_GScannerKey	GScannerKey;

struct	_GScannerKey

{

  guint		 scope_id;

  gchar		*symbol;

  gpointer	 value;

};

/* --- variables --- */

static const GScannerConfig g_scanner_config_template =

{

  (

   " \t\r\n"

   )			/* cset_skip_characters */,

  (

   G_CSET_a_2_z

   "_"

   G_CSET_A_2_Z

   )			/* cset_identifier_first */,

  (

   G_CSET_a_2_z

   "_"

   G_CSET_A_2_Z

   G_CSET_DIGITS

   G_CSET_LATINS

   G_CSET_LATINC

   )			/* cset_identifier_nth */,

  ( "#\n" )		/* cpair_comment_single */,

  FALSE			/* case_sensitive */,

  TRUE			/* skip_comment_multi */,

  TRUE			/* skip_comment_single */,

  TRUE			/* scan_comment_multi */,

  TRUE			/* scan_identifier */,

  FALSE			/* scan_identifier_1char */,

  FALSE			/* scan_identifier_NULL */,

  TRUE			/* scan_symbols */,

  FALSE			/* scan_binary */,

  TRUE			/* scan_octal */,

  TRUE			/* scan_float */,

  TRUE			/* scan_hex */,

  FALSE			/* scan_hex_dollar */,

  TRUE			/* scan_string_sq */,

  TRUE			/* scan_string_dq */,

  TRUE			/* numbers_2_int */,

  FALSE			/* int_2_float */,

  FALSE			/* identifier_2_string */,

  TRUE			/* char_2_token */,

  FALSE			/* symbol_2_token */,

  FALSE			/* scope_0_fallback */,

  FALSE			/* store_int64 */,

};

/* --- prototypes --- */

static inline

GScannerKey*	g_scanner_lookup_internal (GScanner	*scanner,

					   guint	 scope_id,

					   const gchar	*symbol);

static gboolean	g_scanner_key_equal	  (gconstpointer v1,

					   gconstpointer v2);

static guint	g_scanner_key_hash	  (gconstpointer v);

static void	g_scanner_get_token_ll	  (GScanner	*scanner,

					   GTokenType	*token_p,

					   GTokenValue	*value_p,

					   guint	*line_p,

					   guint	*position_p);

static void	g_scanner_get_token_i	  (GScanner	*scanner,

					   GTokenType	*token_p,

					   GTokenValue	*value_p,

					   guint	*line_p,

					   guint	*position_p);

static guchar	g_scanner_peek_next_char  (GScanner	*scanner);

static guchar	g_scanner_get_char	  (GScanner	*scanner,

					   guint	*line_p,

					   guint	*position_p);

static void	g_scanner_msg_handler	  (GScanner	*scanner,

					   gchar	*message,

					   gboolean	 is_error);

/* --- functions --- */

static inline gint

g_scanner_char_2_num (guchar	c,

		      guchar	base)

{

  if (c >= '0' && c <= '9')

    c -= '0';

  else if (c >= 'A' && c <= 'Z')

    c -= 'A' - 10;

  else if (c >= 'a' && c <= 'z')

    c -= 'a' - 10;

  else

    return -1;

  if (c < base)

    return c;

  return -1;

}

EXPORT_C GScanner*

g_scanner_new (const GScannerConfig *config_templ)

{

  GScanner *scanner;

  if (!config_templ)

    config_templ = &g_scanner_config_template;

  scanner = g_new0 (GScanner, 1);

  scanner->user_data = NULL;

  scanner->max_parse_errors = 1;

  scanner->parse_errors	= 0;

  scanner->input_name = NULL;

  g_datalist_init (&scanner->qdata);

  scanner->config = g_new0 (GScannerConfig, 1);

  scanner->config->case_sensitive	 = config_templ->case_sensitive;

  scanner->config->cset_skip_characters	 = config_templ->cset_skip_characters;

  if (!scanner->config->cset_skip_characters)

    scanner->config->cset_skip_characters = "";

  scanner->config->cset_identifier_first = config_templ->cset_identifier_first;

  scanner->config->cset_identifier_nth	 = config_templ->cset_identifier_nth;

  scanner->config->cpair_comment_single	 = config_templ->cpair_comment_single;

  scanner->config->skip_comment_multi	 = config_templ->skip_comment_multi;

  scanner->config->skip_comment_single	 = config_templ->skip_comment_single;

  scanner->config->scan_comment_multi	 = config_templ->scan_comment_multi;

  scanner->config->scan_identifier	 = config_templ->scan_identifier;

  scanner->config->scan_identifier_1char = config_templ->scan_identifier_1char;

  scanner->config->scan_identifier_NULL	 = config_templ->scan_identifier_NULL;

  scanner->config->scan_symbols		 = config_templ->scan_symbols;

  scanner->config->scan_binary		 = config_templ->scan_binary;

  scanner->config->scan_octal		 = config_templ->scan_octal;

  scanner->config->scan_float		 = config_templ->scan_float;

  scanner->config->scan_hex		 = config_templ->scan_hex;

  scanner->config->scan_hex_dollar	 = config_templ->scan_hex_dollar;

  scanner->config->scan_string_sq	 = config_templ->scan_string_sq;

  scanner->config->scan_string_dq	 = config_templ->scan_string_dq;

  scanner->config->numbers_2_int	 = config_templ->numbers_2_int;

  scanner->config->int_2_float		 = config_templ->int_2_float;

  scanner->config->identifier_2_string	 = config_templ->identifier_2_string;

  scanner->config->char_2_token		 = config_templ->char_2_token;

  scanner->config->symbol_2_token	 = config_templ->symbol_2_token;

  scanner->config->scope_0_fallback	 = config_templ->scope_0_fallback;

  scanner->config->store_int64		 = config_templ->store_int64;

  scanner->token = G_TOKEN_NONE;

  scanner->value.v_int64 = 0;

  scanner->line = 1;

  scanner->position = 0;

  scanner->next_token = G_TOKEN_NONE;

  scanner->next_value.v_int64 = 0;

  scanner->next_line = 1;

  scanner->next_position = 0;

  scanner->symbol_table = g_hash_table_new (g_scanner_key_hash, g_scanner_key_equal);

  scanner->input_fd = -1;

  scanner->text = NULL;

  scanner->text_end = NULL;

  scanner->buffer = NULL;

  scanner->scope_id = 0;

  scanner->msg_handler = g_scanner_msg_handler;

  return scanner;

}

static inline void

g_scanner_free_value (GTokenType     *token_p,

		      GTokenValue     *value_p)

{

  switch (*token_p)

    {

    case G_TOKEN_STRING:

    case G_TOKEN_IDENTIFIER:

    case G_TOKEN_IDENTIFIER_NULL:

    case G_TOKEN_COMMENT_SINGLE:

    case G_TOKEN_COMMENT_MULTI:

      g_free (value_p->v_string);

      break;

    default:

      break;

    }

  *token_p = G_TOKEN_NONE;

}

static void

g_scanner_destroy_symbol_table_entry (gpointer _key,

				      gpointer _value,

				      gpointer _data)

{

  GScannerKey *key = _key;

  g_free (key->symbol);

  g_free (key);

}

EXPORT_C void

g_scanner_destroy (GScanner	*scanner)

{

  g_return_if_fail (scanner != NULL);

  g_datalist_clear (&scanner->qdata);

  g_hash_table_foreach (scanner->symbol_table, 

			g_scanner_destroy_symbol_table_entry, NULL);

  g_hash_table_destroy (scanner->symbol_table);

  g_scanner_free_value (&scanner->token, &scanner->value);

  g_scanner_free_value (&scanner->next_token, &scanner->next_value);

  g_free (scanner->config);

  g_free (scanner->buffer);

  g_free (scanner);

}

static void

g_scanner_msg_handler (GScanner		*scanner,

		       gchar		*message,

		       gboolean		is_error)

{

  g_return_if_fail (scanner != NULL);

  _g_fprintf (stderr, "%s:%d: ",

	      scanner->input_name ? scanner->input_name : "<memory>",

	      scanner->line);

  if (is_error)

    _g_fprintf (stderr, "error: ");

  _g_fprintf (stderr, "%s\n", message);

}

EXPORT_C void

g_scanner_error (GScanner	*scanner,

		 const gchar	*format,

		 ...)

{

  g_return_if_fail (scanner != NULL);

  g_return_if_fail (format != NULL);

  scanner->parse_errors++;

  if (scanner->msg_handler)

    {

      va_list args;

      gchar *string;

      va_start (args, format);

      string = g_strdup_vprintf (format, args);

      va_end (args);

      scanner->msg_handler (scanner, string, TRUE);

      g_free (string);

    }

}

EXPORT_C void

g_scanner_warn (GScanner       *scanner,

		const gchar    *format,

		...)

{

  g_return_if_fail (scanner != NULL);

  g_return_if_fail (format != NULL);

  if (scanner->msg_handler)

    {

      va_list args;

      gchar *string;

      va_start (args, format);

      string = g_strdup_vprintf (format, args);

      va_end (args);

      scanner->msg_handler (scanner, string, FALSE);

      g_free (string);

    }

}

static gboolean

g_scanner_key_equal (gconstpointer v1,

		     gconstpointer v2)

{

  const GScannerKey *key1 = v1;

  const GScannerKey *key2 = v2;

  return (key1->scope_id == key2->scope_id) && (strcmp (key1->symbol, key2->symbol) == 0);

}

static guint

g_scanner_key_hash (gconstpointer v)

{

  const GScannerKey *key = v;

  gchar *c;

  guint h;

  h = key->scope_id;

  for (c = key->symbol; *c; c++)

    h = (h << 5) - h + *c;

  return h;

}

static inline GScannerKey*

g_scanner_lookup_internal (GScanner	*scanner,

			   guint	 scope_id,

			   const gchar	*symbol)

{

  GScannerKey	*key_p;

  GScannerKey key;

  key.scope_id = scope_id;

  if (!scanner->config->case_sensitive)

    {

      gchar *d;

      const gchar *c;

      key.symbol = g_new (gchar, strlen (symbol) + 1);

      for (d = key.symbol, c = symbol; *c; c++, d++)

	*d = to_lower (*c);

      *d = 0;

      key_p = g_hash_table_lookup (scanner->symbol_table, &key);

      g_free (key.symbol);

    }

  else

    {

      key.symbol = (gchar*) symbol;

      key_p = g_hash_table_lookup (scanner->symbol_table, &key);

    }

  return key_p;

}

EXPORT_C void

g_scanner_scope_add_symbol (GScanner	*scanner,

			    guint	 scope_id,

			    const gchar	*symbol,

			    gpointer	 value)

{

  GScannerKey	*key;

  g_return_if_fail (scanner != NULL);

  g_return_if_fail (symbol != NULL);

  key = g_scanner_lookup_internal (scanner, scope_id, symbol);

  if (!key)

    {

      key = g_new (GScannerKey, 1);

      key->scope_id = scope_id;

      key->symbol = g_strdup (symbol);

      key->value = value;

      if (!scanner->config->case_sensitive)

	{

	  gchar *c;

	  c = key->symbol;

	  while (*c != 0)

	    {

	      *c = to_lower (*c);

	      c++;

	    }

	}

      g_hash_table_insert (scanner->symbol_table, key, key);

    }

  else

    key->value = value;

}

EXPORT_C void

g_scanner_scope_remove_symbol (GScanner	   *scanner,

			       guint	    scope_id,

			       const gchar *symbol)

{

  GScannerKey	*key;

  g_return_if_fail (scanner != NULL);

  g_return_if_fail (symbol != NULL);

  key = g_scanner_lookup_internal (scanner, scope_id, symbol);

  if (key)

    {

      g_hash_table_remove (scanner->symbol_table, key);

      g_free (key->symbol);

      g_free (key);

    }

}

EXPORT_C gpointer

g_scanner_lookup_symbol (GScanner	*scanner,

			 const gchar	*symbol)

{

  GScannerKey	*key;

  guint scope_id;

  g_return_val_if_fail (scanner != NULL, NULL);

  if (!symbol)

    return NULL;

  scope_id = scanner->scope_id;

  key = g_scanner_lookup_internal (scanner, scope_id, symbol);

  if (!key && scope_id && scanner->config->scope_0_fallback)

    key = g_scanner_lookup_internal (scanner, 0, symbol);

  if (key)

    return key->value;

  else

    return NULL;

}

EXPORT_C gpointer

g_scanner_scope_lookup_symbol (GScanner	      *scanner,

			       guint	       scope_id,

			       const gchar    *symbol)

{

  GScannerKey	*key;

  g_return_val_if_fail (scanner != NULL, NULL);

  if (!symbol)

    return NULL;

  key = g_scanner_lookup_internal (scanner, scope_id, symbol);

  if (key)

    return key->value;

  else

    return NULL;

}

EXPORT_C guint

g_scanner_set_scope (GScanner	    *scanner,

		     guint	     scope_id)

{

  guint old_scope_id;

  g_return_val_if_fail (scanner != NULL, 0);

  old_scope_id = scanner->scope_id;

  scanner->scope_id = scope_id;

  return old_scope_id;

}

static void

g_scanner_foreach_internal (gpointer  _key,

			    gpointer  _value,

			    gpointer  _user_data)

{

  GScannerKey *key;

  gpointer *d;

  GHFunc func;

  gpointer user_data;