/* GTK - The GIMP Toolkit
 * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library 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
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library General Public
 * License along with this library; if not, write to the Free
 * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */
#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "gtkrc.h"


enum {
  TOKEN_EOF,
  TOKEN_LEFT_CURLY,
  TOKEN_RIGHT_CURLY,
  TOKEN_LEFT_BRACE,
  TOKEN_RIGHT_BRACE,
  TOKEN_EQUAL_SIGN,
  TOKEN_COMMA,
  TOKEN_INTEGER,
  TOKEN_FLOAT,
  TOKEN_STRING,
  TOKEN_SYMBOL,
  TOKEN_ACTIVE,
  TOKEN_BASE,
  TOKEN_BG,
  TOKEN_BG_PIXMAP,
  TOKEN_FG,
  TOKEN_FONT,
  TOKEN_FONTSET,
  TOKEN_INSENSITIVE,
  TOKEN_NORMAL,
  TOKEN_PIXMAP_PATH,
  TOKEN_PRELIGHT,
  TOKEN_SELECTED,
  TOKEN_STYLE,
  TOKEN_TEXT,
  TOKEN_WIDGET,
  TOKEN_WIDGET_CLASS
};

enum {
  PARSE_OK,
  PARSE_ERROR,
  PARSE_SYNTAX
};

enum {
  PARSE_START,
  PARSE_COMMENT,
  PARSE_STRING,
  PARSE_SYMBOL,
  PARSE_NUMBER
};


typedef struct _GtkRcStyle  GtkRcStyle;
typedef struct _GtkRcSet    GtkRcSet;

struct _GtkRcStyle
{
  int initialize;
  char *name;
  char *font_name;
  char *fontset_name;
  char *bg_pixmap_name[5];
  GtkStyle *style;
};

struct _GtkRcSet
{
  char *set;
  GtkRcStyle *rc_style;
};


static guint       gtk_rc_style_hash               (const char *name);
static gint        gtk_rc_style_compare            (const char *a,
						    const char *b);
static GtkRcStyle* gtk_rc_style_find               (const char *name);
static GtkRcStyle* gtk_rc_styles_match             (GSList *sets,
						    const char   *path);
static gint        gtk_rc_style_match              (const char *set,
						    const char *path);
static void        gtk_rc_style_init               (GtkRcStyle *rc_style);
static gint        gtk_rc_get_token                (void);
static gint        gtk_rc_simple_token             (char ch);
static gint        gtk_rc_symbol_token             (const char *sym);
static gint        gtk_rc_get_next_token           (void);
static gint        gtk_rc_peek_next_token          (void);
static gint        gtk_rc_parse_statement          (void);
static gint        gtk_rc_parse_style              (void);
static gint        gtk_rc_parse_style_option       (GtkRcStyle   *rc_style);
static gint        gtk_rc_parse_base               (GtkStyle     *style);
static gint        gtk_rc_parse_bg                 (GtkStyle     *style);
static gint        gtk_rc_parse_fg                 (GtkStyle     *style);
static gint        gtk_rc_parse_bg_pixmap          (GtkRcStyle   *rc_style);
static gint        gtk_rc_parse_font               (GtkRcStyle   *rc_style);
static gint	   gtk_rc_parse_fontset 	   (GtkRcStyle   *rc_style);
static gint        gtk_rc_parse_state              (GtkStateType *state);
static gint        gtk_rc_parse_color              (GdkColor     *color);
static gint        gtk_rc_parse_pixmap_path        (void);
static void        gtk_rc_parse_pixmap_path_string (gchar *pix_path);
static char*       gtk_rc_find_pixmap_in_path      (gchar *pixmap_file);
static gint        gtk_rc_parse_widget_style       (void);
static gint        gtk_rc_parse_widget_class_style (void);
static char*       gtk_rc_widget_path              (GtkWidget *widget);
static char*       gtk_rc_widget_class_path        (GtkWidget *widget);


static struct
{
  char *name;
  int token;
} symbols[] =
  {
    { "ACTIVE", TOKEN_ACTIVE },
    { "base", TOKEN_BASE },
    { "bg", TOKEN_BG },
    { "bg_pixmap", TOKEN_BG_PIXMAP },
    { "fg", TOKEN_FG },
    { "font", TOKEN_FONT },
    { "fontset", TOKEN_FONTSET },
    { "INSENSITIVE", TOKEN_INSENSITIVE },
    { "NORMAL", TOKEN_NORMAL },
    { "pixmap_path", TOKEN_PIXMAP_PATH },
    { "PRELIGHT", TOKEN_PRELIGHT },
    { "SELECTED", TOKEN_SELECTED },
    { "style", TOKEN_STYLE },
    { "text", TOKEN_TEXT },
    { "widget", TOKEN_WIDGET },
    { "widget_class", TOKEN_WIDGET_CLASS },
  };

