quickdudley/lix
0
0
Fork 0
forked from lix-project/lix
Code Pull requests Activity

* Removed references to char_traits so that boost/format also works on

Browse source 
GCC 2.95.
This commit is contained in:
Eelco Dolstra 2003-09-11 10:23:55 +00:00
parent d930a9bc5a
commit 1c7d6bf5fc
15 changed files with 222 additions and 239 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
Makefile.am
View file

@ -1,3 +1,3 @@
SUBDIRS = externals src scripts corepkgs doc
SUBDIRS = externals boost src scripts corepkgs doc
EXTRA_DIST = boost/*.hpp boost/format/*.hpp substitute.mk
EXTRA_DIST = substitute.mk

1
boost/Makefile.am Normal file
View file

@ -0,0 +1 @@
SUBDIRS = format

9
boost/format.hpp
View file

@ -25,6 +25,9 @@
#include <cassert>
#include <locale>
//#define BOOST_NO_STD_LOCALE
//#define BOOST_NO_LOCALE_ISIDIGIT
//#include <cctype>
#include <boost/format/macros_default.hpp>
@ -54,15 +57,15 @@ namespace boost
#include <boost/format/exceptions.hpp>
// **** Implementation -------------------------------------------
#include <boost/format/format_implementation.hpp> // member functions
//#include <boost/format/format_implementation.hpp> // member functions
#include <boost/format/group.hpp> // class for grouping arguments
#include <boost/format/feed_args.hpp> // argument-feeding functions
#include <boost/format/parsing.hpp> // format-string parsing (member-)functions
//#include <boost/format/parsing.hpp> // format-string parsing (member-)functions
// **** Implementation of the free functions ----------------------
#include <boost/format/free_funcs.hpp>
//#include <boost/format/free_funcs.hpp>
#endif // BOOST_FORMAT_HPP

3
boost/format/Makefile.am Normal file
View file

@ -0,0 +1,3 @@
noinst_LIBRARIES = libformat.a
libformat_a_SOURCES = format_implementation.cc free_funcs.cc parsing.cc

69
boost/format/feed_args.hpp
View file

@ -31,17 +31,16 @@ namespace io {
namespace detail {
namespace {
template<class Tr, class Ch> inline
void empty_buf(BOOST_IO_STD basic_ostringstream<Ch,Tr> & os) {
static const std::basic_string<Ch, Tr> emptyStr;
inline
void empty_buf(BOOST_IO_STD ostringstream & os) {
static const std::string emptyStr;
os.str(emptyStr);
}
template<class Ch, class Tr>
void do_pad( std::basic_string<Ch,Tr> & s,
void do_pad( std::string & s,
std::streamsize w,
const Ch c,
std::ios_base::fmtflags f,
const char c,
std::ios::fmtflags f,
bool center)
// applies centered / left / right padding to the string s.
// Effects : string s is padded.
@ -59,7 +58,7 @@ namespace {
}
else
{
if(f & std::ios_base::left) {
if(f & std::ios::left) {
s.append(n, c);
}
else {
@ -69,32 +68,32 @@ namespace {
} // -do_pad(..)
template< class Ch, class Tr, class T> inline
void put_head(BOOST_IO_STD basic_ostream<Ch, Tr>& , const T& ) {
template<class T> inline
void put_head(BOOST_IO_STD ostream& , const T& ) {
}
template< class Ch, class Tr, class T> inline
void put_head( BOOST_IO_STD basic_ostream<Ch, Tr>& os, const group1<T>& x ) {
template<class T> inline
void put_head( BOOST_IO_STD ostream& os, const group1<T>& x ) {
os << group_head(x.a1_); // send the first N-1 items, not the last
}
template< class Ch, class Tr, class T> inline
void put_last( BOOST_IO_STD basic_ostream<Ch, Tr>& os, const T& x ) {
template<class T> inline
void put_last( BOOST_IO_STD ostream& os, const T& x ) {
os << x ;
}
template< class Ch, class Tr, class T> inline
void put_last( BOOST_IO_STD basic_ostream<Ch, Tr>& os, const group1<T>& x ) {
template<class T> inline
void put_last( BOOST_IO_STD ostream& os, const group1<T>& x ) {
os << group_last(x.a1_); // this selects the last element
}
#ifndef BOOST_NO_OVERLOAD_FOR_NON_CONST
template< class Ch, class Tr, class T> inline
void put_head( BOOST_IO_STD basic_ostream<Ch, Tr>& , T& ) {
template<class T> inline
void put_head( BOOST_IO_STD ostream& , T& ) {
}
template< class Ch, class Tr, class T> inline
void put_last( BOOST_IO_STD basic_ostream<Ch, Tr>& os, T& x ) {
template<class T> inline
void put_last( BOOST_IO_STD ostream& os, T& x ) {
os << x ;
}
#endif
@ -102,19 +101,19 @@ namespace {
template< class Ch, class Tr, class T>
template<class T>
void put( T x,
const format_item<Ch, Tr>& specs,
std::basic_string<Ch, Tr> & res,
BOOST_IO_STD basic_ostringstream<Ch, Tr>& oss_ )
const format_item& specs,
std::string & res,
BOOST_IO_STD ostringstream& oss_ )
{
// does the actual conversion of x, with given params, into a string
// using the *supplied* strinstream. (the stream state is important)
typedef std::basic_string<Ch, Tr> string_t;
typedef format_item<Ch, Tr> format_item_t;
typedef std::string string_t;
typedef format_item format_item_t;
stream_format_state<Ch, Tr> prev_state(oss_);
stream_format_state prev_state(oss_);
specs.state_.apply_on(oss_);
@ -124,8 +123,8 @@ void put( T x,
empty_buf( oss_);
const std::streamsize w=oss_.width();
const std::ios_base::fmtflags fl=oss_.flags();
const bool internal = (fl & std::ios_base::internal) != 0;
const std::ios::fmtflags fl=oss_.flags();
const bool internal = (fl & std::ios::internal) != 0;
const bool two_stepped_padding = internal
&& ! ( specs.pad_scheme_ & format_item_t::spacepad )
&& specs.truncate_ < 0 ;
@ -203,8 +202,8 @@ void put( T x,
template< class Ch, class Tr, class T>
void distribute(basic_format<Ch,Tr>& self, T x)
template<class T>
void distribute(basic_format& self, T x)
// call put(x, ..) on every occurence of the current argument :
{
if(self.cur_arg_ >= self.num_args_)
@ -217,16 +216,16 @@ void distribute(basic_format<Ch,Tr>& self, T x)
{
if(self.items_[i].argN_ == self.cur_arg_)
{
put<Ch, Tr, T> (x, self.items_[i], self.items_[i].res_, self.oss_ );
put<T> (x, self.items_[i], self.items_[i].res_, self.oss_ );
}
}
}
template<class Ch, class Tr, class T>
basic_format<Ch, Tr>& feed(basic_format<Ch,Tr>& self, T x)
template<class T>
basic_format& feed(basic_format& self, T x)
{
if(self.dumped_) self.clear();
distribute<Ch, Tr, T> (self, x);
distribute<T> (self, x);
++self.cur_arg_;
if(self.bound_.size() != 0)
{

43
boost/format/format_class.hpp
View file

@ -30,26 +30,21 @@
namespace boost {
template<class Ch, class Tr>
class basic_format
{
public:
typedef Ch CharT; // those 2 are necessary for borland compatibilty,
typedef Tr Traits; // in the body of the operator% template.
typedef std::basic_string<Ch, Tr> string_t;
typedef BOOST_IO_STD basic_ostringstream<Ch, Tr> internal_stream_t;
typedef std::string string_t;
typedef BOOST_IO_STD ostringstream internal_stream_t;
private:
typedef BOOST_IO_STD basic_ostream<Ch, Tr> stream_t;
typedef io::detail::stream_format_state<Ch, Tr> stream_format_state;
typedef io::detail::format_item<Ch, Tr> format_item_t;
typedef BOOST_IO_STD ostream stream_t;
typedef io::detail::stream_format_state stream_format_state;
typedef io::detail::format_item format_item_t;
public:
basic_format(const Ch* str);
basic_format(const char* str);
basic_format(const string_t& s);
#ifndef BOOST_NO_STD_LOCALE
basic_format(const Ch* str, const std::locale & loc);
basic_format(const char* str, const std::locale & loc);
basic_format(const string_t& s, const std::locale & loc);
#endif // no locale
basic_format(const basic_format& x);
@ -60,13 +55,13 @@ public:
// pass arguments through those operators :
template<class T> basic_format& operator%(const T& x)
{
return io::detail::feed<CharT, Traits, const T&>(*this,x);
return io::detail::feed<const T&>(*this,x);
}
#ifndef BOOST_NO_OVERLOAD_FOR_NON_CONST
template<class T> basic_format& operator%(T& x)
{
return io::detail::feed<CharT, Traits, T&>(*this,x);
return io::detail::feed<T&>(*this,x);
}
#endif
@ -93,21 +88,21 @@ public:
// final output
string_t str() const;
friend BOOST_IO_STD basic_ostream<Ch, Tr>&
operator<< <Ch, Tr> ( BOOST_IO_STD basic_ostream<Ch, Tr>& , const basic_format& );
friend BOOST_IO_STD ostream&
operator<< ( BOOST_IO_STD ostream& , const basic_format& );
template<class Ch2, class Tr2, class T> friend basic_format<Ch2, Tr2>&
io::detail::feed(basic_format<Ch2,Tr2>&, T);
template<class T> friend basic_format&
io::detail::feed(basic_format&, T);
template<class Ch2, class Tr2, class T> friend
void io::detail::distribute(basic_format<Ch2,Tr2>&, T);
template<class T> friend
void io::detail::distribute(basic_format&, T);
template<class Ch2, class Tr2, class T> friend
basic_format<Ch2, Tr2>& io::detail::modify_item_body(basic_format<Ch2, Tr2>&, int, const T&);
template<class T> friend
basic_format& io::detail::modify_item_body(basic_format&, int, const T&);
template<class Ch2, class Tr2, class T> friend
basic_format<Ch2, Tr2>& io::detail::bind_arg_body(basic_format<Ch2, Tr2>&, int, const T&);
template<class T> friend
basic_format& io::detail::bind_arg_body(basic_format&, int, const T&);
// make the members private only if the friend templates are supported
private:

16
boost/format/format_fwd.hpp
View file

@ -24,13 +24,9 @@
namespace boost {
template<class charT, class Traits = BOOST_IO_STD char_traits<charT> > class basic_format;
class basic_format;
typedef basic_format<char > format;
#if !defined(BOOST_NO_STD_WSTRING) && !defined(BOOST_NO_STD_WSTREAMBUF)
typedef basic_format<wchar_t > wformat;
#endif
typedef basic_format format;
namespace io {
enum format_error_bits { bad_format_string_bit = 1,
@ -39,15 +35,13 @@ enum format_error_bits { bad_format_string_bit = 1,
all_error_bits = 255, no_error_bits=0 };
// Convertion: format to string
template<class Ch, class Tr>
std::basic_string<Ch, Tr> str(const basic_format<Ch, Tr>& ) ;
std::string str(const basic_format& ) ;
} // namespace io
template< class Ch, class Tr>
BOOST_IO_STD basic_ostream<Ch, Tr>&
operator<<( BOOST_IO_STD basic_ostream<Ch, Tr>&, const basic_format<Ch, Tr>&);
BOOST_IO_STD ostream&
operator<<( BOOST_IO_STD ostream&, const basic_format&);
} // namespace boost

46
boost/format/format_implementation.hpp → boost/format/format_implementation.cc
View file

@ -22,13 +22,12 @@
//#include <boost/throw_exception.hpp>
//#include <boost/assert.hpp>
#include <boost/format/format_class.hpp>
#include <boost/format.hpp>
namespace boost {
// -------- format:: -------------------------------------------
template< class Ch, class Tr>
basic_format<Ch, Tr> ::basic_format(const Ch* str)
basic_format::basic_format(const char* str)
: style_(0), cur_arg_(0), num_args_(0), dumped_(false),
items_(), oss_(), exceptions_(io::all_error_bits)
{
@ -39,8 +38,7 @@ basic_format<Ch, Tr> ::basic_format(const Ch* str)
}
#ifndef BOOST_NO_STD_LOCALE
template< class Ch, class Tr>
basic_format<Ch, Tr> ::basic_format(const Ch* str, const std::locale & loc)
basic_format::basic_format(const char* str, const std::locale & loc)
: style_(0), cur_arg_(0), num_args_(0), dumped_(false),
items_(), oss_(), exceptions_(io::all_error_bits)
{
@ -51,8 +49,7 @@ basic_format<Ch, Tr> ::basic_format(const Ch* str, const std::locale & loc)
parse( str );
}
template< class Ch, class Tr>
basic_format<Ch, Tr> ::basic_format(const string_t& s, const std::locale & loc)
basic_format::basic_format(const string_t& s, const std::locale & loc)
: style_(0), cur_arg_(0), num_args_(0), dumped_(false),
items_(), oss_(), exceptions_(io::all_error_bits)
{
@ -62,8 +59,7 @@ basic_format<Ch, Tr> ::basic_format(const string_t& s, const std::locale & loc)
}
#endif //BOOST_NO_STD_LOCALE
template< class Ch, class Tr>
basic_format<Ch, Tr> ::basic_format(const string_t& s)
basic_format::basic_format(const string_t& s)
: style_(0), cur_arg_(0), num_args_(0), dumped_(false),
items_(), oss_(), exceptions_(io::all_error_bits)
{
@ -71,8 +67,7 @@ basic_format<Ch, Tr> ::basic_format(const string_t& s)
parse(s);
}
template< class Ch, class Tr>
basic_format<Ch, Tr> :: basic_format(const basic_format& x)
basic_format:: basic_format(const basic_format& x)
: style_(x.style_), cur_arg_(x.cur_arg_), num_args_(x.num_args_), dumped_(false),
items_(x.items_), prefix_(x.prefix_), bound_(x.bound_),
oss_(), // <- we obviously can't copy x.oss_
@ -81,8 +76,7 @@ basic_format<Ch, Tr> :: basic_format(const basic_format& x)
state0_.apply_on(oss_);
}
template< class Ch, class Tr>
basic_format<Ch, Tr>& basic_format<Ch, Tr> ::operator= (const basic_format& x)
basic_format& basic_format::operator= (const basic_format& x)
{
if(this == &x)
return *this;
@ -102,14 +96,12 @@ basic_format<Ch, Tr>& basic_format<Ch, Tr> ::operator= (const basic_format& x)
}
template< class Ch, class Tr>
unsigned char basic_format<Ch,Tr> ::exceptions() const
unsigned char basic_format::exceptions() const
{
return exceptions_;
}
template< class Ch, class Tr>
unsigned char basic_format<Ch,Tr> ::exceptions(unsigned char newexcept)
unsigned char basic_format::exceptions(unsigned char newexcept)
{
unsigned char swp = exceptions_;
exceptions_ = newexcept;
@ -117,8 +109,7 @@ unsigned char basic_format<Ch,Tr> ::exceptions(unsigned char newexcept)
}
template< class Ch, class Tr>
basic_format<Ch,Tr>& basic_format<Ch,Tr> ::clear()
basic_format& basic_format ::clear()
// empty the string buffers (except bound arguments, see clear_binds() )
// and make the format object ready for formatting a new set of arguments
{
@ -138,8 +129,7 @@ basic_format<Ch,Tr>& basic_format<Ch,Tr> ::clear()
return *this;
}
template< class Ch, class Tr>
basic_format<Ch,Tr>& basic_format<Ch,Tr> ::clear_binds()
basic_format& basic_format ::clear_binds()
// cancel all bindings, and clear()
{
bound_.resize(0);
@ -147,8 +137,7 @@ basic_format<Ch,Tr>& basic_format<Ch,Tr> ::clear_binds()
return *this;
}
template< class Ch, class Tr>
basic_format<Ch,Tr>& basic_format<Ch,Tr> ::clear_bind(int argN)
basic_format& basic_format::clear_bind(int argN)
// cancel the binding of ONE argument, and clear()
{
if(argN<1 || argN > num_args_ || bound_.size()==0 || !bound_[argN-1] )
@ -164,8 +153,7 @@ basic_format<Ch,Tr>& basic_format<Ch,Tr> ::clear_bind(int argN)
template< class Ch, class Tr>
std::basic_string<Ch,Tr> basic_format<Ch,Tr> ::str() const
std::string basic_format::str() const
{
dumped_=true;
if(items_.size()==0)
@ -201,8 +189,8 @@ std::basic_string<Ch,Tr> basic_format<Ch,Tr> ::str() const
namespace io {
namespace detail {
template<class Ch, class Tr, class T>
basic_format<Ch, Tr>& bind_arg_body( basic_format<Ch, Tr>& self,
template<class T>
basic_format& bind_arg_body( basic_format& self,
int argN,
const T& val)
// bind one argument to a fixed value
@ -239,8 +227,8 @@ basic_format<Ch, Tr>& bind_arg_body( basic_format<Ch, Tr>& self,
return self;
}
template<class Ch, class Tr, class T>
basic_format<Ch, Tr>& modify_item_body( basic_format<Ch, Tr>& self,
template<class T>
basic_format& modify_item_body( basic_format& self,
int itemN,
const T& manipulator)
// applies a manipulator to the format_item describing a given directive.

17
boost/format/free_funcs.hpp → boost/format/free_funcs.cc
View file

@ -19,27 +19,26 @@
#ifndef BOOST_FORMAT_FUNCS_HPP
#define BOOST_FORMAT_FUNCS_HPP
#include "boost/format/format_class.hpp"
#include "boost/format.hpp"
//#include "boost/throw_exception.hpp"
namespace boost {
namespace io {
template<class Ch, class Tr> inline
std::basic_string<Ch, Tr> str(const basic_format<Ch, Tr>& f)
inline
std::string str(const basic_format& f)
// adds up all pieces of strings and converted items, and return the formatted string
{
return f.str();
}
} // - namespace io
template< class Ch, class Tr>
BOOST_IO_STD basic_ostream<Ch, Tr>&
operator<<( BOOST_IO_STD basic_ostream<Ch, Tr>& os,
const boost::basic_format<Ch, Tr>& f)
BOOST_IO_STD ostream&
operator<<( BOOST_IO_STD ostream& os,
const boost::basic_format& f)
// effect: "return os << str(f);" but we can try to do it faster
{
typedef boost::basic_format<Ch, Tr> format_t;
typedef boost::basic_format format_t;
if(f.items_.size()==0)
os << f.prefix_;
else {
@ -53,7 +52,7 @@ operator<<( BOOST_IO_STD basic_ostream<Ch, Tr>& os,
os << f.prefix_;
for(unsigned long i=0; i<f.items_.size(); ++i)
{
const typename format_t::format_item_t& item = f.items_[i];
const format_t::format_item_t& item = f.items_[i];
os << item.res_;
os << item.appendix_;

44
boost/format/group.hpp
View file

@ -45,8 +45,8 @@ struct group0
template <class Ch, class Tr>
inline
BOOST_IO_STD basic_ostream<Ch, Tr>&
operator << ( BOOST_IO_STD basic_ostream<Ch, Tr>& os,
BOOST_IO_STD ostream&
operator << ( BOOST_IO_STD ostream& os,
const group0& )
{
return os;
@ -63,8 +63,8 @@ struct group1
template <class Ch, class Tr, class T1>
inline
BOOST_IO_STD basic_ostream<Ch, Tr>&
operator << (BOOST_IO_STD basic_ostream<Ch, Tr>& os,
BOOST_IO_STD ostream&
operator << (BOOST_IO_STD ostream& os,
const group1<T1>& x)
{
os << x.a1_;
@ -86,8 +86,8 @@ struct group2
template <class Ch, class Tr, class T1,class T2>
inline
BOOST_IO_STD basic_ostream<Ch, Tr>&
operator << (BOOST_IO_STD basic_ostream<Ch, Tr>& os,
BOOST_IO_STD ostream&
operator << (BOOST_IO_STD ostream& os,
const group2<T1,T2>& x)
{
os << x.a1_<< x.a2_;
@ -107,8 +107,8 @@ struct group3
template <class Ch, class Tr, class T1,class T2,class T3>
inline
BOOST_IO_STD basic_ostream<Ch, Tr>&
operator << (BOOST_IO_STD basic_ostream<Ch, Tr>& os,
BOOST_IO_STD ostream&
operator << (BOOST_IO_STD ostream& os,
const group3<T1,T2,T3>& x)
{
os << x.a1_<< x.a2_<< x.a3_;
@ -129,8 +129,8 @@ struct group4
template <class Ch, class Tr, class T1,class T2,class T3,class T4>
inline
BOOST_IO_STD basic_ostream<Ch, Tr>&
operator << (BOOST_IO_STD basic_ostream<Ch, Tr>& os,
BOOST_IO_STD ostream&
operator << (BOOST_IO_STD ostream& os,
const group4<T1,T2,T3,T4>& x)
{
os << x.a1_<< x.a2_<< x.a3_<< x.a4_;
@ -152,8 +152,8 @@ struct group5
template <class Ch, class Tr, class T1,class T2,class T3,class T4,class T5>
inline
BOOST_IO_STD basic_ostream<Ch, Tr>&
operator << (BOOST_IO_STD basic_ostream<Ch, Tr>& os,
BOOST_IO_STD ostream&
operator << (BOOST_IO_STD ostream& os,
const group5<T1,T2,T3,T4,T5>& x)
{
os << x.a1_<< x.a2_<< x.a3_<< x.a4_<< x.a5_;
@ -176,8 +176,8 @@ struct group6
template <class Ch, class Tr, class T1,class T2,class T3,class T4,class T5,class T6>
inline
BOOST_IO_STD basic_ostream<Ch, Tr>&
operator << (BOOST_IO_STD basic_ostream<Ch, Tr>& os,
BOOST_IO_STD ostream&
operator << (BOOST_IO_STD ostream& os,
const group6<T1,T2,T3,T4,T5,T6>& x)
{
os << x.a1_<< x.a2_<< x.a3_<< x.a4_<< x.a5_<< x.a6_;
@ -201,8 +201,8 @@ struct group7
template <class Ch, class Tr, class T1,class T2,class T3,class T4,class T5,class T6,class T7>
inline
BOOST_IO_STD basic_ostream<Ch, Tr>&
operator << (BOOST_IO_STD basic_ostream<Ch, Tr>& os,
BOOST_IO_STD ostream&
operator << (BOOST_IO_STD ostream& os,
const group7<T1,T2,T3,T4,T5,T6,T7>& x)
{
os << x.a1_<< x.a2_<< x.a3_<< x.a4_<< x.a5_<< x.a6_<< x.a7_;
@ -227,8 +227,8 @@ struct group8
template <class Ch, class Tr, class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8>
inline
BOOST_IO_STD basic_ostream<Ch, Tr>&
operator << (BOOST_IO_STD basic_ostream<Ch, Tr>& os,
BOOST_IO_STD ostream&
operator << (BOOST_IO_STD ostream& os,
const group8<T1,T2,T3,T4,T5,T6,T7,T8>& x)
{
os << x.a1_<< x.a2_<< x.a3_<< x.a4_<< x.a5_<< x.a6_<< x.a7_<< x.a8_;
@ -254,8 +254,8 @@ struct group9
template <class Ch, class Tr, class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9>
inline
BOOST_IO_STD basic_ostream<Ch, Tr>&
operator << (BOOST_IO_STD basic_ostream<Ch, Tr>& os,
BOOST_IO_STD ostream&
operator << (BOOST_IO_STD ostream& os,
const group9<T1,T2,T3,T4,T5,T6,T7,T8,T9>& x)
{
os << x.a1_<< x.a2_<< x.a3_<< x.a4_<< x.a5_<< x.a6_<< x.a7_<< x.a8_<< x.a9_;
@ -282,8 +282,8 @@ struct group10
template <class Ch, class Tr, class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10>
inline
BOOST_IO_STD basic_ostream<Ch, Tr>&
operator << (BOOST_IO_STD basic_ostream<Ch, Tr>& os,
BOOST_IO_STD ostream&
operator << (BOOST_IO_STD ostream& os,
const group10<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>& x)
{
os << x.a1_<< x.a2_<< x.a3_<< x.a4_<< x.a5_<< x.a6_<< x.a7_<< x.a8_<< x.a9_<< x.a10_;

48
boost/format/internals.hpp
View file

@ -33,22 +33,21 @@ namespace detail {
// --------------
// set of params that define the format state of a stream
template<class Ch, class Tr>
struct stream_format_state
{
typedef BOOST_IO_STD basic_ios<Ch, Tr> basic_ios;
typedef std::ios basic_ios;
std::streamsize width_;
std::streamsize precision_;
Ch fill_;
std::ios_base::fmtflags flags_;
char fill_;
std::ios::fmtflags flags_;
stream_format_state() : width_(-1), precision_(-1), fill_(0), flags_(std::ios_base::dec) {}
stream_format_state() : width_(-1), precision_(-1), fill_(0), flags_(std::ios::dec) {}
stream_format_state(basic_ios& os) {set_by_stream(os); }
void apply_on(basic_ios & os) const; //- applies format_state to the stream
template<class T> void apply_manip(T manipulator) //- modifies state by applying manipulator.
{ apply_manip_body<Ch, Tr, T>( *this, manipulator) ; }
{ apply_manip_body<T>( *this, manipulator) ; }
void reset(); //- sets to default state.
void set_by_stream(const basic_ios& os); //- sets to os's state.
};
@ -58,7 +57,6 @@ struct stream_format_state
// --------------
// format_item : stores all parameters that can be defined by directives in the format-string
template<class Ch, class Tr>
struct format_item
{
enum pad_values { zeropad = 1, spacepad =2, centered=4, tabulation = 8 };
@ -67,10 +65,10 @@ struct format_item
argN_tabulation = -2, // tabulation directive. (no argument read)
argN_ignored = -3 // ignored directive. (no argument read)
};
typedef BOOST_IO_STD basic_ios<Ch, Tr> basic_ios;
typedef detail::stream_format_state<Ch, Tr> stream_format_state;
typedef std::basic_string<Ch, Tr> string_t;
typedef BOOST_IO_STD basic_ostringstream<Ch, Tr> internal_stream_t;
typedef BOOST_IO_STD ios basic_ios;
typedef detail::stream_format_state stream_format_state;
typedef std::string string_t;
typedef BOOST_IO_STD ostringstream internal_stream_t;
int argN_; //- argument number (starts at 0, eg : %1 => argN=0)
@ -98,8 +96,8 @@ struct format_item
// -----------------------------------------------------------
// --- stream_format_state:: -------------------------------------------
template<class Ch, class Tr> inline
void stream_format_state<Ch,Tr> ::apply_on(basic_ios & os) const
inline
void stream_format_state::apply_on(basic_ios & os) const
// set the state of this stream according to our params
{
if(width_ != -1)
@ -111,8 +109,8 @@ void stream_format_state<Ch,Tr> ::apply_on(basic_ios & os) const
os.flags(flags_);
}
template<class Ch, class Tr> inline
void stream_format_state<Ch,Tr> ::set_by_stream(const basic_ios& os)
inline
void stream_format_state::set_by_stream(const basic_ios& os)
// set our params according to the state of this stream
{
flags_ = os.flags();
@ -121,42 +119,42 @@ void stream_format_state<Ch,Tr> ::set_by_stream(const basic_ios& os)
fill_ = os.fill();
}
template<class Ch, class Tr, class T> inline
void apply_manip_body( stream_format_state<Ch, Tr>& self,
template<class T> inline
void apply_manip_body( stream_format_state& self,
T manipulator)
// modify our params according to the manipulator
{
BOOST_IO_STD basic_stringstream<Ch, Tr> ss;
BOOST_IO_STD stringstream ss;
self.apply_on( ss );
ss << manipulator;
self.set_by_stream( ss );
}
template<class Ch, class Tr> inline
void stream_format_state<Ch,Tr> ::reset()
inline
void stream_format_state::reset()
// set our params to standard's default state
{
width_=-1; precision_=-1; fill_=0;
flags_ = std::ios_base::dec;
flags_ = std::ios::dec;
}
// --- format_items:: -------------------------------------------
template<class Ch, class Tr> inline
void format_item<Ch, Tr> ::compute_states()
inline
void format_item::compute_states()
// reflect pad_scheme_ on state_ and ref_state_
// because some pad_schemes has complex consequences on several state params.
{
if(pad_scheme_ & zeropad)
{
if(ref_state_.flags_ & std::ios_base::left)
if(ref_state_.flags_ & std::ios::left)
{
pad_scheme_ = pad_scheme_ & (~zeropad); // ignore zeropad in left alignment
}
else
{
ref_state_.fill_='0';
ref_state_.flags_ |= std::ios_base::internal;
ref_state_.flags_ |= std::ios::internal;
}
}
state_ = ref_state_;

24
boost/format/internals_fwd.hpp
View file

@ -26,8 +26,8 @@ namespace boost {
namespace io {
namespace detail {
template<class Ch, class Tr> struct stream_format_state;
template<class Ch, class Tr> struct format_item;
struct stream_format_state;
struct format_item;
}
@ -37,24 +37,24 @@ namespace detail {
// but MSVC have problems with template member functions :
// defined in format_implementation.hpp :
template<class Ch, class Tr, class T>
basic_format<Ch, Tr>& modify_item_body( basic_format<Ch, Tr>& self,
template<class T>
basic_format& modify_item_body( basic_format& self,
int itemN, const T& manipulator);
template<class Ch, class Tr, class T>
basic_format<Ch, Tr>& bind_arg_body( basic_format<Ch, Tr>& self,
template<class T>
basic_format& bind_arg_body( basic_format& self,
int argN, const T& val);
template<class Ch, class Tr, class T>
void apply_manip_body( stream_format_state<Ch, Tr>& self,
template<class T>
void apply_manip_body( stream_format_state& self,
T manipulator);
// argument feeding (defined in feed_args.hpp ) :
template<class Ch, class Tr, class T>
void distribute(basic_format<Ch,Tr>& self, T x);
template<class T>
void distribute(basic_format& self, T x);
template<class Ch, class Tr, class T>
basic_format<Ch, Tr>& feed(basic_format<Ch,Tr>& self, T x);
template<class T>
basic_format& feed(basic_format& self, T x);
} // namespace detail

113
boost/format/parsing.hpp → boost/format/parsing.cc
View file

@ -22,7 +22,7 @@
#define BOOST_FORMAT_PARSING_HPP
#include <boost/format/format_class.hpp>
#include <boost/format.hpp>
//#include <boost/throw_exception.hpp>
//#include <boost/assert.hpp>
@ -31,8 +31,8 @@ namespace boost {
namespace io {
namespace detail {
template<class Ch, class Stream> inline
bool wrap_isdigit(Ch c, Stream &os)
template<class Stream> inline
bool wrap_isdigit(char c, Stream &os)
{
#ifndef BOOST_NO_LOCALE_ISIDIGIT
return std::isdigit(c, os.rdbuf()->getloc() );
@ -42,10 +42,10 @@ namespace detail {
#endif
} //end- wrap_isdigit(..)
template<class Res, class Ch, class Tr> inline
Res str2int(const std::basic_string<Ch, Tr>& s,
typename std::basic_string<Ch, Tr>::size_type start,
BOOST_IO_STD basic_ios<Ch,Tr> &os,
template<class Res> inline
Res str2int(const std::string& s,
std::string::size_type start,
BOOST_IO_STD ios &os,
const Res = Res(0) )
// Input : char string, with starting index
// a basic_ios& merely to call its widen/narrow member function in the desired locale.
@ -54,7 +54,7 @@ namespace detail {
{
Res n = 0;
while(start<s.size() && wrap_isdigit(s[start], os) ) {
char cur_ch = os.narrow( s[start], 0);
char cur_ch = s[start];
BOOST_ASSERT(cur_ch != 0 ); // since we called isdigit, this should not happen.
n *= 10;
n += cur_ch - '0'; // 22.2.1.1.2 of the C++ standard
@ -63,10 +63,9 @@ namespace detail {
return n;
}
template<class Ch, class Tr>
void skip_asterisk(const std::basic_string<Ch,Tr> & buf,
typename std::basic_string<Ch,Tr>::size_type * pos_p,
BOOST_IO_STD basic_ios<Ch, Tr> &os)
void skip_asterisk(const std::string & buf,
std::string::size_type * pos_p,
BOOST_IO_STD ios &os)
// skip printf's "asterisk-fields" directives in the format-string buf
// Input : char string, with starting index *pos_p
// a basic_ios& merely to call its widen/narrow member function in the desired locale.
@ -76,10 +75,10 @@ namespace detail {
using namespace std;
BOOST_ASSERT( pos_p != 0);
if(*pos_p >= buf.size() ) return;
if(buf[ *pos_p]==os.widen('*')) {
if(buf[ *pos_p]=='*') {
++ (*pos_p);
while (*pos_p < buf.size() && wrap_isdigit(buf[*pos_p],os)) ++(*pos_p);
if(buf[*pos_p]==os.widen('$')) ++(*pos_p);
if(buf[*pos_p]=='$') ++(*pos_p);
}
}
@ -95,11 +94,10 @@ namespace detail {
template<class Ch, class Tr>
bool parse_printf_directive(const std::basic_string<Ch, Tr> & buf,
typename std::basic_string<Ch, Tr>::size_type * pos_p,
detail::format_item<Ch, Tr> * fpar,
BOOST_IO_STD basic_ios<Ch,Tr> &os,
bool parse_printf_directive(const std::string & buf,
std::string::size_type * pos_p,
detail::format_item * fpar,
BOOST_IO_STD ios &os,
unsigned char exceptions)
// Input : a 'printf-directive' in the format-string, starting at buf[ *pos_p ]
// a basic_ios& merely to call its widen/narrow member function in the desired locale.
@ -109,14 +107,14 @@ namespace detail {
// Effects : - *pos_p is incremented so that buf[*pos_p] is the first char after the directive
// - *fpar is set with the parameters read in the directive
{
typedef format_item<Ch, Tr> format_item_t;
typedef format_item format_item_t;
BOOST_ASSERT( pos_p != 0);
typename std::basic_string<Ch, Tr>::size_type &i1 = *pos_p,
std::string::size_type &i1 = *pos_p,
i0;
fpar->argN_ = format_item_t::argN_no_posit; // if no positional-directive
bool in_brackets=false;
if(buf[i1]==os.widen('|'))
if(buf[i1]=='|')
{
in_brackets=true;
if( ++i1 >= buf.size() ) {
@ -126,7 +124,7 @@ namespace detail {
}
// the flag '0' would be picked as a digit for argument order, but here it's a flag :
if(buf[i1]==os.widen('0'))
if(buf[i1]=='0')
goto parse_flags;
// handle argument order (%2$d) or possibly width specification: %2d
@ -142,7 +140,7 @@ namespace detail {
int n=str2int(buf,i0, os, int(0) );
// %N% case : this is already the end of the directive
if( buf[i1] == os.widen('%') )
if( buf[i1] == '%' )
{
fpar->argN_ = n-1;
++i1;
@ -152,7 +150,7 @@ namespace detail {
else return true;
}
if ( buf[i1]==os.widen('$') )
if ( buf[i1]=='$' )
{
fpar->argN_ = n-1;
++i1;
@ -171,14 +169,14 @@ namespace detail {
while ( i1 <buf.size()) // as long as char is one of + - = # 0 l h or ' '
{
// misc switches
switch (os.narrow(buf[i1], 0))
switch (buf[i1])
{
case '\'' : break; // no effect yet. (painful to implement)
case 'l':
case 'h': // short/long modifier : for printf-comaptibility (no action needed)
break;
case '-':
fpar->ref_state_.flags_ |= std::ios_base::left;
fpar->ref_state_.flags_ |= std::ios::left;
break;
case '=':
fpar->pad_scheme_ |= format_item_t::centered;
@ -187,7 +185,7 @@ namespace detail {
fpar->pad_scheme_ |= format_item_t::spacepad;
break;
case '+':
fpar->ref_state_.flags_ |= std::ios_base::showpos;
fpar->ref_state_.flags_ |= std::ios::showpos;
break;
case '0':
fpar->pad_scheme_ |= format_item_t::zeropad;
@ -195,7 +193,7 @@ namespace detail {
// so just add 'zeropad' flag for now, it will be processed later.
break;
case '#':
fpar->ref_state_.flags_ |= std::ios_base::showpoint | std::ios_base::showbase;
fpar->ref_state_.flags_ |= std::ios::showpoint | std::ios::showbase;
break;
default:
goto parse_width;
@ -223,7 +221,7 @@ namespace detail {
return true;
}
// handle precision spec
if (buf[i1]==os.widen('.'))
if (buf[i1]=='.')
{
++i1;
skip_asterisk(buf, &i1, os);
@ -239,51 +237,51 @@ namespace detail {
// handle formatting-type flags :
while( i1<buf.size() &&
( buf[i1]==os.widen('l') || buf[i1]==os.widen('L') || buf[i1]==os.widen('h')) )
( buf[i1]=='l' || buf[i1]=='L' || buf[i1]=='h') )
++i1;
if( i1>=buf.size()) {
maybe_throw_exception(exceptions);
return true;
}
if( in_brackets && buf[i1]==os.widen('|') )
if( in_brackets && buf[i1]=='|' )
{
++i1;
return true;
}
switch (os.narrow(buf[i1], 0) )
switch (buf[i1])
{
case 'X':
fpar->ref_state_.flags_ |= std::ios_base::uppercase;
fpar->ref_state_.flags_ |= std::ios::uppercase;
case 'p': // pointer => set hex.
case 'x':
fpar->ref_state_.flags_ &= ~std::ios_base::basefield;
fpar->ref_state_.flags_ |= std::ios_base::hex;
fpar->ref_state_.flags_ &= ~std::ios::basefield;
fpar->ref_state_.flags_ |= std::ios::hex;
break;
case 'o':
fpar->ref_state_.flags_ &= ~std::ios_base::basefield;
fpar->ref_state_.flags_ |= std::ios_base::oct;
fpar->ref_state_.flags_ &= ~std::ios::basefield;
fpar->ref_state_.flags_ |= std::ios::oct;
break;
case 'E':
fpar->ref_state_.flags_ |= std::ios_base::uppercase;
fpar->ref_state_.flags_ |= std::ios::uppercase;
case 'e':
fpar->ref_state_.flags_ &= ~std::ios_base::floatfield;
fpar->ref_state_.flags_ |= std::ios_base::scientific;
fpar->ref_state_.flags_ &= ~std::ios::floatfield;
fpar->ref_state_.flags_ |= std::ios::scientific;
fpar->ref_state_.flags_ &= ~std::ios_base::basefield;
fpar->ref_state_.flags_ |= std::ios_base::dec;
fpar->ref_state_.flags_ &= ~std::ios::basefield;
fpar->ref_state_.flags_ |= std::ios::dec;
break;
case 'f':
fpar->ref_state_.flags_ &= ~std::ios_base::floatfield;
fpar->ref_state_.flags_ |= std::ios_base::fixed;
fpar->ref_state_.flags_ &= ~std::ios::floatfield;
fpar->ref_state_.flags_ |= std::ios::fixed;
case 'u':
case 'd':
case 'i':
fpar->ref_state_.flags_ &= ~std::ios_base::basefield;
fpar->ref_state_.flags_ |= std::ios_base::dec;
fpar->ref_state_.flags_ &= ~std::ios::basefield;
fpar->ref_state_.flags_ |= std::ios::dec;
break;
case 'T':
@ -296,20 +294,20 @@ namespace detail {
fpar->argN_ = format_item_t::argN_tabulation;
break;
case 't':
fpar->ref_state_.fill_ = os.widen(' ');
fpar->ref_state_.fill_ = ' ';
fpar->pad_scheme_ |= format_item_t::tabulation;
fpar->argN_ = format_item_t::argN_tabulation;
break;
case 'G':
fpar->ref_state_.flags_ |= std::ios_base::uppercase;
fpar->ref_state_.flags_ |= std::ios::uppercase;
break;
case 'g': // 'g' conversion is default for floats.
fpar->ref_state_.flags_ &= ~std::ios_base::basefield;
fpar->ref_state_.flags_ |= std::ios_base::dec;
fpar->ref_state_.flags_ &= ~std::ios::basefield;
fpar->ref_state_.flags_ |= std::ios::dec;
// CLEAR all floatield flags, so stream will CHOOSE
fpar->ref_state_.flags_ &= ~std::ios_base::floatfield;
fpar->ref_state_.flags_ &= ~std::ios::floatfield;
break;
case 'C':
@ -331,7 +329,7 @@ namespace detail {
if( in_brackets )
{
if( i1<buf.size() && buf[i1]==os.widen('|') )
if( i1<buf.size() && buf[i1]=='|' )
{
++i1;
return true;
@ -348,15 +346,14 @@ namespace detail {
// -----------------------------------------------
// format :: parse(..)
template<class Ch, class Traits>
void basic_format<Ch, Traits> ::parse(const string_t & buf)
void basic_format::parse(const string_t & buf)
// parse the format-string
{
using namespace std;
const Ch arg_mark = oss_.widen('%');
const char arg_mark = '%';
bool ordered_args=true;
int max_argN=-1;
typename string_t::size_type i1=0;
string_t::size_type i1=0;
int num_items=0;
// A: find upper_bound on num_items and allocates arrays
@ -382,7 +379,7 @@ void basic_format<Ch, Traits> ::parse(const string_t & buf)
// B: Now the real parsing of the format string :
num_items=0;
i1 = 0;
typename string_t::size_type i0 = i1;
string_t::size_type i0 = i1;
bool special_things=false;
int cur_it=0;
while( (i1=buf.find(arg_mark,i1)) != string::npos )

12
configure.ac
View file

@ -16,8 +16,12 @@ AC_PATH_PROG(wget, wget)
AC_CHECK_LIB(pthread, pthread_mutex_init)
AM_CONFIG_HEADER([config.h])
AC_CONFIG_FILES([Makefile externals/Makefile src/Makefile scripts/Makefile
corepkgs/Makefile corepkgs/fetchurl/Makefile
corepkgs/nar/Makefile
doc/Makefile doc/manual/Makefile])
AC_CONFIG_FILES([Makefile
externals/Makefile
boost/Makefile boost/format/Makefile
src/Makefile
scripts/Makefile
corepkgs/Makefile corepkgs/fetchurl/Makefile corepkgs/nar/Makefile
doc/Makefile doc/manual/Makefile
])
AC_OUTPUT

12
src/Makefile.am
View file

@ -1,22 +1,24 @@
bin_PROGRAMS = nix nix-hash fix
check_PROGRAMS = test
AM_CXXFLAGS = -DSYSTEM=\"@host@\" -Wall -I.. -I../externals/inst/include $(CXXFLAGS)
AM_LDFLAGS = -L../externals/inst/lib -ldb_cxx -lATerm $(LDFLAGS)
LDADD = -L../externals/inst/lib -ldb_cxx -lATerm -L../boost/format -lformat
nix_SOURCES = nix.cc dotgraph.cc
nix_LDADD = libshared.a libnix.a -ldb_cxx -lATerm
nix_LDADD = libshared.a libnix.a $(LDADD)
nix_hash_SOURCES = nix-hash.cc
nix_hash_LDADD = libshared.a libnix.a -ldb_cxx -lATerm
nix_hash_LDADD = libshared.a libnix.a $(LDADD)
fix_SOURCES = fix.cc
fix_LDADD = libshared.a libnix.a -ldb_cxx -lATerm
fix_LDADD = libshared.a libnix.a $(LDADD)
TESTS = test
test_SOURCES = test.cc
test_LDADD = libshared.a libnix.a -ldb_cxx -lATerm
test_LDADD = libshared.a libnix.a $(LDADD)
noinst_LIBRARIES = libnix.a libshared.a