Add native Windows binary for gperf.

gperf/src/gperf/3.0.1/gperf-3.0.1-src/src/positions.icc

Index: gperf/src/gperf/3.0.1/gperf-3.0.1-src/src/positions.icc 
=================================================================== 
--- gperf/src/gperf/3.0.1/gperf-3.0.1-src/src/positions.icc	(revision 0) 
+++ gperf/src/gperf/3.0.1/gperf-3.0.1-src/src/positions.icc	(revision 0) 
@@ -0,0 +1,285 @@ 
+/* Inline Functions for positions.{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. */ 
+ 
+// This needs: 
+//#include <string.h> 
+ 
+/* ---------------------------- Class Positions ---------------------------- */ 
+ 
+/* Constructors. */ 
+ 
+INLINE 
+Positions::Positions () 
+ : _useall (false), 
+ _size (0) 
+{ 
+} 
+ 
+INLINE 
+Positions::Positions (int pos1) 
+ : _useall (false), 
+ _size (1) 
+{ 
+ _positions[0] = pos1; 
+} 
+ 
+INLINE 
+Positions::Positions (int pos1, int pos2) 
+ : _useall (false), 
+ _size (2) 
+{ 
+ _positions[0] = pos1; 
+ _positions[1] = pos2; 
+} 
+ 
+/* Copy constructor. */ 
+ 
+INLINE 
+Positions::Positions (const Positions& src) 
+ : _useall (src._useall), 
+ _size (src._size) 
+{ 
+ memcpy (_positions, src._positions, _size * sizeof (_positions[0])); 
+} 
+ 
+/* Assignment operator. */ 
+ 
+INLINE Positions& 
+Positions::operator= (const Positions& src) 
+{ 
+ _useall = src._useall; 
+ _size = src._size; 
+ memcpy (_positions, src._positions, _size * sizeof (_positions[0])); 
+ return *this; 
+} 
+ 
+/* Accessors. */ 
+ 
+INLINE bool 
+Positions::is_useall () const 
+{ 
+ return _useall; 
+} 
+ 
+INLINE int 
+Positions::operator[] (unsigned int index) const 
+{ 
+ return _positions[index]; 
+} 
+ 
+INLINE unsigned int 
+Positions::get_size () const 
+{ 
+ return _size; 
+} 
+ 
+/* Write access. */ 
+ 
+INLINE void 
+Positions::set_useall (bool useall) 
+{ 
+ _useall = useall; 
+ if (useall) 
+ { 
+ /* The positions are 0, 1, ..., MAX_KEY_POS-1, in descending order. */ 
+ _size = MAX_KEY_POS; 
+ int *ptr = _positions; 
+ for (int i = MAX_KEY_POS - 1; i >= 0; i--) 
+ *ptr++ = i; 
+ } 
+} 
+ 
+INLINE int * 
+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 () 
+{ 
+ if (_useall) 
+ return true; 
+ 
+ /* Bubble sort. */ 
+ bool duplicate_free = true; 
+ int *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; 
+} 
+ 
+/* Creates an iterator, returning the positions in descending order. */ 
+INLINE PositionIterator 
+Positions::iterator () const 
+{ 
+ return PositionIterator (*this); 
+} 
+ 
+/* Creates an iterator, returning the positions in descending order, 
+ that apply to strings of length <= maxlen. */ 
+INLINE PositionIterator 
+Positions::iterator (int maxlen) const 
+{ 
+ return PositionIterator (*this, maxlen); 
+} 
+ 
+/* Creates an iterator, returning the positions in ascending order. */ 
+INLINE PositionReverseIterator 
+Positions::reviterator () const 
+{ 
+ return PositionReverseIterator (*this); 
+} 
+ 
+/* Creates an iterator, returning the positions in ascending order, 
+ that apply to strings of length <= maxlen. */ 
+INLINE PositionReverseIterator 
+Positions::reviterator (int maxlen) const 
+{ 
+ return PositionReverseIterator (*this, maxlen); 
+} 
+ 
+/* ------------------------- Class PositionIterator ------------------------ */ 
+ 
+/* Initializes an iterator through POSITIONS. */ 
+INLINE 
+PositionIterator::PositionIterator (Positions const& positions) 
+ : _set (positions), 
+ _index (0) 
+{ 
+} 
+ 
+/* Initializes an iterator through POSITIONS, ignoring positions >= maxlen. */ 
+INLINE 
+PositionIterator::PositionIterator (Positions const& positions, int maxlen) 
+ : _set (positions) 
+{ 
+ if (positions._useall) 
+ _index = (maxlen <= Positions::MAX_KEY_POS ? Positions::MAX_KEY_POS - maxlen : 0); 
+ else 
+ { 
+ unsigned int index; 
+ for (index = 0; 
+ index < positions._size && positions._positions[index] >= maxlen; 
+ index++) 
+ ; 
+ _index = index; 
+ } 
+} 
+ 
+/* Retrieves the next position, or EOS past the end. */ 
+INLINE int 
+PositionIterator::next () 
+{ 
+ return (_index < _set._size ? _set._positions[_index++] : EOS); 
+} 
+ 
+/* Returns the number of remaining positions, i.e. how often next() will 
+ return a value != EOS. */ 
+INLINE unsigned int 
+PositionIterator::remaining () const 
+{ 
+ return _set._size - _index; 
+} 
+ 
+/* Copy constructor. */ 
+INLINE 
+PositionIterator::PositionIterator (const PositionIterator& src) 
+ : _set (src._set), 
+ _index (src._index) 
+{ 
+} 
+ 
+/* --------------------- Class PositionReverseIterator --------------------- */ 
+ 
+/* Initializes an iterator through POSITIONS. */ 
+INLINE 
+PositionReverseIterator::PositionReverseIterator (Positions const& positions) 
+ : _set (positions), 
+ _index (_set._size), 
+ _minindex (0) 
+{ 
+} 
+ 
+/* Initializes an iterator through POSITIONS, ignoring positions >= maxlen. */ 
+INLINE 
+PositionReverseIterator::PositionReverseIterator (Positions const& positions, int maxlen) 
+ : _set (positions), 
+ _index (_set._size) 
+{ 
+ if (positions._useall) 
+ _minindex = (maxlen <= Positions::MAX_KEY_POS ? Positions::MAX_KEY_POS - maxlen : 0); 
+ else 
+ { 
+ unsigned int index; 
+ for (index = 0; 
+ index < positions._size && positions._positions[index] >= maxlen; 
+ index++) 
+ ; 
+ _minindex = index; 
+ } 
+} 
+ 
+/* Retrieves the next position, or EOS past the end. */ 
+INLINE int 
+PositionReverseIterator::next () 
+{ 
+ return (_index > _minindex ? _set._positions[--_index] : EOS); 
+} 
+ 
+/* Returns the number of remaining positions, i.e. how often next() will 
+ return a value != EOS. */ 
+INLINE unsigned int 
+PositionReverseIterator::remaining () const 
+{ 
+ return _index - _minindex; 
+} 
+ 
+/* Copy constructor. */ 
+INLINE 
+PositionReverseIterator::PositionReverseIterator (const PositionReverseIterator& src) 
+ : _set (src._set), 
+ _index (src._index), 
+ _minindex (src._minindex) 
+{ 
+}