build: look for Perl in configure.

[bison.git] / src / muscle-tab.c

/* Muscle table manager for Bison.

   Copyright (C) 2001-2012 Free Software Foundation, Inc.

   This file is part of Bison, the GNU Compiler Compiler.

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

   This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.  */

#include <config.h>
#include "system.h"

#include <hash.h>

#include "complain.h"
#include "files.h"
#include "getargs.h"
#include "muscle-tab.h"
#include "quote.h"

/* A key-value pair, along with storage that can be reclaimed when
   this pair is no longer needed.  */
typedef struct
{
  char const *key;
  char const *value;
  char *storage;
} muscle_entry;

/* An obstack used to create some entries.  */
struct obstack muscle_obstack;

/* Initial capacity of muscles hash table.  */
#define HT_INITIAL_CAPACITY 257

static struct hash_table *muscle_table = NULL;

static bool
hash_compare_muscles (void const *x, void const *y)
{
  muscle_entry const *m1 = x;
  muscle_entry const *m2 = y;
  return STREQ (m1->key, m2->key);
}

static size_t
hash_muscle (const void *x, size_t tablesize)
{
  muscle_entry const *m = x;
  return hash_string (m->key, tablesize);
}

/*-----------------------------------------------------------------.
| Create the MUSCLE_TABLE, and initialize it with default values.  |
| Also set up the MUSCLE_OBSTACK.                                  |
`-----------------------------------------------------------------*/

static void
muscle_entry_free (void *entry)
{
  muscle_entry *mentry = entry;
  free (mentry->storage);
  free (mentry);
}

void
muscle_init (void)
{
  /* Initialize the muscle obstack.  */
  obstack_init (&muscle_obstack);

  muscle_table = hash_initialize (HT_INITIAL_CAPACITY, NULL, hash_muscle,
                                  hash_compare_muscles, muscle_entry_free);

  /* Version and input file.  */
  MUSCLE_INSERT_STRING ("version", VERSION);
}


/*------------------------------------------------------------.
| Free all the memory consumed by the muscle machinery only.  |
`------------------------------------------------------------*/

void
muscle_free (void)
{
  hash_free (muscle_table);
  obstack_free (&muscle_obstack, NULL);
}



/*------------------------------------------------------------.
| Insert (KEY, VALUE).  If KEY already existed, overwrite the |
| previous value.                                             |
`------------------------------------------------------------*/

void
muscle_insert (char const *key, char const *value)
{
  muscle_entry probe;
  muscle_entry *entry;

  probe.key = key;
  entry = hash_lookup (muscle_table, &probe);

  if (!entry)
    {
      /* First insertion in the hash. */
      entry = xmalloc (sizeof *entry);
      entry->key = key;
      if (!hash_insert (muscle_table, entry))
        xalloc_die ();
    }
  else
    free (entry->storage);
  entry->value = value;
  entry->storage = NULL;
}


/*-------------------------------------------------------------------.
| Append VALUE to the current value of KEY.  If KEY did not already  |
| exist, create it.  Use MUSCLE_OBSTACK.  De-allocate the previously |
| associated value.  Copy VALUE and SEPARATOR.                       |
`-------------------------------------------------------------------*/

void
muscle_grow (const char *key, const char *val, const char *separator)
{
  muscle_entry probe;
  muscle_entry *entry = NULL;

  probe.key = key;
  entry = hash_lookup (muscle_table, &probe);

  if (!entry)
    {
      /* First insertion in the hash. */
      entry = xmalloc (sizeof *entry);
      entry->key = key;
      if (!hash_insert (muscle_table, entry))
        xalloc_die ();
      entry->value = entry->storage = xstrdup (val);
    }
  else
    {
      /* Grow the current value. */
      char *new_val;
      obstack_sgrow (&muscle_obstack, entry->value);
      free (entry->storage);
      obstack_sgrow (&muscle_obstack, separator);
      obstack_sgrow (&muscle_obstack, val);
      obstack_1grow (&muscle_obstack, 0);
      new_val = obstack_finish (&muscle_obstack);
      entry->value = entry->storage = xstrdup (new_val);
      obstack_free (&muscle_obstack, new_val);
    }
}