static int nsymbols = sizeof (symbols) / sizeof (symbols[0]);

static struct
{
  char ch;
  int token;
} simple_tokens[] =
  {
    { '{', TOKEN_LEFT_CURLY },
    { '}', TOKEN_RIGHT_CURLY },
    { '[', TOKEN_LEFT_BRACE },
    { ']', TOKEN_RIGHT_BRACE },
    { '=', TOKEN_EQUAL_SIGN },
    { ',', TOKEN_COMMA },
  };

static int nsimple_tokens = sizeof (simple_tokens) / sizeof (simple_tokens[0]);

static FILE *input_fp = NULL;
static char *buffer = NULL;
static char *tokenbuf = NULL;
static int position = 0;
static int linenum = 1;
static int buffer_size = 1024;
static int tokenbuf_size = 1024;

static int done;
static int cur_token;
static int next_token;

static char *token_str;
static double token_float;
static int token_int;

static GHashTable *rc_style_ht = NULL;
static GSList *widget_sets = NULL;
static GSList *widget_class_sets = NULL;

#define GTK_RC_MAX_PIXMAP_PATHS 128
static gchar *pixmap_path[GTK_RC_MAX_PIXMAP_PATHS];


void
gtk_rc_init ()
{
  rc_style_ht = g_hash_table_new ((GHashFunc) gtk_rc_style_hash,
				  (GCompareFunc) gtk_rc_style_compare);
}

void
gtk_rc_parse (const char *filename)
{
  input_fp = fopen (filename, "r");
  if (!input_fp)
	  return;

  buffer = g_new (char, buffer_size + tokenbuf_size);
  tokenbuf = buffer + buffer_size;
  position = 0;
  linenum = 1;

  cur_token = -1;
  next_token = -1;
  done = FALSE;

  while (!done)
    {
      if (gtk_rc_parse_statement () != PARSE_OK)
	{
	  g_warning ("rc file parse error: \"%s\" line %d",
		     filename, linenum);
	  done = TRUE;
	}
    }

  fclose (input_fp);

  g_free (buffer);

  buffer = NULL;
  tokenbuf = NULL;
  position = 0;
  linenum = 1;
}

GtkStyle*
gtk_rc_get_style (GtkWidget *widget)
{
  GtkRcStyle *rc_style;
  char *path;

  if (widget_sets)
    {
      path = gtk_rc_widget_path (widget);
      if (path)
	{
	  rc_style = gtk_rc_styles_match (widget_sets, path);
	  g_free (path);

	  if (rc_style)
	    {
	      gtk_rc_style_init (rc_style);
	      return rc_style->style;
	    }
	}
    }

  if (widget_class_sets)
    {
      path = gtk_rc_widget_class_path (widget);
      if (path)
	{
	  rc_style = gtk_rc_styles_match (widget_class_sets, path);
	  g_free (path);

	  if (rc_style)
	    {
	      gtk_rc_style_init (rc_style);
	      return rc_style->style;
	    }
	}
    }

  return widget->style;
}

void
gtk_rc_add_widget_name_style (GtkStyle *style,
			      const char     *pattern)
{
  GtkRcStyle *rc_style;
  GtkRcSet *rc_set;
  int i;

  gtk_style_ref (style);

  rc_style = g_new (GtkRcStyle, 1);
  rc_style->initialize = FALSE;
  rc_style->name = NULL;
  rc_style->font_name = NULL;
  rc_style->fontset_name = NULL;

  for (i = 0; i < 5; i++)
    rc_style->bg_pixmap_name[i] = NULL;

  rc_style->style = style;

  rc_set = g_new (GtkRcSet, 1);
  rc_set->set = g_strdup (pattern);
  rc_set->rc_style = rc_style;

  widget_sets = g_slist_append (widget_sets, rc_set);
}

void
gtk_rc_add_widget_class_style (GtkStyle *style,
			       const char     *pattern)
{
  GtkRcStyle *rc_style;
  GtkRcSet *rc_set;
  int i;

  gtk_style_ref (style);

  rc_style = g_new (GtkRcStyle, 1);
  rc_style->initialize = FALSE;
  rc_style->name = NULL;
  rc_style->font_name = NULL;
  rc_style->fontset_name = NULL;

  for (i = 0; i < 5; i++)
    rc_style->bg_pixmap_name[i] = NULL;

  rc_style->style = style;

  rc_set = g_new (GtkRcSet, 1);
  rc_set->set = g_strdup (pattern);
  rc_set->rc_style = rc_style;

  widget_class_sets = g_slist_append (widget_class_sets, rc_set);
}


static guint
gtk_rc_style_hash (const char *name)
{
  guint result;

  result = 0;
  while (*name)
    result += (result << 3) + *name++;

  return result;
}

static gint
gtk_rc_style_compare (const char *a,
		      const char *b)
{
  return (strcmp (a, b) == 0);
}

