/usr/include/lexertl/partition/equivset.hpp is in libpuma-dev 1:2.1-2+b1.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 | // equivset.hpp
// Copyright (c) 2005-2015 Ben Hanson (http://www.benhanson.net/)
//
// Distributed under the Boost Software License, Version 1.0. (See accompanying
// file licence_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#ifndef LEXERTL_EQUIVSET_HPP
#define LEXERTL_EQUIVSET_HPP
#include <algorithm>
#include "../parser/tree/node.hpp"
#include <set>
namespace lexertl
{
namespace detail
{
template<typename id_type>
struct basic_equivset
{
typedef std::set<id_type> index_set;
typedef std::vector<id_type> index_vector;
// Not owner of nodes:
typedef basic_node<id_type> node;
typedef std::vector<node *> node_vector;
index_vector _index_vector;
id_type _id;
bool _greedy;
node_vector _followpos;
basic_equivset() :
_index_vector(),
_id(0),
_greedy(true),
_followpos()
{
}
basic_equivset(const index_set &index_set_, const id_type id_,
const bool greedy_, const node_vector &followpos_) :
_index_vector(index_set_.begin(), index_set_.end()),
_id(id_),
_greedy(greedy_),
_followpos(followpos_)
{
}
bool empty() const
{
return _index_vector.empty() && _followpos.empty();
}
void intersect(basic_equivset &rhs_, basic_equivset &overlap_)
{
intersect_indexes(rhs_._index_vector, overlap_._index_vector);
if (!overlap_._index_vector.empty())
{
// Note that the LHS takes priority in order to
// respect rule ordering priority in the lex spec.
overlap_._id = _id;
overlap_._greedy = _greedy;
overlap_._followpos = _followpos;
typename node_vector::const_iterator overlap_begin_ =
overlap_._followpos.begin();
typename node_vector::const_iterator overlap_end_ =
overlap_._followpos.end();
typename node_vector::const_iterator rhs_iter_ =
rhs_._followpos.begin();
typename node_vector::const_iterator rhs_end_ =
rhs_._followpos.end();
for (; rhs_iter_ != rhs_end_; ++rhs_iter_)
{
node *node_ = *rhs_iter_;
if (std::find(overlap_begin_, overlap_end_, node_) ==
overlap_end_)
{
overlap_._followpos.push_back(node_);
overlap_begin_ = overlap_._followpos.begin();
overlap_end_ = overlap_._followpos.end();
}
}
if (_index_vector.empty())
{
_followpos.clear();
}
if (rhs_._index_vector.empty())
{
rhs_._followpos.clear();
}
}
}
private:
void intersect_indexes(index_vector &rhs_, index_vector &overlap_)
{
typename index_vector::iterator iter_ = _index_vector.begin();
typename index_vector::iterator end_ = _index_vector.end();
typename index_vector::iterator rhs_iter_ = rhs_.begin();
typename index_vector::iterator rhs_end_ = rhs_.end();
while (iter_ != end_ && rhs_iter_ != rhs_end_)
{
const id_type index_ = *iter_;
const id_type rhs_index_ = *rhs_iter_;
if (index_ < rhs_index_)
{
++iter_;
}
else if (index_ > rhs_index_)
{
++rhs_iter_;
}
else
{
overlap_.push_back(index_);
iter_ = _index_vector.erase(iter_);
end_ = _index_vector.end();
rhs_iter_ = rhs_.erase(rhs_iter_);
rhs_end_ = rhs_.end();
}
}
}
};
}
}
#endif
|