/* Inline Functions for options.{h,cc}.

   Copyright (C) 1989-1998, 2000, 2002 Free Software Foundation, Inc.
   Written by Douglas C. Schmidt <schmidt@ics.uci.edu>
   and Bruno Haible <bruno@clisp.org>.

   This file is part of GNU GPERF.

   GNU GPERF 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 2, or (at your option)
   any later version.

   GNU GPERF 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; see the file COPYING.
   If not, write to the Free Software Foundation, Inc.,
   59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */

/* ---------------------------- Class Positions ---------------------------- */

/* Constructors.  */

INLINE
Positions::Positions ()
  : _size (0)
{
}

INLINE
Positions::Positions (int key1)
  : _size (1)
{
  _positions[0] = key1;
}

INLINE
Positions::Positions (int key1, int key2)
  : _size (2)
{
  _positions[0] = key1;
  _positions[1] = key2;
}

/* Accessors.  */

INLINE int
Positions::operator[] (unsigned int index) const
{
  return _positions[index];
}

INLINE unsigned int
Positions::get_size () const
{
  return _size;
}

/* Write access.  */

INLINE unsigned char *
Positions::pointer ()
{
  return _positions;
}

INLINE void
Positions::set_size (unsigned int size)
{
  _size = size;
}

/* Sorts the array in reverse order.
   Returns true if there are no duplicates, false otherwise.  */
INLINE bool
Positions::sort ()
{
  /* Bubble sort.  */
  bool duplicate_free = true;
  unsigned char *base = _positions;
  unsigned int len = _size;

  for (unsigned int i = 1; i < len; i++)
    {
      unsigned int j;
      int tmp;

      for (j = i, tmp = base[j]; j > 0 && tmp >= base[j - 1]; j--)
        if ((base[j] = base[j - 1]) == tmp) /* oh no, a duplicate!!! */
          duplicate_free = false;

      base[j] = tmp;
    }

  return duplicate_free;
}

/* ------------------------- Class PositionIterator ------------------------ */

/* Initializes an iterator through POSITIONS.  */
INLINE
PositionIterator::PositionIterator (Positions const& positions)
  : _set (positions),
    _index (0)
{
}

/* Retrieves the next position, or EOS past the end.  */
INLINE int
PositionIterator::next ()
{
  return (_index < _set._size ? _set._positions[_index++] : EOS);
}

/* ----------------------------- Class Options ----------------------------- */

/* Tests a given boolean option.  Returns true if set, false otherwise.  */
INLINE bool
Options::operator[] (Option_Type option) const
{
  return _option_word & option;
}

/* Sets a given boolean option.  */
INLINE void
Options::set (Option_Type option)
{
  _option_word |= option;
}

/* Returns the input file name.  */
INLINE const char *
Options::get_input_file_name () const
{
  return _input_file_name;
}

/* Returns the output file name.  */
INLINE const char *
Options::get_output_file_name () const
{
  return _output_file_name;
}

/* Returns the iterations value.  */
INLINE int
Options::get_iterations () const
{
  return _iterations;
}

/* Returns the jump value.  */
INLINE int
Options::get_jump () const
{
  return _jump;
}

/* Returns the initial associated character value.  */
INLINE int
Options::get_initial_asso_value () const
{
  return _initial_asso_value;
}

/* Returns the number of iterations for finding finding good asso_values.  */
INLINE int
Options::get_asso_iterations () const
{
  return _asso_iterations;
}

/* Returns the total number of switch statements to generate.  */
INLINE int
Options::get_total_switches () const
{
  return _total_switches;
}

/* Returns the factor by which to multiply the generated table's size.  */
INLINE int
Options::get_size_multiple () const
{
  return _size_multiple;
}

/* Returns the generated function name.  */
INLINE const char *
Options::get_function_name () const
{
  return _function_name;
}

/* Returns the keyword key name.  */
INLINE const char *
Options::get_slot_name () const
{
  return _slot_name;
}

/* Returns the struct initializer suffix.  */
INLINE const char *
Options::get_initializer_suffix () const
{
  return _initializer_suffix;
}

/* Returns the generated class name.  */
INLINE const char *
Options::get_class_name () const
{
  return _class_name;
}

/* Returns the hash function name.  */
INLINE const char *
Options::get_hash_name () const
{
  return _hash_name;
}

/* Returns the hash table array name.  */
INLINE const char *
Options::get_wordlist_name () const
{
  return _wordlist_name;
}

/* Returns the string used to delimit keywords from other attributes.  */
INLINE const char *
Options::get_delimiters () const
{
  return _delimiters;
}

/* Returns key positions.
   Only to be called if !options[ALLCHARS].  */
INLINE const Positions&
Options::get_key_positions () const
{
  return _key_positions;
}

/* Returns total distinct key positions.
   Only to be called if !options[ALLCHARS].  */
INLINE int
Options::get_max_keysig_size () const
{
  return _key_positions.get_size();
}