/*------------------------------------------------------------------.
| Using muscle_grow, append a synchronization line for the location |
| LOC to the current value of KEY.                                  |
`------------------------------------------------------------------*/

static void
muscle_syncline_grow (char const *key, location loc)
{
  char *extension = NULL;
  obstack_fgrow1 (&muscle_obstack, "]b4_syncline(%d, [[", loc.start.line);
  MUSCLE_OBSTACK_SGROW (&muscle_obstack,
                        quotearg_style (c_quoting_style, loc.start.file));
  obstack_sgrow (&muscle_obstack, "]])[");
  obstack_1grow (&muscle_obstack, 0);
  extension = obstack_finish (&muscle_obstack);
  muscle_grow (key, extension, "");
  obstack_free (&muscle_obstack, extension);
}

/*------------------------------------------------------------------.
| Append VALUE to the current value of KEY, using muscle_grow.  But |
| in addition, issue a synchronization line for the location LOC    |
| using muscle_syncline_grow.                                       |
`------------------------------------------------------------------*/

void
muscle_code_grow (const char *key, const char *val, location loc)
{
  muscle_syncline_grow (key, loc);
  muscle_grow (key, val, "\n");
}


void muscle_pair_list_grow (const char *muscle,
                            const char *a1, const char *a2)
{
  char *pair;
  obstack_sgrow (&muscle_obstack, "[[[");
  MUSCLE_OBSTACK_SGROW (&muscle_obstack, a1);
  obstack_sgrow (&muscle_obstack, "]], [[");
  MUSCLE_OBSTACK_SGROW (&muscle_obstack, a2);
  obstack_sgrow (&muscle_obstack, "]]]");
  obstack_1grow (&muscle_obstack, 0);
  pair = obstack_finish (&muscle_obstack);
  muscle_grow (muscle, pair, ",\n");
  obstack_free (&muscle_obstack, pair);
}


/*----------------------------------------------------------------------------.
| Find the value of muscle KEY.  Unlike MUSCLE_FIND, this is always reliable  |
| to determine whether KEY has a value.                                       |
`----------------------------------------------------------------------------*/

char const *
muscle_find_const (char const *key)
{
  muscle_entry probe;
  muscle_entry *result = NULL;

  probe.key = key;
  result = hash_lookup (muscle_table, &probe);
  if (result)
    return result->value;
  return NULL;
}


/*----------------------------------------------------------------------------.
| Find the value of muscle KEY.  Abort if muscle_insert was invoked more      |
| recently than muscle_grow for KEY since muscle_find can't return a          |
| char const *.                                                               |
`----------------------------------------------------------------------------*/

char *
muscle_find (char const *key)
{
  muscle_entry probe;
  muscle_entry *result = NULL;

  probe.key = key;
  result = hash_lookup (muscle_table, &probe);
  if (result)
    {
      aver (result->value == result->storage);
      return result->storage;
    }
  return NULL;
}


void
muscle_boundary_grow (char const *key, boundary bound)
{
  char *extension;
  MUSCLE_OBSTACK_SGROW (&muscle_obstack, bound.file);
  obstack_1grow (&muscle_obstack, ':');
  obstack_fgrow1 (&muscle_obstack, "%d", bound.line);
  obstack_1grow (&muscle_obstack, '.');
  obstack_fgrow1 (&muscle_obstack, "%d", bound.column);
  obstack_1grow (&muscle_obstack, '\0');
  extension = obstack_finish (&muscle_obstack);
  muscle_grow (key, extension, "");
  obstack_free (&muscle_obstack, extension);
}

void
muscle_location_grow (char const *key, location loc)
{
  muscle_grow (key, "[[", "");
  muscle_boundary_grow (key, loc.start);
  muscle_grow (key, "]], [[", "");
  muscle_boundary_grow (key, loc.end);
  muscle_grow (key, "]]", "");
}

