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

 *

 * 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 "gscanner.h"

#include "gprintfint.h"

#include "gstrfuncs.h"

#include "gstring.h"

#include "gtestutils.h"

#ifdef G_OS_WIN32

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

#endif

/**

 * SECTION:scanner

 * @title: Lexical Scanner

 * @short_description: a general purpose lexical scanner

 *

 * The #GScanner and its associated functions provide a

 * general purpose lexical scanner.

 */

/**

 * GScannerMsgFunc:

 * @scanner: a #GScanner

 * @message: the message

 * @error: %TRUE if the message signals an error,

 *     %FALSE if it signals a warning.

 *

 * Specifies the type of the message handler function.

 */

/**

 * G_CSET_a_2_z:

 *

 * The set of lowercase ASCII alphabet characters.

 * Used for specifying valid identifier characters

 * in #GScannerConfig.

 */

/**

 * G_CSET_A_2_Z:

 *

 * The set of uppercase ASCII alphabet characters.

 * Used for specifying valid identifier characters

 * in #GScannerConfig.

 */

/**

 * G_CSET_LATINC:

 *

 * The set of uppercase ISO 8859-1 alphabet characters

 * which are not ASCII characters.

 * Used for specifying valid identifier characters

 * in #GScannerConfig.

 */

/**

 * G_CSET_LATINS:

 *

 * The set of lowercase ISO 8859-1 alphabet characters

 * which are not ASCII characters.

 * Used for specifying valid identifier characters

 * in #GScannerConfig.

 */

/**

 * GTokenType:

 * @G_TOKEN_EOF: the end of the file

 * @G_TOKEN_LEFT_PAREN: a '(' character

 * @G_TOKEN_LEFT_CURLY: a '{' character

 * @G_TOKEN_LEFT_BRACE: a '[' character

 * @G_TOKEN_RIGHT_CURLY: a '}' character

 * @G_TOKEN_RIGHT_PAREN: a ')' character

 * @G_TOKEN_RIGHT_BRACE: a ']' character

 * @G_TOKEN_EQUAL_SIGN: a '=' character

 * @G_TOKEN_COMMA: a ',' character

 * @G_TOKEN_NONE: not a token

 * @G_TOKEN_ERROR: an error occurred

 * @G_TOKEN_CHAR: a character

 * @G_TOKEN_BINARY: a binary integer

 * @G_TOKEN_OCTAL: an octal integer

 * @G_TOKEN_INT: an integer

 * @G_TOKEN_HEX: a hex integer

 * @G_TOKEN_FLOAT: a floating point number

 * @G_TOKEN_STRING: a string

 * @G_TOKEN_SYMBOL: a symbol

 * @G_TOKEN_IDENTIFIER: an identifier

 * @G_TOKEN_IDENTIFIER_NULL: a null identifier

 * @G_TOKEN_COMMENT_SINGLE: one line comment

 * @G_TOKEN_COMMENT_MULTI: multi line comment

 *

 * The possible types of token returned from each

 * g_scanner_get_next_token() call.

 */

/**

 * GTokenValue:

 * @v_symbol: token symbol value

 * @v_identifier: token identifier value

 * @v_binary: token binary integer value

 * @v_octal: octal integer value

 * @v_int: integer value

 * @v_int64: 64-bit integer value

 * @v_float: floating point value

 * @v_hex: hex integer value

 * @v_string: string value

 * @v_comment: comment value

 * @v_char: character value

 * @v_error: error value

 *

 * A union holding the value of the token.

 */

/**

 * GErrorType:

 * @G_ERR_UNKNOWN: unknown error

 * @G_ERR_UNEXP_EOF: unexpected end of file

 * @G_ERR_UNEXP_EOF_IN_STRING: unterminated string constant

 * @G_ERR_UNEXP_EOF_IN_COMMENT: unterminated comment

 * @G_ERR_NON_DIGIT_IN_CONST: non-digit character in a number

 * @G_ERR_DIGIT_RADIX: digit beyond radix in a number

 * @G_ERR_FLOAT_RADIX: non-decimal floating point number

 * @G_ERR_FLOAT_MALFORMED: malformed floating point number

 *

 * The possible errors, used in the @v_error field

 * of #GTokenValue, when the token is a %G_TOKEN_ERROR.

 */