static GtkRcStyle*
gtk_rc_style_find (const char *name)
{
  GtkRcStyle *rc_style;

  rc_style = g_hash_table_lookup (rc_style_ht, (gpointer) name);

  return rc_style;
}

static GtkRcStyle*
gtk_rc_styles_match (GSList       *sets,
		     const char   *path)
{
  GtkRcSet *rc_set;

  while (sets)
    {
      rc_set = sets->data;
      sets = sets->next;

      if (gtk_rc_style_match (rc_set->set, path))
	return rc_set->rc_style;
    }

  return NULL;
}

static gint
gtk_rc_style_match (const char *set,
		    const char *path)
{
  char ch;

  while (1)
    {
      ch = *set++;
      if (ch == '\0')
	return (*path == '\0');

      switch (ch)
	{
	case '*':
	  while (*set == '*')
	    set++;

	  ch = *set++;
	  if (ch == '\0')
	    return TRUE;

	  while (*path)
	    {
	      while (*path && (ch != *path))
		path++;

	      if (!(*path))
		return FALSE;

	      path++;
	      if (gtk_rc_style_match (set, path))
		return TRUE;
	    }
	  break;

	case '?':
	  break;

	default:
	  if (ch == *path)
	    path++;
	  else
	    return FALSE;
	  break;
	}
    }

  return TRUE;
}

static void
gtk_rc_style_init (GtkRcStyle *rc_style)
{
  GdkFont *old_font;
  gint i;

  if (rc_style->initialize)
    {
      rc_style->initialize = FALSE;

      if (rc_style->fontset_name)
	{
	  old_font = rc_style->style->font;
	  rc_style->style->font = gdk_fontset_load (rc_style->fontset_name);
	  if (rc_style->style->font)
	    gdk_fontset_free (old_font);
	  else
	    rc_style->style->font = old_font;
	}
      else if (rc_style->font_name)
	{
	  old_font = rc_style->style->font;
	  rc_style->style->font = gdk_font_load (rc_style->font_name);
	  if (rc_style->style->font)
	    gdk_font_free (old_font);
	  else
	    rc_style->style->font = old_font;
	}

      for (i = 0; i < 5; i++)
	if (rc_style->bg_pixmap_name[i])
	  {
	    if (strcmp (rc_style->bg_pixmap_name[i], "<parent>") == 0)
	      rc_style->style->bg_pixmap[i] = (GdkPixmap*) GDK_PARENT_RELATIVE;
	    else
	      rc_style->style->bg_pixmap[i] = gdk_pixmap_create_from_xpm (NULL, NULL,
									  &rc_style->style->bg[i],
									  rc_style->bg_pixmap_name[i]);
	  }
    }
}

static gint
gtk_rc_get_token ()
{
  int tokenpos;
  int state;
  int count;
  int token;
  int hex_number = FALSE;
  int float_number = FALSE;
  char ch;

  tokenpos = 0;
  state = PARSE_START;

  while (1)
    {
      if (position >= (buffer_size - 1))
	position = 0;
      if (!position || (buffer[position] == '\0'))
	{
	  count = fread (buffer, sizeof (char), buffer_size - 1, input_fp);
	  if ((count == 0) && feof (input_fp))
	    return TOKEN_EOF;
	  buffer[count] = '\0';
	}

      ch = buffer[position++];
      if (ch == '\n')
	linenum += 1;

      switch (state)
	{
	case PARSE_START:
	  token = gtk_rc_simple_token (ch);

	  if (token)
	    return token;
	  else if (ch == '#')
	    state = PARSE_COMMENT;
	  else if (ch == '"')
	    state = PARSE_STRING;
	  else if ((ch == ' ') || (ch == '\t') || (ch == '\n'))
	    break;
	  else if (ch == '.')
	    {
	      hex_number = FALSE;
	      float_number = TRUE;
	      tokenbuf[tokenpos++] = ch;
	      state = PARSE_NUMBER;
	    }
	  else if ((ch == '$') || (ch == '#'))
	    {
	      hex_number = TRUE;
	      float_number = FALSE;
	      state = PARSE_NUMBER;
	    }
	  else if (isdigit (ch))
	    {
	      hex_number = FALSE;
	      float_number = FALSE;
	      tokenbuf[tokenpos++] = ch;
	      state = PARSE_NUMBER;
	    }
	  else
	    {
	      tokenbuf[tokenpos++] = ch;
	      state = PARSE_SYMBOL;
	    }
	  break;

	case PARSE_COMMENT:
	  if (ch == '\n')
	    state = PARSE_START;
	  break;

	case PARSE_STRING:
	  if (ch != '"')
	    {
	      tokenbuf[tokenpos++] = ch;
	    }
	  else
	    {
	      tokenbuf[tokenpos] = '\0';
	      token_str = tokenbuf;
	      return TOKEN_STRING;
	    }
	  break;

	case PARSE_SYMBOL:
	  if ((ch != ' ') && (ch != '\t') && (ch != '\n') &&
	      (gtk_rc_simple_token (ch) == 0))
	    {
	      tokenbuf[tokenpos++] = ch;
	    }
	  else
	    {
	      position -= 1;
	      tokenbuf[tokenpos] = '\0';
	      token_str = tokenbuf;
	      return gtk_rc_symbol_token (tokenbuf);
	    }
	  break;

	case PARSE_NUMBER:
	  if (isdigit (ch) || (hex_number && isxdigit (ch)))
	    {
	      tokenbuf[tokenpos++] = ch;
	    }
	  else if (!hex_number && !float_number && (ch == '.'))
	    {
	      float_number = TRUE;
	      tokenbuf[tokenpos++] = ch;
	    }
	  else if (!float_number &&
		   (ch == 'x') && (tokenpos == 1) &&
		   (tokenbuf[0] == '0'))
	    {
	      hex_number = TRUE;
	      tokenpos = 0;
	    }
	  else
	    {
	      position -= 1;
	      tokenbuf[tokenpos] = '\0';
	      if (float_number)
		{
		  sscanf (tokenbuf, "%lf", &token_float);
		  return TOKEN_FLOAT;
		}
	      else
		{
		  sscanf (tokenbuf, (hex_number ? "%x" : "%d"), &token_int);
		  return TOKEN_INTEGER;
		}
	    }
	  break;
	}
    }
}