#define MUSCLE_COMMON_DECODE(Value)                                           \
  case '$':                                                                   \
    aver (*++(Value) == ']');                                                 \
    aver (*++(Value) == '[');                                                 \
    obstack_sgrow (&muscle_obstack, "$");                                     \
    break;                                                                    \
  case '@':                                                                   \
    switch (*++(Value))                                                       \
      {                                                                       \
        case '@': obstack_sgrow (&muscle_obstack, "@" ); break;               \
        case '{': obstack_sgrow (&muscle_obstack, "[" ); break;               \
        case '}': obstack_sgrow (&muscle_obstack, "]" ); break;               \
        default: aver (false); break;                                         \
      }                                                                       \
    break;                                                                    \
  default:                                                                    \
    obstack_1grow (&muscle_obstack, *(Value));                                \
    break;

/* Reverse of MUSCLE_OBSTACK_SGROW.  */
static char *
muscle_string_decode (char const *key)
{
  char const *value;
  char *value_decoded;
  char *result;

  value = muscle_find_const (key);
  if (!value)
    return NULL;
  do {
    switch (*value)
      {
        MUSCLE_COMMON_DECODE (value)
        case '[':
        case ']':
          aver (false);
          break;
      }
  } while (*value++);
  value_decoded = obstack_finish (&muscle_obstack);
  result = xstrdup (value_decoded);
  obstack_free (&muscle_obstack, value_decoded);
  return result;
}

/* Reverse of muscle_location_grow.  */
static location
muscle_location_decode (char const *key)
{
  location loc;
  char const *value = muscle_find_const (key);
  aver (value);
  aver (*value == '[');
  aver (*++value == '[');
  while (*++value)
    switch (*value)
      {
        MUSCLE_COMMON_DECODE (value)
        case '[':
          aver (false);
          break;
        case ']':
          {
            char *boundary_str;
            aver (*++value == ']');
            obstack_1grow (&muscle_obstack, '\0');
            boundary_str = obstack_finish (&muscle_obstack);
            switch (*++value)
              {
                case ',':
                  boundary_set_from_string (&loc.start, boundary_str);
                  obstack_free (&muscle_obstack, boundary_str);
                  aver (*++value == ' ');
                  aver (*++value == '[');
                  aver (*++value == '[');
                  break;
                case '\0':
                  boundary_set_from_string (&loc.end, boundary_str);
                  obstack_free (&muscle_obstack, boundary_str);
                  return loc;
                  break;
                default:
                  aver (false);
                  break;
              }
          }
          break;
      }
  aver (false);
  return loc;
}

void
muscle_user_name_list_grow (char const *key, char const *user_name,
                            location loc)
{
  muscle_grow (key, "[[[[", ",");
  muscle_grow (key, user_name, "");
  muscle_grow (key, "]], ", "");
  muscle_location_grow (key, loc);
  muscle_grow (key, "]]", "");
}

/** If the \a variable name is obsolete, return the name to use,
 * otherwise \a variable. */
static
char const *
muscle_percent_variable_update (char const *variable)
{
  typedef struct
  {
    const char *obsolete;
    const char *updated;
  } conversion_type;
  const conversion_type conversion[] =
    {
      { "api.push_pull", "api.push-pull", },
      { "lr.keep_unreachable_states", "lr.keep-unreachable-states", },
      { "namespace", "api.namespace", },
    };
  int i;
  for (i = 0; i < sizeof conversion / sizeof *conversion; ++i)
    if (STREQ (conversion[i].obsolete, variable))
      return conversion[i].updated;
  return variable;
}