/**

 * GScanner:

 * @user_data: unused

 * @max_parse_errors: unused

 * @parse_errors: g_scanner_error() increments this field

 * @input_name: name of input stream, featured by the default message handler

 * @qdata: quarked data

 * @config: link into the scanner configuration

 * @token: token parsed by the last g_scanner_get_next_token()

 * @value: value of the last token from g_scanner_get_next_token()

 * @line: line number of the last token from g_scanner_get_next_token()

 * @position: char number of the last token from g_scanner_get_next_token()

 * @next_token: token parsed by the last g_scanner_peek_next_token()

 * @next_value: value of the last token from g_scanner_peek_next_token()

 * @next_line: line number of the last token from g_scanner_peek_next_token()

 * @next_position: char number of the last token from g_scanner_peek_next_token()

 * @msg_handler: handler function for _warn and _error

 *

 * The data structure representing a lexical scanner.

 *

 * You should set @input_name after creating the scanner, since

 * it is used by the default message handler when displaying

 * warnings and errors. If you are scanning a file, the filename

 * would be a good choice.

 *

 * The @user_data and @max_parse_errors fields are not used.

 * If you need to associate extra data with the scanner you

 * can place them here.

 *

 * If you want to use your own message handler you can set the

 * @msg_handler field. The type of the message handler function

 * is declared by #GScannerMsgFunc.

 */

/**

 * GScannerConfig:

 * @cset_skip_characters: specifies which characters should be skipped

 *     by the scanner (the default is the whitespace characters: space,

 *     tab, carriage-return and line-feed).

 * @cset_identifier_first: specifies the characters which can start

 *     identifiers (the default is #G_CSET_a_2_z, "_", and #G_CSET_A_2_Z).

 * @cset_identifier_nth: specifies the characters which can be used

 *     in identifiers, after the first character (the default is

 *     #G_CSET_a_2_z, "_0123456789", #G_CSET_A_2_Z, #G_CSET_LATINS,

 *     #G_CSET_LATINC).

 * @cpair_comment_single: specifies the characters at the start and

 *     end of single-line comments. The default is "#\n" which means

 *     that single-line comments start with a '#' and continue until

 *     a '\n' (end of line).

 * @case_sensitive: specifies if symbols are case sensitive (the

 *     default is %FALSE).

 * @skip_comment_multi: specifies if multi-line comments are skipped

 *     and not returned as tokens (the default is %TRUE).

 * @skip_comment_single: specifies if single-line comments are skipped

 *     and not returned as tokens (the default is %TRUE).

 * @scan_comment_multi: specifies if multi-line comments are recognized

 *     (the default is %TRUE).

 * @scan_identifier: specifies if identifiers are recognized (the

 *     default is %TRUE).

 * @scan_identifier_1char: specifies if single-character

 *     identifiers are recognized (the default is %FALSE).

 * @scan_identifier_NULL: specifies if %NULL is reported as

 *     %G_TOKEN_IDENTIFIER_NULL (the default is %FALSE).

 * @scan_symbols: specifies if symbols are recognized (the default

 *     is %TRUE).

 * @scan_binary: specifies if binary numbers are recognized (the

 *     default is %FALSE).

 * @scan_octal: specifies if octal numbers are recognized (the

 *     default is %TRUE).

 * @scan_float: specifies if floating point numbers are recognized

 *     (the default is %TRUE).

 * @scan_hex: specifies if hexadecimal numbers are recognized (the

 *     default is %TRUE).

 * @scan_hex_dollar: specifies if '$' is recognized as a prefix for

 *     hexadecimal numbers (the default is %FALSE).

 * @scan_string_sq: specifies if strings can be enclosed in single

 *     quotes (the default is %TRUE).

 * @scan_string_dq: specifies if strings can be enclosed in double

 *     quotes (the default is %TRUE).

 * @numbers_2_int: specifies if binary, octal and hexadecimal numbers

 *     are reported as #G_TOKEN_INT (the default is %TRUE).

 * @int_2_float: specifies if all numbers are reported as %G_TOKEN_FLOAT

 *     (the default is %FALSE).

 * @identifier_2_string: specifies if identifiers are reported as strings

 *     (the default is %FALSE).

 * @char_2_token: specifies if characters are reported by setting

 *     <literal>token = ch</literal> or as %G_TOKEN_CHAR (the default

 *     is %TRUE).

 * @symbol_2_token: specifies if symbols are reported by setting

 *     <literal>token = v_symbol</literal> or as %G_TOKEN_SYMBOL (the

 *     default is %FALSE).

 * @scope_0_fallback: specifies if a symbol is searched for in the

 *     default scope in addition to the current scope (the default is %FALSE).

 * @store_int64: use value.v_int64 rather than v_int

 *

 * Specifies the #GScanner parser configuration. Most settings can

 * be changed during the parsing phase and will affect the lexical

 * parsing of the next unpeeked token.

 */