static gint
gtk_rc_simple_token (char ch)
{
  gint i;

  for (i = 0; i < nsimple_tokens; i++)
    if (simple_tokens[i].ch == ch)
      return simple_tokens[i].token;

  return 0;
}

static gint
gtk_rc_symbol_token (const char *sym)
{
  gint i;

  for (i = 0; i < nsymbols; i++)
    if (strcmp (symbols[i].name, sym) == 0)
      return symbols[i].token;

  return TOKEN_STRING;
}

static gint
gtk_rc_get_next_token ()
{
  if (next_token != -1)
    {
      cur_token = next_token;
      next_token = -1;
    }
  else
    {
      cur_token = gtk_rc_get_token ();
    }

  return cur_token;
}

static gint
gtk_rc_peek_next_token ()
{
  if (next_token == -1)
    next_token = gtk_rc_get_token ();

  return next_token;
}

static gint
gtk_rc_parse_statement ()
{
  gint token;
  gint error;

  token = gtk_rc_peek_next_token ();
  if (!token)
    {
      done = TRUE;
      return PARSE_OK;
    }

  error = gtk_rc_parse_style ();
  if (error != PARSE_SYNTAX)
    return error;

  error = gtk_rc_parse_pixmap_path ();
  if (error != PARSE_SYNTAX)
    return error;

  error = gtk_rc_parse_widget_style ();
  if (error != PARSE_SYNTAX)
    return error;

  error = gtk_rc_parse_widget_class_style ();

  return error;
}