void
muscle_percent_define_insert (char const *variable, location variable_loc,
                              char const *value,
                              muscle_percent_define_how how)
{
  char const *name;
  char const *loc_name;
  char const *syncline_name;
  char const *how_name;

  /* Permit certain names with underscores for backward compatibility.  */
  variable = muscle_percent_variable_update (variable);

  name = UNIQSTR_CONCAT ("percent_define(", variable, ")");
  loc_name = UNIQSTR_CONCAT ("percent_define_loc(", variable, ")");
  syncline_name =
    UNIQSTR_CONCAT ("percent_define_syncline(", variable, ")");
  how_name = UNIQSTR_CONCAT ("percent_define_how(", variable, ")");

  /* Command-line options are processed before the grammar file.  */
  if (how == MUSCLE_PERCENT_DEFINE_GRAMMAR_FILE
      && muscle_find_const (name))
    {
      muscle_percent_define_how how_old =
        atoi (muscle_find_const (how_name));
      if (how_old == MUSCLE_PERCENT_DEFINE_F)
        return;
      complain_at (variable_loc, _("%%define variable %s redefined"),
                   quote (variable));
      complain_at (muscle_percent_define_get_loc (variable),
                   _("previous definition"));
    }

  MUSCLE_INSERT_STRING (name, value);
  muscle_insert (loc_name, "");
  muscle_location_grow (loc_name, variable_loc);
  muscle_insert (syncline_name, "");
  muscle_syncline_grow (syncline_name, variable_loc);
  muscle_user_name_list_grow ("percent_define_user_variables", variable,
                              variable_loc);
  MUSCLE_INSERT_INT (how_name, how);
}

/* This is used for backward compatibility, e.g., "%define api.pure"
   supersedes "%pure-parser".  */
void
muscle_percent_define_ensure (char const *variable, location loc,
                              bool value)
{
  char const *val = value ? "" : "false";
  char const *name;
  name = UNIQSTR_CONCAT ("percent_define(", variable, ")");

  /* %pure-parser is deprecated in favor of `%define api.pure', so use
     `%define api.pure' in a backward-compatible manner here.  First,
     don't complain if %pure-parser is specified multiple times.  */
  if (!muscle_find_const (name))
    muscle_percent_define_insert (variable, loc, val,
                                  MUSCLE_PERCENT_DEFINE_GRAMMAR_FILE);
  /* In all cases, use api.pure now so that the backend doesn't complain if
     the skeleton ignores api.pure, but do warn now if there's a previous
     conflicting definition from an actual %define.  */
  if (muscle_percent_define_flag_if (variable) != value)
    muscle_percent_define_insert (variable, loc, val,
                                  MUSCLE_PERCENT_DEFINE_GRAMMAR_FILE);
}

char *
muscle_percent_define_get (char const *variable)
{
  char const *name;
  char const *usage_name;
  char *value;

  name = UNIQSTR_CONCAT ("percent_define(", variable, ")");
  usage_name = UNIQSTR_CONCAT ("percent_define_bison_variables(",
                               variable, ")");

  muscle_insert (usage_name, "");
  value = muscle_string_decode (name);
  if (!value)
    value = xstrdup ("");
  return value;
}

location
muscle_percent_define_get_loc (char const *variable)
{
  char const *loc_name;
  loc_name = UNIQSTR_CONCAT ("percent_define_loc(", variable, ")");
  if (!muscle_find_const (loc_name))
    fatal(_("%s: undefined %%define variable %s"),
          "muscle_percent_define_get_loc", quote (variable));
  return muscle_location_decode (loc_name);
}

char const *
muscle_percent_define_get_syncline (char const *variable)
{
  char const *syncline_name;
  char const *syncline;
  syncline_name =
    UNIQSTR_CONCAT ("percent_define_syncline(", variable, ")");
  syncline = muscle_find_const (syncline_name);
  if (!syncline)
    fatal(_("%s: undefined %%define variable %s"),
          "muscle_percent_define_get_syncline", quote (variable));
  return syncline;
}

bool
muscle_percent_define_ifdef (char const *variable)
{
  char const *name;
  char const *usage_name;
  char const *value;

  name = UNIQSTR_CONCAT ("percent_define(", variable, ")");
  usage_name =
    UNIQSTR_CONCAT ("percent_define_bison_variables(", variable, ")");

  value = muscle_find_const (name);
  if (value)
    {
      muscle_insert (usage_name, "");
      return true;
    }

  return false;
}

