sfos/ledger
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Whitespace cleanup.

Browse source
This commit is contained in:
John Wiegley 2007-05-21 20:45:13 +00:00
parent fdfc37adf9
commit d23ed020ab
24 changed files with 254 additions and 247 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

11
Makefile.am
View file

@ -25,9 +25,16 @@ WARNFLAGS = -Wall #-pedantic-errors
#WARNFLAGS += -Wmissing-field-initializers -Wstrict-null-sentinel
#WARNFLAGS += -Wold-style-cast -Woverloaded-virtual
libledger_la_CPPFLAGS = -I$(top_builddir)/gdtoa -I$(srcdir)/gdtoa \
-I$(srcdir)/src $(WARNFLAGS)
libledger_la_LDFLAGS = -release $(PACKAGE_VERSION)
libledger_la_CPPFLAGS = $(WARNFLAGS) \
-I$(top_builddir)/gdtoa \
-I$(srcdir)/gdtoa \
-I$(srcdir)/src \
-I$(srcdir)/src/utility \
-I$(srcdir)/src/numerics \
-I$(srcdir)/src/data \
-I$(srcdir)/src/traversal \
-I$(srcdir)/src/driver
libledger_la_SOURCES = \
src/utility/utils.cc \

122
configure.in
View file

@ -55,31 +55,31 @@ AC_CACHE_CHECK(
[AC_LANG_PUSH(C++)
AC_LINK_IFELSE(
[AC_LANG_PROGRAM(
[[#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>]],
[[int status, pfd[2];
status = pipe(pfd);
status = fork();
if (status < 0) {
;
} else if (status == 0) {
char *arg0;
[[#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>]],
[[int status, pfd[2];
status = pipe(pfd);
status = fork();
if (status < 0) {
;
} else if (status == 0) {
char *arg0;
status = dup2(pfd[0], STDIN_FILENO);
status = dup2(pfd[0], STDIN_FILENO);
close(pfd[1]);
close(pfd[0]);
close(pfd[1]);
close(pfd[0]);
execlp("", arg0, (char *)0);
perror("execl");
exit(1);
} else {
close(pfd[0]);
}]])],
execlp("", arg0, (char *)0);
perror("execl");
exit(1);
} else {
close(pfd[0]);
}]])],
[pipes_avail=true],
[pipes_avail=false])
AC_LANG_POP])
@ -119,26 +119,26 @@ AC_CACHE_CHECK(
AC_LANG_PUSH(C++)
AC_LINK_IFELSE(
[AC_LANG_PROGRAM(
[[#include <boost/date_time/posix_time/posix_time.hpp>
#include <boost/date_time/gregorian/gregorian.hpp>
#include <boost/date_time/local_time_adjustor.hpp>
#include <boost/date_time/time_duration.hpp>
[[#include <boost/date_time/posix_time/posix_time.hpp>
#include <boost/date_time/gregorian/gregorian.hpp>
#include <boost/date_time/local_time_adjustor.hpp>
#include <boost/date_time/time_duration.hpp>
using namespace boost::posix_time;
using namespace boost::date_time;
using namespace boost::posix_time;
using namespace boost::date_time;
#include <ctime>
#include <ctime>
inline ptime time_to_system_local(const ptime& when) {
struct std::tm tm_gmt = to_tm(when);
return from_time_t(mktime(&tm_gmt));
}]],
[[ptime t10 = ptime(boost::gregorian::from_string("2007-01-15"),
ptime::time_duration_type());
inline ptime time_to_system_local(const ptime& when) {
struct std::tm tm_gmt = to_tm(when);
return from_time_t(mktime(&tm_gmt));
}]],
[[ptime t10 = ptime(boost::gregorian::from_string("2007-01-15"),
ptime::time_duration_type());
ptime t12 = time_to_system_local(t10);
ptime t12 = time_to_system_local(t10);
return t10 != t12;]])],
return t10 != t12;]])],
[boost_date_time_cpplib_avail=true],
[boost_date_time_cpplib_avail=false])
AC_LANG_POP
@ -159,8 +159,8 @@ AC_CACHE_CHECK(
AC_LANG_PUSH(C++)
AC_LINK_IFELSE(
[AC_LANG_PROGRAM(
[[#include <boost/filesystem/path.hpp>]],
[[boost::filesystem::path this_path("Hello");]])],
[[#include <boost/filesystem/path.hpp>]],
[[boost::filesystem::path this_path("Hello");]])],
[boost_filesystem_cpplib_avail=true],
[boost_filesystem_cpplib_avail=false])
AC_LANG_POP
@ -233,8 +233,8 @@ if [test x$ofx = xtrue ]; then
AC_LANG_PUSH(C++)
AC_LINK_IFELSE(
[AC_LANG_PROGRAM(
[[#include <libofx.h>]],
[[LibofxContextPtr libofx_context = libofx_get_new_context();]])],
[[#include <libofx.h>]],
[[LibofxContextPtr libofx_context = libofx_get_new_context();]])],
[libofx_avail=true],
[libofx_avail=false])
AC_LANG_POP
@ -271,16 +271,16 @@ if [test x$python = xtrue ]; then
LIBS="-lboost_python$BOOST_SUFFIX -lpython$PYTHON_VERSION $LIBS"
AC_LANG_PUSH(C++)
AC_LINK_IFELSE(
[AC_LANG_PROGRAM(
[[#include <boost/python.hpp>
using namespace boost::python;
class foo {};
BOOST_PYTHON_MODULE(samp) {
class_< foo > ("foo") ;
}]],
[[return 0]])],
[boost_python_cpplib_avail=true],
[boost_python_cpplib_avail=false])
[AC_LANG_PROGRAM(
[[#include <boost/python.hpp>
using namespace boost::python;
class foo {};
BOOST_PYTHON_MODULE(samp) {
class_< foo > ("foo") ;
}]],
[[return 0]])],
[boost_python_cpplib_avail=true],
[boost_python_cpplib_avail=false])
AC_LANG_POP
LIBS=$boost_python_save_libs])
@ -306,16 +306,16 @@ AC_CACHE_CHECK(
AC_LANG_PUSH(C++)
AC_LINK_IFELSE(
[AC_LANG_PROGRAM(
[[#include <cppunit/CompilerOutputter.h>
#include <cppunit/TestResult.h>
#include <cppunit/TestResultCollector.h>
#include <cppunit/TestRunner.h>
#include <cppunit/TextTestProgressListener.h>
#include <cppunit/BriefTestProgressListener.h>
#include <cppunit/XmlOutputter.h>
#include <cppunit/extensions/TestFactoryRegistry.h>]],
[[CPPUNIT_NS::TestResult controller;
CPPUNIT_NS::TestResultCollector result;]])],
[[#include <cppunit/CompilerOutputter.h>
#include <cppunit/TestResult.h>
#include <cppunit/TestResultCollector.h>
#include <cppunit/TestRunner.h>
#include <cppunit/TextTestProgressListener.h>
#include <cppunit/BriefTestProgressListener.h>
#include <cppunit/XmlOutputter.h>
#include <cppunit/extensions/TestFactoryRegistry.h>]],
[[CPPUNIT_NS::TestResult controller;
CPPUNIT_NS::TestResultCollector result;]])],
[cppunit_avail=true],
[cppunit_avail=false])
AC_LANG_POP

2
src/data/journal.h
View file

@ -358,7 +358,7 @@ bool run_hooks(std::list<T>& list, Data& item, bool post) {
typedef std::list<entry_t *> entries_list;
typedef std::list<auto_entry_t *> auto_entries_list;
typedef std::list<period_entry_t *> period_entries_list;
typedef std::list<path> path_list;
typedef std::list<path> path_list;
typedef std::list<string> strings_list;
class journal_t

7
src/numerics/amount.cc
View file

@ -43,6 +43,7 @@
#include "amount.h"
#include "binary.h"
#include "parser.h"
namespace ledger {
@ -1218,7 +1219,7 @@ namespace {
void amount_t::read(std::istream& in)
{
using ledger::binary;
using namespace ledger::binary;
// Read in the commodity for this amount
@ -1266,7 +1267,7 @@ void amount_t::read(std::istream& in)
void amount_t::read(const char *& data)
{
using ledger::binary;
using namespace ledger::binary;
// Read in the commodity for this amount
@ -1323,7 +1324,7 @@ void amount_t::read(const char *& data)
void amount_t::write(std::ostream& out, bool optimized) const
{
using ledger::binary;
using namespace ledger::binary;
// Write out the commodity for this amount

2
src/numerics/amount.h
View file

@ -347,7 +347,7 @@ public:
return *this;
}
amount_t round(const optional<precision_t>& prec) const;
amount_t round(const optional<precision_t>& prec = none) const;
amount_t unround() const;
amount_t reduce() const {

26
src/numerics/balance.h
View file

@ -60,19 +60,19 @@ DECLARE_EXCEPTION(balance_error);
*/
class balance_t
: public equality_comparable<balance_t,
equality_comparable<balance_t, amount_t,
equality_comparable<balance_t, double,
equality_comparable<balance_t, unsigned long,
equality_comparable<balance_t, long,
additive<balance_t,
additive<balance_t, amount_t,
additive<balance_t, double,
additive<balance_t, unsigned long,
additive<balance_t, long,
multiplicative<balance_t, amount_t,
multiplicative<balance_t, double,
multiplicative<balance_t, unsigned long,
multiplicative<balance_t, long> > > > > > > > > > > > > >
equality_comparable<balance_t, amount_t,
equality_comparable<balance_t, double,
equality_comparable<balance_t, unsigned long,
equality_comparable<balance_t, long,
additive<balance_t,
additive<balance_t, amount_t,
additive<balance_t, double,
additive<balance_t, unsigned long,
additive<balance_t, long,
multiplicative<balance_t, amount_t,
multiplicative<balance_t, double,
multiplicative<balance_t, unsigned long,
multiplicative<balance_t, long> > > > > > > > > > > > > >
{
public:
typedef std::map<const commodity_t *, amount_t> amounts_map;

83
src/numerics/balpair.h
View file

@ -56,24 +56,24 @@
namespace ledger {
class balance_pair_t
: public equality_comparable<balance_pair_t,
equality_comparable<balance_pair_t, balance_t,
equality_comparable<balance_pair_t, amount_t,
equality_comparable<balance_pair_t, double,
equality_comparable<balance_pair_t, unsigned long,
equality_comparable<balance_pair_t, long,
additive<balance_pair_t,
additive<balance_pair_t, balance_t,
additive<balance_pair_t, amount_t,
additive<balance_pair_t, double,
additive<balance_pair_t, unsigned long,
additive<balance_pair_t, long,
multiplicative<balance_pair_t, amount_t,
multiplicative<balance_pair_t, balance_t,
multiplicative<balance_pair_t, double,
multiplicative<balance_pair_t, unsigned long,
multiplicative2<balance_pair_t, long, balance_t
> > > > > > > > > > > > > > > > >
: public balance_t,
public equality_comparable<balance_pair_t,
equality_comparable<balance_pair_t, balance_t,
equality_comparable<balance_pair_t, amount_t,
equality_comparable<balance_pair_t, double,
equality_comparable<balance_pair_t, unsigned long,
equality_comparable<balance_pair_t, long,
additive<balance_pair_t,
additive<balance_pair_t, balance_t,
additive<balance_pair_t, amount_t,
additive<balance_pair_t, double,
additive<balance_pair_t, unsigned long,
additive<balance_pair_t, long,
multiplicative<balance_pair_t, amount_t,
multiplicative<balance_pair_t, balance_t,
multiplicative<balance_pair_t, double,
multiplicative<balance_pair_t, unsigned long,
multiplicative<balance_pair_t, long> > > > > > > > > > > > > > > > >
{
/**
* The `cost' member of a balance pair tracks the cost associated
@ -216,33 +216,22 @@ public:
// comparison
bool operator==(const balance_pair_t& bal_pair) const {
return quantity == bal_pair.quantity;
return quantity() == bal_pair.quantity();
}
bool operator==(const balance_t& bal) const {
return quantity == bal;
return quantity() == bal;
}
bool operator==(const amount_t& amt) const {
return quantity == amt;
}
balance_pair_t& operator*=(const amount_t& amt) {
quantity *= amt;
if (cost)
*cost *= amt;
return *this;
}
balance_pair_t& operator/=(const amount_t& amt) {
quantity /= amt;
if (cost)
*cost /= amt;
return *this;
return quantity() == amt;
}
// unary negation
void in_place_negate() {
#if 0
quantity.in_place_negate();
if (cost)
cost->in_place_negate();
#endif
}
balance_pair_t negate() const {
balance_pair_t temp = *this;
@ -255,57 +244,67 @@ public:
// test for non-zero (use ! for zero)
operator bool() const {
return quantity;
return quantity();
}
bool is_realzero() const {
#if 0
return ((! cost || cost->is_realzero()) && quantity.is_realzero());
#else
return false;
#endif
}
balance_pair_t abs() const {
#if 0
balance_pair_t temp = *this;
temp.quantity = temp.quantity.abs();
if (temp.cost)
temp.cost = temp.cost->abs();
return temp;
#else
return balance_pair_t();
#endif
}
optional<amount_t>
commodity_amount(const optional<const commodity_t&>& commodity = none) const {
return quantity.commodity_amount(commodity);
return quantity().commodity_amount(commodity);
}
optional<balance_t> value(const optional<moment_t>& moment = none) const {
return quantity.value(moment);
return quantity().value(moment);
}
balance_t
strip_annotations(const bool keep_price = amount_t::keep_price,
const bool keep_date = amount_t::keep_date,
const bool keep_tag = amount_t::keep_tag) const {
return quantity.strip_annotations(keep_price, keep_date, keep_tag);
return quantity().strip_annotations(keep_price, keep_date, keep_tag);
}
void print(std::ostream& out, const int first_width,
const int latter_width = -1) const {
quantity.print(out, first_width, latter_width);
quantity().print(out, first_width, latter_width);
}
balance_pair_t& add(const amount_t& amt,
const optional<amount_t>& a_cost = none) {
#if 0
if (a_cost && ! cost)
cost = quantity;
quantity += amt;
if (cost)
*cost += a_cost ? *a_cost : amt;
#endif
return *this;
}
bool valid() {
return quantity.valid() && (! cost || cost->valid());
return quantity().valid() && (! cost || cost->valid());
}
void in_place_reduce() {
quantity.in_place_reduce();
quantity().in_place_reduce();
if (cost) cost->in_place_reduce();
}
balance_pair_t reduce() const {
@ -320,7 +319,7 @@ public:
inline std::ostream& operator<<(std::ostream& out,
const balance_pair_t& bal_pair) {
bal_pair.quantity.print(out, 12);
bal_pair.quantity().print(out, 12);
return out;
}

2
src/numerics/commodity.h
View file

@ -256,7 +256,7 @@ inline std::ostream& operator<<(std::ostream& out, const annotation_t& details)
class annotated_commodity_t
: public commodity_t,
public equality_comparable<annotated_commodity_t,
equality_comparable2<annotated_commodity_t, commodity_t,
equality_comparable2<annotated_commodity_t, commodity_t,
noncopyable> >
{
public:

12
src/numerics/value.h
View file

@ -51,12 +51,12 @@ namespace xml {
class value_t
: public ordered_field_operators<value_t,
ordered_field_operators<value_t, balance_pair_t,
ordered_field_operators<value_t, balance_t,
ordered_field_operators<value_t, amount_t,
ordered_field_operators<value_t, double,
ordered_field_operators<value_t, unsigned long,
ordered_field_operators<value_t, long> > > > > > >
ordered_field_operators<value_t, balance_pair_t,
ordered_field_operators<value_t, balance_t,
ordered_field_operators<value_t, amount_t,
ordered_field_operators<value_t, double,
ordered_field_operators<value_t, unsigned long,
ordered_field_operators<value_t, long> > > > > > >
{
public:
typedef std::vector<value_t> sequence_t;

2
src/python/py_commodity.cc
View file

@ -51,7 +51,7 @@ void export_commodity()
scope().attr("COMMODITY_STYLE_BUILTIN") = COMMODITY_STYLE_BUILTIN;
class_< commodity_t, bases<>,
commodity_t, boost::noncopyable > ("commodity", no_init)
commodity_t, boost::noncopyable > ("commodity", no_init)
.def(self == self)
.def("drop_flags", &commodity_t::drop_flags)

2
src/python/pyutils.h
View file

@ -62,7 +62,7 @@ struct register_optional_to_python : public boost::noncopyable
{
return boost::python::incref
(value ? boost::python::to_python_value<T>()(*value) :
boost::python::detail::none());
boost::python::detail::none());
}
};

106
src/python/tuples.hpp
View file

@ -145,11 +145,11 @@ struct to_py_tuple{
typedef mpl::int_< tuples::length< TTuple >::value > length_type;
static PyObject* convert(const TTuple& c_tuple){
list values;
//add all c_tuple items to "values" list
convert_impl( c_tuple, values, mpl::int_< 0 >(), length_type() );
//create Python tuple from the list
return incref( python::tuple( values ).ptr() );
list values;
//add all c_tuple items to "values" list
convert_impl( c_tuple, values, mpl::int_< 0 >(), length_type() );
//create Python tuple from the list
return incref( python::tuple( values ).ptr() );
}
private:
@ -157,8 +157,8 @@ private:
template< int index, int length >
static void
convert_impl( const TTuple &c_tuple, list& values, mpl::int_< index >, mpl::int_< length > ) {
values.append( c_tuple.template get< index >() );
convert_impl( c_tuple, values, details::increment_index<index>(), length_type() );
values.append( c_tuple.template get< index >() );
convert_impl( c_tuple, values, details::increment_index<index>(), length_type() );
}
template< int length >
@ -179,48 +179,48 @@ struct from_py_sequence{
static void*
convertible(PyObject* py_obj){
if( !PySequence_Check( py_obj ) ){
return 0;
}
if( !PySequence_Check( py_obj ) ){
return 0;
}
if( !PyObject_HasAttrString( py_obj, "__len__" ) ){
return 0;
}
if( !PyObject_HasAttrString( py_obj, "__len__" ) ){
return 0;
}
python::object py_sequence( handle<>( borrowed( py_obj ) ) );
python::object py_sequence( handle<>( borrowed( py_obj ) ) );
if( tuples::length< TTuple >::value != len( py_sequence ) ){
return 0;
}
if( tuples::length< TTuple >::value != len( py_sequence ) ){
return 0;
}
if( convertible_impl( py_sequence, mpl::int_< 0 >(), length_type() ) ){
return py_obj;
}
else{
return 0;
}
if( convertible_impl( py_sequence, mpl::int_< 0 >(), length_type() ) ){
return py_obj;
}
else{
return 0;
}
}
static void
construct( PyObject* py_obj, converter::rvalue_from_python_stage1_data* data){
typedef converter::rvalue_from_python_storage<TTuple> storage_t;
storage_t* the_storage = reinterpret_cast<storage_t*>( data );
void* memory_chunk = the_storage->storage.bytes;
TTuple* c_tuple = new (memory_chunk) TTuple();
data->convertible = memory_chunk;
typedef converter::rvalue_from_python_storage<TTuple> storage_t;
storage_t* the_storage = reinterpret_cast<storage_t*>( data );
void* memory_chunk = the_storage->storage.bytes;
TTuple* c_tuple = new (memory_chunk) TTuple();
data->convertible = memory_chunk;
python::object py_sequence( handle<>( borrowed( py_obj ) ) );
construct_impl( py_sequence, *c_tuple, mpl::int_< 0 >(), length_type() );
python::object py_sequence( handle<>( borrowed( py_obj ) ) );
construct_impl( py_sequence, *c_tuple, mpl::int_< 0 >(), length_type() );
}
static TTuple to_c_tuple( PyObject* py_obj ){
if( !convertible( py_obj ) ){
throw std::runtime_error( "Unable to construct boost::tuples::tuple from Python object!" );
}
TTuple c_tuple;
python::object py_sequence( handle<>( borrowed( py_obj ) ) );
construct_impl( py_sequence, c_tuple, mpl::int_< 0 >(), length_type() );
return c_tuple;
if( !convertible( py_obj ) ){
throw std::runtime_error( "Unable to construct boost::tuples::tuple from Python object!" );
}
TTuple c_tuple;
python::object py_sequence( handle<>( borrowed( py_obj ) ) );
construct_impl( py_sequence, c_tuple, mpl::int_< 0 >(), length_type() );
return c_tuple;
}
private:
@ -229,34 +229,34 @@ private:
static bool
convertible_impl( const python::object& py_sequence, mpl::int_< index >, mpl::int_< length > ){
typedef typename tuples::element< index, TTuple>::type element_type;
typedef typename tuples::element< index, TTuple>::type element_type;
object element = py_sequence[index];
extract<element_type> type_checker( element );
if( !type_checker.check() ){
return false;
}
else{
return convertible_impl( py_sequence, details::increment_index<index>(), length_type() );
}
object element = py_sequence[index];
extract<element_type> type_checker( element );
if( !type_checker.check() ){
return false;
}
else{
return convertible_impl( py_sequence, details::increment_index<index>(), length_type() );
}
}
template< int length >
static bool
convertible_impl( const python::object& py_sequence, mpl::int_< length >, mpl::int_< length > ){
return true;
return true;
}
template< int index, int length >
static void
construct_impl( const python::object& py_sequence, TTuple& c_tuple, mpl::int_< index >, mpl::int_< length > ){
typedef typename tuples::element< index, TTuple>::type element_type;
typedef typename tuples::element< index, TTuple>::type element_type;
object element = py_sequence[index];
c_tuple.template get< index >() = extract<element_type>( element );
object element = py_sequence[index];
c_tuple.template get< index >() = extract<element_type>( element );
construct_impl( py_sequence, c_tuple, details::increment_index<index>(), length_type() );
construct_impl( py_sequence, c_tuple, details::increment_index<index>(), length_type() );
}
template< int length >
@ -272,8 +272,8 @@ void register_tuple(){
to_python_converter< TTuple, to_py_tuple<TTuple> >();
converter::registry::push_back( &from_py_sequence<TTuple>::convertible
, &from_py_sequence<TTuple>::construct
, type_id<TTuple>() );
, &from_py_sequence<TTuple>::construct
, type_id<TTuple>() );
};
} } //boost::python

2
src/traversal/xpath.cc
View file

@ -1210,7 +1210,7 @@ value_t xpath_t::op_t::calc(scope_t& scope)
case ATTR_NAME:
if (optional<value_t&> value =
kind == ATTR_ID ? current_xml_node(scope).get_attr(as_name()) :
current_xml_node(scope).get_attr(as_string()))
current_xml_node(scope).get_attr(as_string()))
return *value;
break;

6
src/traversal/xpath.h
View file

@ -83,9 +83,9 @@ public:
}
virtual void define(const string& name, ptr_op_t def) = 0;
void define(const string& name, const value_t& val);
void define(const string& name, const value_t& val);
virtual ptr_op_t lookup(const string& name) = 0;
value_t resolve(const string& name) {
value_t resolve(const string& name) {
return lookup(name)->calc(*this);
}
@ -175,7 +175,7 @@ public:
}
virtual void define(const string& name, ptr_op_t def);
void define(const string& name, const value_t& val) {
void define(const string& name, const value_t& val) {
scope_t::define(name, val);
}
virtual ptr_op_t lookup(const string& name);