static gint
gtk_rc_parse_style ()
{
  GtkRcStyle *rc_style;
  GtkRcStyle *parent_style;
  gint token;
  gint error;
  gint insert;
  gint i;

  token = gtk_rc_peek_next_token ();
  if (!token)
    return PARSE_ERROR;
  if (token != TOKEN_STYLE)
    return PARSE_SYNTAX;
  token = gtk_rc_get_next_token ();

  token = gtk_rc_get_next_token ();
  if (!token || (token != TOKEN_STRING))
    return PARSE_ERROR;

  insert = FALSE;
  rc_style = g_hash_table_lookup (rc_style_ht, token_str);

  if (!rc_style)
    {
      insert = TRUE;
      rc_style = g_new (GtkRcStyle, 1);
      rc_style->initialize = TRUE;
      rc_style->name = g_strdup (token_str);
      rc_style->font_name = NULL;
      rc_style->fontset_name = NULL;

      for (i = 0; i < 5; i++)
	rc_style->bg_pixmap_name[i] = NULL;

      rc_style->style = gtk_style_new ();
      gtk_style_ref (rc_style->style);
    }

  token = gtk_rc_peek_next_token ();
  if (token == TOKEN_EQUAL_SIGN)
    {
      token = gtk_rc_get_next_token ();

      token = gtk_rc_get_next_token ();
      if (!token || (token != TOKEN_STRING))
	{
	  if (insert)
	    {
	      gtk_style_unref (rc_style->style);
	      g_free (rc_style);
	    }
	  return PARSE_ERROR;
	}

      parent_style = g_hash_table_lookup (rc_style_ht, token_str);
      if (parent_style)
	{
	  for (i = 0; i < 5; i++)
	    {
	      rc_style->style->fg[i] = parent_style->style->fg[i];
	      rc_style->style->bg[i] = parent_style->style->bg[i];
	      rc_style->style->light[i] = parent_style->style->light[i];
	      rc_style->style->dark[i] = parent_style->style->dark[i];
	      rc_style->style->mid[i] = parent_style->style->mid[i];
	      rc_style->style->text[i] = parent_style->style->text[i];
	      rc_style->style->base[i] = parent_style->style->base[i];
	    }

	  rc_style->style->black = parent_style->style->black;
	  rc_style->style->white = parent_style->style->white;

	  if (rc_style->fontset_name)
	    {
	      g_free (rc_style->fontset_name);
	      rc_style->fontset_name = g_strdup (parent_style->fontset_name);
	    }
	  else if (rc_style->font_name)
	    {
	      g_free (rc_style->font_name);
	      rc_style->font_name = g_strdup (parent_style->font_name);
	    }

	  for (i = 0; i < 5; i++)
	    {
	      if (rc_style->bg_pixmap_name[i])
		g_free (rc_style->bg_pixmap_name[i]);
	      rc_style->bg_pixmap_name[i] = g_strdup (parent_style->bg_pixmap_name[i]);
	    }
	}
    }

  token = gtk_rc_get_next_token ();
  if (!token || (token != TOKEN_LEFT_CURLY))
    {
      if (insert)
	{
	  gtk_style_unref (rc_style->style);
	  g_free (rc_style);
	}
      return PARSE_ERROR;
    }

  while (1)
    {
      error = gtk_rc_parse_style_option (rc_style);
      if (error == PARSE_SYNTAX)
	break;
      if (error == PARSE_ERROR)
	{
	  if (insert)
	    {
	      gtk_style_unref (rc_style->style);
	      g_free (rc_style);
	    }
	  return error;
	}
    }

  token = gtk_rc_get_next_token ();
  if (!token || (token != TOKEN_RIGHT_CURLY))
    {
      if (insert)
	{
	  if (rc_style->fontset_name)
	    g_free (rc_style->fontset_name);
	  else if (rc_style->font_name)
	    g_free (rc_style->font_name);

	  for (i = 0; i < 5; i++)
	    if (rc_style->bg_pixmap_name[i])
	      g_free (rc_style->bg_pixmap_name[i]);

	  gtk_style_unref (rc_style->style);
	  g_free (rc_style);
	}
      return PARSE_ERROR;
    }

  if (insert)
    g_hash_table_insert (rc_style_ht, rc_style->name, rc_style);

  return PARSE_OK;
}

static gint
gtk_rc_parse_style_option (GtkRcStyle *rc_style)
{
  gint token;
  gint error;

  token = gtk_rc_peek_next_token ();
  if (!token)
    return PARSE_ERROR;

  error = gtk_rc_parse_base (rc_style->style);
  if (error != PARSE_SYNTAX)
    return error;

  error = gtk_rc_parse_bg (rc_style->style);
  if (error != PARSE_SYNTAX)
    return error;

  error = gtk_rc_parse_fg (rc_style->style);
  if (error != PARSE_SYNTAX)
    return error;

  error = gtk_rc_parse_bg_pixmap (rc_style);
  if (error != PARSE_SYNTAX)
    return error;

  error = gtk_rc_parse_font (rc_style);
  if (error != PARSE_SYNTAX)
    return error;

  error = gtk_rc_parse_fontset (rc_style);

  return error;
}

static gint
gtk_rc_parse_base (GtkStyle *style)
{
  GtkStateType state;
  gint token;
  gint error;

  token = gtk_rc_peek_next_token ();
  if (!token)
    return PARSE_ERROR;
  if (token != TOKEN_BASE)
    return PARSE_SYNTAX;
  token = gtk_rc_get_next_token ();

  error = gtk_rc_parse_state (&state);
  if (error != PARSE_OK)
    return error;

  token = gtk_rc_get_next_token ();
  if (!token || (token != TOKEN_EQUAL_SIGN))
    return PARSE_ERROR;

  error = gtk_rc_parse_color (&style->base[state]);

  return error;
}

static gint
gtk_rc_parse_bg (GtkStyle *style)
{
  GtkStateType state;
  gint token;
  gint error;

  token = gtk_rc_peek_next_token ();
  if (!token)
    return PARSE_ERROR;
  if (token != TOKEN_BG)
    return PARSE_SYNTAX;
  token = gtk_rc_get_next_token ();

  error = gtk_rc_parse_state (&state);
  if (error != PARSE_OK)
    return error;

  token = gtk_rc_get_next_token ();
  if (!token || (token != TOKEN_EQUAL_SIGN))
    return PARSE_ERROR;

  error = gtk_rc_parse_color (&style->bg[state]);

  return error;
}