bool
muscle_percent_define_flag_if (char const *variable)
{
  char const *invalid_boolean_name;
  bool result = false;

  invalid_boolean_name =
    UNIQSTR_CONCAT ("percent_define_invalid_boolean(", variable, ")");

  if (muscle_percent_define_ifdef (variable))
    {
      char *value = muscle_percent_define_get (variable);
      if (value[0] == '\0' || STREQ (value, "true"))
        result = true;
      else if (STREQ (value, "false"))
        result = false;
      else if (!muscle_find_const (invalid_boolean_name))
        {
          muscle_insert (invalid_boolean_name, "");
          complain_at(muscle_percent_define_get_loc (variable),
                      _("invalid value for %%define Boolean variable %s"),
                      quote (variable));
        }
      free (value);
    }
  else
    fatal(_("%s: undefined %%define variable %s"),
          "muscle_percent_define_flag", quote (variable));

  return result;
}

void
muscle_percent_define_default (char const *variable, char const *value)
{
  char const *name;
  char const *loc_name;
  char const *syncline_name;
  name = UNIQSTR_CONCAT ("percent_define(", variable, ")");
  loc_name = UNIQSTR_CONCAT ("percent_define_loc(", variable, ")");
  syncline_name =
    UNIQSTR_CONCAT ("percent_define_syncline(", variable, ")");
  if (!muscle_find_const (name))
    {
      location loc;
      MUSCLE_INSERT_STRING (name, value);
      loc.start.file = loc.end.file = "<default value>";
      loc.start.line = loc.end.line = -1;
      loc.start.column = loc.end.column = -1;
      muscle_insert (loc_name, "");
      muscle_location_grow (loc_name, loc);
      muscle_insert (syncline_name, "");
    }
}

void
muscle_percent_define_check_values (char const * const *values)
{
  for (; *values; ++values)
    {
      char const * const *variablep = values;
      char const *name;
      char *value;

      name = UNIQSTR_CONCAT ("percent_define(", *variablep, ")");

      value = muscle_string_decode (name);
      if (value)
        {
          for (++values; *values; ++values)
            {
              if (STREQ (value, *values))
                break;
            }
          if (!*values)
            {
              location loc = muscle_percent_define_get_loc (*variablep);
              complain_at(loc,
                          _("invalid value for %%define variable %s: %s"),
                          quote (*variablep), quote_n (1, value));
              for (values = variablep + 1; *values; ++values)
                complain_at (loc, _("accepted value: %s"), quote (*values));
            }
          else
            {
              while (*values)
                ++values;
            }
          free (value);
        }
      else
        fatal (_("%s: undefined %%define variable %s"),
               "muscle_percent_define_check_values", quote (*variablep));
    }
}

void
muscle_percent_code_grow (char const *qualifier, location qualifier_loc,
                          char const *code, location code_loc)
{
  char const *name;
  name = UNIQSTR_CONCAT ("percent_code(", qualifier, ")");
  muscle_code_grow (name, code, code_loc);
  muscle_user_name_list_grow ("percent_code_user_qualifiers", qualifier,
                               qualifier_loc);
}


/*------------------------------------------------.
| Output the definition of ENTRY as a m4_define.  |
`------------------------------------------------*/

static inline bool
muscle_m4_output (muscle_entry *entry, FILE *out)
{
  fprintf (out, "m4_define([b4_%s],\n", entry->key);
  fprintf (out, "[[%s]])\n\n\n", entry->value);
  return true;
}

static bool
muscle_m4_output_processor (void *entry, void *out)
{
  return muscle_m4_output (entry, out);
}


/*----------------------------------------------------------------.
| Output the definition of all the current muscles into a list of |
| m4_defines.                                                     |
`----------------------------------------------------------------*/

void
muscles_m4_output (FILE *out)
{
  hash_do_for_each (muscle_table, muscle_m4_output_processor, out);
}