gem5/base/range.hh
Steve Reinhardt 548b4a1cb0 Change "Foo& foo" declarations to "Foo &foo".
This primarily to be internally consistent (sometimes we used one,
sometimes the other, even within the same line of code!).
I picked the latter to be symmetric with "Foo *foo".

base/cprintf_formats.hh:
base/range.hh:
base/refcnt.hh:
base/res_list.hh:
base/statistics.hh:
base/str.hh:
cpu/exec_context.hh:
cpu/simple_cpu/simple_cpu.cc:
cpu/simple_cpu/simple_cpu.hh:
sim/serialize.cc:
sim/serialize.hh:
sim/syscall_emul.hh:
    Change "Foo& foo" declarations to "Foo &foo".

--HG--
extra : convert_revision : ca1b0e85a578b539214bda3b8d61ac23792f2e87
2004-02-02 15:55:35 -08:00

260 lines
6.1 KiB
C++

/*
* Copyright (c) 2003 The Regents of The University of Michigan
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met: redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer;
* redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution;
* neither the name of the copyright holders nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef __RANGE_HH__
#define __RANGE_HH__
#include <assert.h>
#include "base/intmath.hh"
#include "base/str.hh"
template<class T>
class Range
{
private:
bool valid;
public:
T start;
T end;
public:
Range() {}
Range(const Range &r) { operator=(r); }
Range(const T &s, const T &e)
: start(s), end(e)
{
valid = (start <= end);
}
Range(const std::string &s) { valid = parse(s); }
~Range() {}
int compare(const T &p);
bool parse(const std::string &s);
const Range &operator=(const Range &r);
bool isValid() const { return valid; }
};
template<class T>
inline int
Range<T>::compare(const T &p)
{
assert(isValid());
if (p < start)
return -1;
else if (p > end)
return 1;
else
return 0;
}
// Parse a range string
//
// Ranges are in the following format:
// <range> := {<start_val>}:{<end>}
// <end> := <end_val> | +<delta>
template<class T>
inline bool
Range<T>::parse(const std::string &str)
{
std::vector<std::string> values;
tokenize(values, str, ':');
T thestart, theend;
if (values.size() != 2)
return false;
std::string s = values[0];
std::string e = values[1];
if (!to_number(s, thestart))
return false;
bool increment = (e[0] == '+');
if (increment)
e = e.substr(1);
if (!to_number(e, theend))
return false;
if (increment)
theend += thestart;
start = thestart;
end = theend;
if (start > end)
return false;
return true;
}
template<class T>
inline const Range<T> &
Range<T>::operator=(const Range<T> &r)
{
if (this != &r) {
start = r.start;
end = r.end;
valid = r.valid;
}
else {
valid = false;
}
return *this;
}
template<class T>
inline std::ostream &
operator<<(std::ostream &o, const Range<T> &r)
{
// don't currently support output of invalid ranges
assert(r.isValid());
o << r.start << ":" << r.end;
return o;
}
//////////////////////////////////////////
//
// Compare two ranges
//
template<class T>
inline bool
operator==(const Range<T> &l, const Range<T> &r)
{
// ranges must both be valid to be equal
return (l.isValid() && r.isValid() &&
(l.start == r.start) && (l.end == r.end));
}
template<class T>
inline bool
operator!=(const Range<T> &l, const Range<T> &r)
{
// for symmetry with ==, an invalid range is not equal to any other
return (!l.isValid() || !r.isValid() ||
(l.start != r.start) || (l.end != r.end));
}
//////////////////////////////////////////
//
// Compare position to a range
//
// - 'pos == range' indicates that position pos is within the given range.
// This test always returns false if the range is invalid.
//
// - 'pos < range' and 'pos > range' indicate that the position is
// before the start of or after the end of the range, respectively.
// The range must be valid for these comparisons to be made.
//
// All other comparisons do the obvious thing based on these definitions.
//
//
//
// Basic comparisons
//
template<class T>
inline bool
operator==(const T &pos, const Range<T> &range)
{ return range.isValid() && pos >= range.start && pos <= range.end; }
template<class T>
inline bool
operator<(const T &pos, const Range<T> &range)
{ assert(range.isValid()); return pos < range.start; }
template<class T>
inline bool
operator>(const T &pos, const Range<T> &range)
{ assert(range.isValid()); return pos > range.end; }
//
// Derived comparisons
//
template<class T>
inline bool
operator<=(const T &pos, const Range<T> &range)
{ assert(range.isValid()); return pos <= range.end; }
template<class T>
inline bool
operator>=(const T &pos, const Range<T> &range)
{ assert(range.isValid()); return pos >= range.start; }
template<class T>
inline bool
operator!=(const T &pos, const Range<T> &range)
{ return !(pos == range); }
//
// Define symmetric comparisons based on above
//
template<class T>
inline bool
operator>(const Range<T> &range, const T &pos)
{ return pos < range; }
template<class T>
inline bool
operator<(const Range<T> &range, const T &pos)
{ return pos > range; }
template<class T>
inline bool
operator<=(const Range<T> &range, const T &pos)
{ return pos >= range; }
template<class T>
inline bool
operator>=(const Range<T> &range, const T &pos)
{ return pos <= range; }
template<class T>
inline bool
operator==(const Range<T> &range, const T &pos)
{ return (pos == range); }
template<class T>
inline bool
operator!=(const Range<T> &range, const T &pos)
{ return (pos != range); }
#endif // __RANGE_HH__