static gint
gtk_rc_parse_fg (GtkStyle *style)
{
  GtkStateType state;
  gint token;
  gint error;

  token = gtk_rc_peek_next_token ();
  if (!token)
    return PARSE_ERROR;
  if (token != TOKEN_FG)
    return PARSE_SYNTAX;
  token = gtk_rc_get_next_token ();

  error = gtk_rc_parse_state (&state);
  if (error != PARSE_OK)
    return error;

  token = gtk_rc_get_next_token ();
  if (!token || (token != TOKEN_EQUAL_SIGN))
    return PARSE_ERROR;

  error = gtk_rc_parse_color (&style->fg[state]);

  return error;
}

static gint
gtk_rc_parse_bg_pixmap (GtkRcStyle *rc_style)
{
  GtkStateType state;
  gint token;
  gint error;
  gchar *pixmap_file;

  token = gtk_rc_peek_next_token ();
  if (!token)
    return PARSE_ERROR;
  if (token != TOKEN_BG_PIXMAP)
    return PARSE_SYNTAX;
  token = gtk_rc_get_next_token ();

  error = gtk_rc_parse_state (&state);
  if (error != PARSE_OK)
    return error;

  token = gtk_rc_get_next_token ();
  if (!token || (token != TOKEN_EQUAL_SIGN))
    return PARSE_ERROR;

  token = gtk_rc_get_next_token ();
  if (!token || (token != TOKEN_STRING))
    return PARSE_ERROR;

  if (strcmp (token_str, "<parent>"))
    pixmap_file = gtk_rc_find_pixmap_in_path (token_str);
  else
    pixmap_file = g_strdup(token_str);

  if (pixmap_file)
    {
      if (rc_style->bg_pixmap_name[state])
	g_free (rc_style->bg_pixmap_name[state]);
      rc_style->bg_pixmap_name[state] = pixmap_file;
    }

  return PARSE_OK;
}

static char*
gtk_rc_find_pixmap_in_path (gchar *pixmap_file)
{
  gint i;
  FILE *fp;
  gchar *buf;

  for (i = 0; (i < GTK_RC_MAX_PIXMAP_PATHS) && (pixmap_path[i] != NULL); i++)
    {
      buf = g_malloc (strlen (pixmap_path[i]) + strlen (pixmap_file) + 2);
      sprintf (buf, "%s%c%s", pixmap_path[i], '/', pixmap_file);

      fp = fopen (buf, "r");
      if (fp)
	{
	  fclose (fp);
	  return buf;
	}

      g_free (buf);
    }

  g_warning ("Unable to locate image file in pixmap_path: \"%s\" line %d",
	     pixmap_file, linenum);

  return NULL;
}

static gint
gtk_rc_parse_font (GtkRcStyle *rc_style)
{
  gint token;

  token = gtk_rc_peek_next_token ();
  if (!token)
    return PARSE_ERROR;
  if (token != TOKEN_FONT)
    return PARSE_SYNTAX;
  token = gtk_rc_get_next_token ();

  token = gtk_rc_get_next_token ();
  if (!token || (token != TOKEN_EQUAL_SIGN))
    return PARSE_ERROR;

  token = gtk_rc_get_next_token ();
  if (!token || (token != TOKEN_STRING))
    return PARSE_ERROR;

  if (rc_style->font_name)
    g_free (rc_style->font_name);
  rc_style->font_name = g_strdup (token_str);

  return PARSE_OK;
}

static gint
gtk_rc_parse_fontset (GtkRcStyle *rc_style)
{
  gint token;

  token = gtk_rc_peek_next_token ();
  if (!token)
    return PARSE_ERROR;
  if (token != TOKEN_FONTSET)
    return PARSE_SYNTAX;
  token = gtk_rc_get_next_token ();

  token = gtk_rc_get_next_token ();
  if (!token || (token != TOKEN_EQUAL_SIGN))
    return PARSE_ERROR;

  token = gtk_rc_get_next_token ();
  if (!token || (token != TOKEN_STRING))
    return PARSE_ERROR;

  if (rc_style->fontset_name)
    g_free (rc_style->fontset_name);
  rc_style->fontset_name = g_strdup (token_str);

  return PARSE_OK;
}

static gint
gtk_rc_parse_state (GtkStateType *state)
{
  gint token;

  token = gtk_rc_peek_next_token ();
  if (!token)
    return PARSE_ERROR;
  if (token != TOKEN_LEFT_BRACE)
    return PARSE_SYNTAX;
  token = gtk_rc_get_next_token ();

  token = gtk_rc_get_next_token ();
  if (token == TOKEN_ACTIVE)
    *state = GTK_STATE_ACTIVE;
  else if (token == TOKEN_INSENSITIVE)
    *state = GTK_STATE_INSENSITIVE;
  else if (token == TOKEN_NORMAL)
    *state = GTK_STATE_NORMAL;
  else if (token == TOKEN_PRELIGHT)
    *state = GTK_STATE_PRELIGHT;
  else if (token == TOKEN_SELECTED)
    *state = GTK_STATE_SELECTED;
  else
    return PARSE_ERROR;

  token = gtk_rc_get_next_token ();
  if (!token || (token != TOKEN_RIGHT_BRACE))
    return PARSE_ERROR;

  return PARSE_OK;
}