/* --- 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;

}

/**

 * g_scanner_new:

 * @config_templ: the initial scanner settings

 *

 * Creates a new #GScanner.

 *

 * The @config_templ structure specifies the initial settings

 * of the scanner, which are copied into the #GScanner

 * @config field. If you pass %NULL then the default settings

 * are used.

 *

 * Returns: the new #GScanner

 */

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);

}

/**

 * g_scanner_destroy:

 * @scanner: a #GScanner

 *

 * Frees all memory used by the #GScanner.

 */

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);

}

/**

 * g_scanner_error:

 * @scanner: a #GScanner

 * @format: the message format. See the printf() documentation

 * @...: the parameters to insert into the format string

 *

 * Outputs an error message, via the #GScanner message handler.

 */

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);

    }

}

/**

 * g_scanner_warn:

 * @scanner: a #GScanner

 * @format: the message format. See the printf() documentation

 * @...: the parameters to insert into the format string

 *

 * Outputs a warning message, via the #GScanner message handler.

 */

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;

}

/**

 * g_scanner_add_symbol:

 * @scanner: a #GScanner

 * @symbol: the symbol to add

 * @value: the value of the symbol

 *

 * Adds a symbol to the default scope.

 *

 * Deprecated: 2.2: Use g_scanner_scope_add_symbol() instead.

 */

/**

 * g_scanner_scope_add_symbol:

 * @scanner: a #GScanner

 * @scope_id: the scope id

 * @symbol: the symbol to add

 * @value: the value of the symbol

 *

 * Adds a symbol to the given scope.

 */

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;

}

/**

 * g_scanner_remove_symbol:

 * @scanner: a #GScanner

 * @symbol: the symbol to remove

 *

 * Removes a symbol from the default scope.

 *

 * Deprecated: 2.2: Use g_scanner_scope_remove_symbol() instead.

 */

/**

 * g_scanner_scope_remove_symbol:

 * @scanner: a #GScanner

 * @scope_id: the scope id

 * @symbol: the symbol to remove

 *

 * Removes a symbol from a scope.

 */

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);

    }

}

/**

 * g_scanner_freeze_symbol_table:

 * @scanner: a #GScanner

 *

 * There is no reason to use this macro, since it does nothing.

 *

 * Deprecated: 2.2: This macro does nothing.

 */

/**

 * g_scanner_thaw_symbol_table:

 * @scanner: a #GScanner

 *

 * There is no reason to use this macro, since it does nothing.

 *

 * Deprecated: 2.2: This macro does nothing.

 */

/**

 * g_scanner_lookup_symbol:

 * @scanner: a #GScanner

 * @symbol: the symbol to look up

 *

 * Looks up a symbol in the current scope and return its value.

 * If the symbol is not bound in the current scope, %NULL is

 * returned.

 *

 * Returns: the value of @symbol in the current scope, or %NULL

 *     if @symbol is not bound in the current scope

 */

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;

}

/**

 * g_scanner_scope_lookup_symbol:

 * @scanner: a #GScanner

 * @scope_id: the scope id

 * @symbol: the symbol to look up

 *

 * Looks up a symbol in a scope and return its value. If the

 * symbol is not bound in the scope, %NULL is returned.

 *

 * Returns: the value of @symbol in the given scope, or %NULL

 *     if @symbol is not bound in the given scope.

 *

 */

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;

}

/**

 * g_scanner_set_scope:

 * @scanner: a #GScanner

 * @scope_id: the new scope id

 *

 * Sets the current scope.

 *

 * Returns: the old scope id

 */

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;

  guint *scope_id;

  d = _user_data;

  func = (GHFunc) d[0];

  user_data = d[1];

  scope_id = d[2];

  key = _value;