static gint
gtk_rc_parse_color (GdkColor *color)
{
  gint token;
  gint length;
  gint temp;
  gchar buf[9];
  gint i, j;

  token = gtk_rc_peek_next_token ();
  if (!token)
    return PARSE_ERROR;

  switch (token)
    {
    case TOKEN_LEFT_CURLY:
      token = gtk_rc_get_next_token ();

      token = gtk_rc_get_next_token ();
      if (!token || ((token != TOKEN_INTEGER) && (token != TOKEN_FLOAT)))
	return PARSE_ERROR;

      if (token == TOKEN_FLOAT)
	token_int = token_float * 65535.0;
      if (token_int < 0)
	token_int = 0;
      if (token_int > 65535)
	token_int = 65535;

      color->red = token_int;

      token = gtk_rc_get_next_token ();
      if (!token || (token != TOKEN_COMMA))
	return PARSE_ERROR;

      token = gtk_rc_get_next_token ();
      if (!token || ((token != TOKEN_INTEGER) && (token != TOKEN_FLOAT)))
	return PARSE_ERROR;

      if (token == TOKEN_FLOAT)
	token_int = token_float * 65535.0;
      if (token_int < 0)
	token_int = 0;
      if (token_int > 65535)
	token_int = 65535;

      color->green = token_int;

      token = gtk_rc_get_next_token ();
      if (!token || (token != TOKEN_COMMA))
	return PARSE_ERROR;

      token = gtk_rc_get_next_token ();
      if (!token || ((token != TOKEN_INTEGER) && (token != TOKEN_FLOAT)))
	return PARSE_ERROR;

      if (token == TOKEN_FLOAT)
	token_int = token_float * 65535.0;
      if (token_int < 0)
	token_int = 0;
      if (token_int > 65535)
	token_int = 65535;

      color->blue = token_int;

      token = gtk_rc_get_next_token ();
      if (!token || (token != TOKEN_RIGHT_CURLY))
	return PARSE_ERROR;
      break;

    case TOKEN_STRING:
      token = gtk_rc_get_next_token ();

      if (token_str[0] != '#')
	return PARSE_ERROR;

      length = strlen (token_str) - 1;
      if (((length % 3) != 0) || (length > 12))
	return PARSE_ERROR;
      length /= 3;

      for (i = 0, j = 1; i < length; i++, j++)
	buf[i] = token_str[j];
      buf[i] = '\0';

      sscanf (buf, "%x", &temp);
      color->red = temp;

      for (i = 0; i < length; i++, j++)
	buf[i] = token_str[j];
      buf[i] = '\0';

      sscanf (buf, "%x", &temp);
      color->green = temp;

      for (i = 0; i < length; i++, j++)
	buf[i] = token_str[j];
      buf[i] = '\0';

      sscanf (buf, "%x", &temp);
      color->blue = temp;

      if (length == 1)
	{
	  color->red *= 4369;
	  color->green *= 4369;
	  color->blue *= 4369;
	}
      else if (length == 2)
	{
	  color->red *= 257;
	  color->green *= 257;
	  color->blue *= 257;
	}
      else if (length == 3)
	{
	  color->red *= 16;
	  color->green *= 16;
	  color->blue *= 16;
	}
      break;

    default:
      return PARSE_SYNTAX;
    }

  return PARSE_OK;
}

static gint
gtk_rc_parse_pixmap_path ()
{
  gint token;

  token = gtk_rc_peek_next_token ();
  if (!token)
    return PARSE_ERROR;
  if (token != TOKEN_PIXMAP_PATH)
    return PARSE_SYNTAX;
  token = gtk_rc_get_next_token ();

  token = gtk_rc_get_next_token ();

  if (!token || (token != TOKEN_STRING))
    return PARSE_ERROR;

  gtk_rc_parse_pixmap_path_string(token_str);

  return PARSE_OK;
}

static void
gtk_rc_parse_pixmap_path_string (gchar *pix_path)
{
  gchar *buf;
  gint end_offset;
  gint start_offset = 0;
  gint path_len;
  gint path_num;
  
  /* free the old one, or just add to the old one ? */
  for (path_num=0; pixmap_path[path_num]; path_num++)
    {
      g_free (pixmap_path[path_num]);
      pixmap_path[path_num] = NULL;
    }
  
  path_num = 0;
  
  path_len = strlen (pix_path);
  
  buf = g_strdup (pix_path);

  for (end_offset = 0; end_offset <= path_len; end_offset++)
    {
      if ((buf[end_offset] == ':') ||
	  (end_offset == path_len))
	{
	  buf[end_offset] = '\0';
	  pixmap_path[path_num] = g_strdup (buf + start_offset);
	  path_num++;
	  pixmap_path[path_num] = NULL;
	  start_offset = end_offset + 1;
	}
    }
  g_free (buf);
}

static gint
gtk_rc_parse_widget_style ()
{
  GtkRcSet *rc_set;
  gint token;

  token = gtk_rc_peek_next_token ();
  if (!token)
    return PARSE_ERROR;
  if (token != TOKEN_WIDGET)
    return PARSE_SYNTAX;
  token = gtk_rc_get_next_token ();

  token = gtk_rc_get_next_token ();
  if (!token || (token != TOKEN_STRING))
    return PARSE_ERROR;

  rc_set = g_new (GtkRcSet, 1);
  rc_set->set = g_strdup (token_str);

  token = gtk_rc_get_next_token ();
  if (!token || (token != TOKEN_STYLE))
    {
      g_free (rc_set->set);
      g_free (rc_set);
      return PARSE_ERROR;
    }

  token = gtk_rc_get_next_token ();
  if (!token || (token != TOKEN_STRING))
    {
      g_free (rc_set->set);
      g_free (rc_set);
      return PARSE_ERROR;
    }

  rc_set->rc_style = gtk_rc_style_find (token_str);
  if (!rc_set->rc_style)
    {
      g_free (rc_set->set);
      g_free (rc_set);
      return PARSE_ERROR;
    }

  widget_sets = g_slist_append (widget_sets, rc_set);

  return PARSE_OK;
}

static gint
gtk_rc_parse_widget_class_style ()
{
  GtkRcSet *rc_set;
  gint token;

  token = gtk_rc_peek_next_token ();
  if (!token)
    return PARSE_ERROR;
  if (token != TOKEN_WIDGET_CLASS)
    return PARSE_SYNTAX;
  token = gtk_rc_get_next_token ();

  token = gtk_rc_get_next_token ();
  if (!token || (token != TOKEN_STRING))
    return PARSE_ERROR;

  rc_set = g_new (GtkRcSet, 1);
  rc_set->set = g_strdup (token_str);

  token = gtk_rc_get_next_token ();
  if (!token || (token != TOKEN_STYLE))
    {
      g_free (rc_set->set);
      g_free (rc_set);
      return PARSE_ERROR;
    }

  token = gtk_rc_get_next_token ();
  if (!token || (token != TOKEN_STRING))
    {
      g_free (rc_set->set);
      g_free (rc_set);
      return PARSE_ERROR;
    }

  rc_set->rc_style = gtk_rc_style_find (token_str);
  if (!rc_set->rc_style)
    {
      g_free (rc_set->set);
      g_free (rc_set);
      return PARSE_ERROR;
    }

  widget_class_sets = g_slist_append (widget_class_sets, rc_set);

  return PARSE_OK;
}

static char*
gtk_rc_widget_path (GtkWidget *widget)
{
  GtkWidget *tmp_widget;
  char *path;
  char *name;
  int pathlength;
  int namelength;

  path = NULL;
  pathlength = 0;

  tmp_widget = widget;
  while (tmp_widget)
    {
      name = gtk_widget_get_name (tmp_widget);
      pathlength += strlen (name);

      tmp_widget = tmp_widget->parent;

      if (tmp_widget)
	pathlength += 1;
    }

  path = g_new (char, pathlength + 1);
  path[pathlength] = '\0';

  tmp_widget = widget;
  while (tmp_widget)
    {
      name = gtk_widget_get_name (tmp_widget);
      namelength = strlen (name);

      strncpy (&path[pathlength - namelength], name, namelength);
      pathlength -= namelength;

      tmp_widget = tmp_widget->parent;

      if (tmp_widget)
	{
	  pathlength -= 1;
	  path[pathlength] = '.';
	}
    }

  return path;
}

static char*
gtk_rc_widget_class_path (GtkWidget *widget)
{
  GtkWidget *tmp_widget;
  char *path;
  char *name;
  int pathlength;
  int namelength;

  path = NULL;
  pathlength = 0;

  tmp_widget = widget;
  while (tmp_widget)
    {
      name = gtk_type_name (GTK_WIDGET_TYPE (tmp_widget));
      pathlength += strlen (name);

      tmp_widget = tmp_widget->parent;

      if (tmp_widget)
	pathlength += 1;
    }

  path = g_new (char, pathlength + 1);
  path[pathlength] = '\0';

  tmp_widget = widget;
  while (tmp_widget)
    {
      name = gtk_type_name (GTK_WIDGET_TYPE (tmp_widget));
      namelength = strlen (name);

      strncpy (&path[pathlength - namelength], name, namelength);
      pathlength -= namelength;

      tmp_widget = tmp_widget->parent;

      if (tmp_widget)
	{
	  pathlength -= 1;
	  path[pathlength] = '.';
	}
    }

  return path;
}