Boost  v1.57.0
doxygen for www.boost.org
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Modules Pages
boost::wave::util Namespace Reference

Namespaces

 flex_string_details
 
 impl
 
 on_exit
 
 time_conversion
 

Classes

class  AllocatorStringStorage
 
class  CowString
 
struct  file_position
 
class  flex_string
 
struct  functor_input
 
class  if_block
 
class  if_block_stack
 
class  include_paths
 
class  insert_whitespace_detection
 
class  iteration_context_stack
 
struct  macro_definition
 
class  macromap
 
class  mallocator
 
class  mallocator< void >
 
struct  pattern_and
 
struct  position_iterator
 
class  predefined_macros
 
class  SimpleStringStorage
 
class  SmallStringOpt
 
struct  symbol_table
 
class  unput_queue_iterator
 
class  VectorStringStorage
 

Typedefs

typedef file_position
< BOOST_WAVE_STRINGTYPE
file_position_type
 

Enumerations

enum  severity {
  severity_remark = 0,
  severity_warning,
  severity_error,
  severity_fatal,
  severity_commandline_error,
  last_severity_code = severity_commandline_error
}
 

Functions

char const * get_severity (int level)
 
template<typename Exception , typename S1 , typename Pos >
void throw_ (typename Exception::error_code code, S1 msg, Pos const &pos)
 
template<typename Exception , typename Context , typename S1 , typename Pos >
void throw_ (Context &ctx, typename Exception::error_code code, S1 msg, Pos const &pos)
 
template<typename Exception , typename S1 , typename Pos , typename S2 >
void throw_ (typename Exception::error_code code, S1 msg, Pos const &pos, S2 name)
 
template<typename Exception , typename Context , typename S1 , typename Pos1 , typename S2 >
void throw_ (Context &ctx, typename Exception::error_code code, S1 msg, Pos1 const &pos, S2 name)
 
bool as_relative_to (boost::filesystem::path const &path, boost::filesystem::path const &base, boost::filesystem::path &result)
 
template<typename ContextT , typename ParseNodeT , typename TokenT , typename PositionT >
bool retrieve_macroname (ContextT &ctx, ParseNodeT const &node, boost::spirit::classic::parser_id id, TokenT &macroname, PositionT &act_pos, bool update_position)
 
template<typename ParseNodeT , typename ContainerT , typename PositionT >
bool retrieve_macrodefinition (ParseNodeT const &node, boost::spirit::classic::parser_id id, ContainerT &macrodefinition, PositionT &act_pos, bool update_position)
 
template<typename Context >
void report_invalid_concatenation (Context &ctx, typename Context::token_type const &prev, typename Context::token_type const &next, typename Context::position_type const &main_pos)
 
template<typename Target , typename Src >
impl::to_string_helper< Target,
Src >::type 
to_string (Src const &src)
 
template<typename StringT >
bool operator== (file_position< StringT > const &lhs, file_position< StringT > const &rhs)
 
template<typename StringT >
std::ostream & operator<< (std::ostream &o, file_position< StringT > const &pos)
 
boost::filesystem::path initial_path ()
 
boost::filesystem::path current_path ()
 
template<typename String >
boost::filesystem::path create_path (String const &p)
 
std::string leaf (boost::filesystem::path const &p)
 
boost::filesystem::path branch_path (boost::filesystem::path const &p)
 
boost::filesystem::path normalize (boost::filesystem::path &p)
 
std::string native_file_string (boost::filesystem::path const &p)
 
boost::filesystem::path complete_path (boost::filesystem::path const &p)
 
boost::filesystem::path complete_path (boost::filesystem::path const &p, boost::filesystem::path const &base)
 
bool create_directories (boost::filesystem::path const &p)
 
template<class T >
bool operator== (const mallocator< T > &, const mallocator< T > &)
 
template<class T >
bool operator!= (const mallocator< T > &, const mallocator< T > &)
 
template<class Allocator >
Allocator::pointer Reallocate (Allocator &alloc, typename Allocator::pointer p, typename Allocator::size_type oldObjCount, typename Allocator::size_type newObjCount, void *)
 
template<class Allocator >
Allocator::pointer Reallocate (Allocator &alloc, typename Allocator::pointer p, typename Allocator::size_type oldObjCount, typename Allocator::size_type newObjCount, mallocator< void > *)
 
template<typename E , class T , class A , class S >
flex_string< E, T, A, S > operator+ (const flex_string< E, T, A, S > &lhs, const flex_string< E, T, A, S > &rhs)
 
template<typename E , class T , class A , class S >
flex_string< E, T, A, S > operator+ (const typename flex_string< E, T, A, S >::value_type *lhs, const flex_string< E, T, A, S > &rhs)
 
template<typename E , class T , class A , class S >
flex_string< E, T, A, S > operator+ (typename flex_string< E, T, A, S >::value_type lhs, const flex_string< E, T, A, S > &rhs)
 
template<typename E , class T , class A , class S >
flex_string< E, T, A, S > operator+ (const flex_string< E, T, A, S > &lhs, const typename flex_string< E, T, A, S >::value_type *rhs)
 
template<typename E , class T , class A , class S >
flex_string< E, T, A, S > operator+ (const flex_string< E, T, A, S > &lhs, typename flex_string< E, T, A, S >::value_type rhs)
 
template<typename E , class T , class A , class S >
bool operator== (const flex_string< E, T, A, S > &lhs, const flex_string< E, T, A, S > &rhs)
 
template<typename E , class T , class A , class S >
bool operator== (const typename flex_string< E, T, A, S >::value_type *lhs, const flex_string< E, T, A, S > &rhs)
 
template<typename E , class T , class A , class S >
bool operator== (const flex_string< E, T, A, S > &lhs, const typename flex_string< E, T, A, S >::value_type *rhs)
 
template<typename E , class T , class A , class S >
bool operator!= (const flex_string< E, T, A, S > &lhs, const flex_string< E, T, A, S > &rhs)
 
template<typename E , class T , class A , class S >
bool operator!= (const typename flex_string< E, T, A, S >::value_type *lhs, const flex_string< E, T, A, S > &rhs)
 
template<typename E , class T , class A , class S >
bool operator!= (const flex_string< E, T, A, S > &lhs, const typename flex_string< E, T, A, S >::value_type *rhs)
 
template<typename E , class T , class A , class S >
bool operator< (const flex_string< E, T, A, S > &lhs, const flex_string< E, T, A, S > &rhs)
 
template<typename E , class T , class A , class S >
bool operator< (const flex_string< E, T, A, S > &lhs, const typename flex_string< E, T, A, S >::value_type *rhs)
 
template<typename E , class T , class A , class S >
bool operator< (const typename flex_string< E, T, A, S >::value_type *lhs, const flex_string< E, T, A, S > &rhs)
 
template<typename E , class T , class A , class S >
bool operator> (const flex_string< E, T, A, S > &lhs, const flex_string< E, T, A, S > &rhs)
 
template<typename E , class T , class A , class S >
bool operator> (const flex_string< E, T, A, S > &lhs, const typename flex_string< E, T, A, S >::value_type *rhs)
 
template<typename E , class T , class A , class S >
bool operator> (const typename flex_string< E, T, A, S >::value_type *lhs, const flex_string< E, T, A, S > &rhs)
 
template<typename E , class T , class A , class S >
bool operator<= (const flex_string< E, T, A, S > &lhs, const flex_string< E, T, A, S > &rhs)
 
template<typename E , class T , class A , class S >
bool operator<= (const flex_string< E, T, A, S > &lhs, const typename flex_string< E, T, A, S >::value_type *rhs)
 
template<typename E , class T , class A , class S >
bool operator<= (const typename flex_string< E, T, A, S >::value_type *lhs, const flex_string< E, T, A, S > &rhs)
 
template<typename E , class T , class A , class S >
bool operator>= (const flex_string< E, T, A, S > &lhs, const flex_string< E, T, A, S > &rhs)
 
template<typename E , class T , class A , class S >
bool operator>= (const flex_string< E, T, A, S > &lhs, const typename flex_string< E, T, A, S >::value_type *rhs)
 
template<typename E , class T , class A , class S >
bool operator>= (const typename flex_string< E, T, A, S >::value_type *lhs, const flex_string< E, T, A, S > &rhs)
 
template<typename E , class T , class A , class S >
void swap (flex_string< E, T, A, S > &lhs, flex_string< E, T, A, S > &rhs)
 
template<typename E , class T , class A , class S >
std::basic_istream< typename
flex_string< E, T, A, S >
::value_type, typename
flex_string< E, T, A, S >
::traits_type > & 
operator>> (std::basic_istream< typename flex_string< E, T, A, S >::value_type, typename flex_string< E, T, A, S >::traits_type > &is, flex_string< E, T, A, S > &str)
 
template<typename E , class T , class A , class S >
std::basic_ostream< typename
flex_string< E, T, A, S >
::value_type, typename
flex_string< E, T, A, S >
::traits_type > & 
operator<< (std::basic_ostream< typename flex_string< E, T, A, S >::value_type, typename flex_string< E, T, A, S >::traits_type > &os, const flex_string< E, T, A, S > &str)
 
template<typename ContextT , typename IteratorT , typename ContainerT >
bool interpret_pragma (ContextT &ctx, typename ContextT::token_type const &act_token, IteratorT it, IteratorT const &end, ContainerT &pending)
 
template<typename TokenT , typename ContainerT >
void intrusive_ptr_add_ref (macro_definition< TokenT, ContainerT > *p)
 
template<typename TokenT , typename ContainerT >
void intrusive_ptr_release (macro_definition< TokenT, ContainerT > *p)
 
template<typename CharT >
pattern_and< CharT > pattern_p (CharT pattern, unsigned long pattern_mask=0UL)
 

Typedef Documentation

Enumeration Type Documentation

Enumerator
severity_remark 
severity_warning 
severity_error 
severity_fatal 
severity_commandline_error 
last_severity_code 

Function Documentation

boost::filesystem::path boost::wave::util::complete_path ( boost::filesystem::path const &  p,
boost::filesystem::path const &  base 
)
inline
bool boost::wave::util::create_directories ( boost::filesystem::path const &  p)
inline
boost::filesystem::path boost::wave::util::current_path ( )
inline
char const* boost::wave::util::get_severity ( int  level)
inline
boost::filesystem::path boost::wave::util::initial_path ( )
inline
template<typename TokenT , typename ContainerT >
void boost::wave::util::intrusive_ptr_add_ref ( macro_definition< TokenT, ContainerT > *  p)
inline
template<typename TokenT , typename ContainerT >
void boost::wave::util::intrusive_ptr_release ( macro_definition< TokenT, ContainerT > *  p)
inline
std::string boost::wave::util::leaf ( boost::filesystem::path const &  p)
inline
template<class T >
bool boost::wave::util::operator!= ( const mallocator< T > &  ,
const mallocator< T > &   
)
inline
template<typename E , class T , class A , class S >
bool boost::wave::util::operator!= ( const flex_string< E, T, A, S > &  lhs,
const flex_string< E, T, A, S > &  rhs 
)
inline
template<typename E , class T , class A , class S >
bool boost::wave::util::operator!= ( const typename flex_string< E, T, A, S >::value_type *  lhs,
const flex_string< E, T, A, S > &  rhs 
)
inline
template<typename E , class T , class A , class S >
bool boost::wave::util::operator!= ( const flex_string< E, T, A, S > &  lhs,
const typename flex_string< E, T, A, S >::value_type *  rhs 
)
inline
template<typename E , class T , class A , class S >
flex_string<E, T, A, S> boost::wave::util::operator+ ( const flex_string< E, T, A, S > &  lhs,
const flex_string< E, T, A, S > &  rhs 
)
template<typename E , class T , class A , class S >
flex_string<E, T, A, S> boost::wave::util::operator+ ( const typename flex_string< E, T, A, S >::value_type *  lhs,
const flex_string< E, T, A, S > &  rhs 
)
template<typename E , class T , class A , class S >
flex_string<E, T, A, S> boost::wave::util::operator+ ( typename flex_string< E, T, A, S >::value_type  lhs,
const flex_string< E, T, A, S > &  rhs 
)
template<typename E , class T , class A , class S >
flex_string<E, T, A, S> boost::wave::util::operator+ ( const flex_string< E, T, A, S > &  lhs,
const typename flex_string< E, T, A, S >::value_type *  rhs 
)
template<typename E , class T , class A , class S >
flex_string<E, T, A, S> boost::wave::util::operator+ ( const flex_string< E, T, A, S > &  lhs,
typename flex_string< E, T, A, S >::value_type  rhs 
)
template<typename E , class T , class A , class S >
bool boost::wave::util::operator< ( const flex_string< E, T, A, S > &  lhs,
const flex_string< E, T, A, S > &  rhs 
)
inline
template<typename E , class T , class A , class S >
bool boost::wave::util::operator< ( const flex_string< E, T, A, S > &  lhs,
const typename flex_string< E, T, A, S >::value_type *  rhs 
)
inline
template<typename E , class T , class A , class S >
bool boost::wave::util::operator< ( const typename flex_string< E, T, A, S >::value_type *  lhs,
const flex_string< E, T, A, S > &  rhs 
)
inline
template<typename StringT >
std::ostream& boost::wave::util::operator<< ( std::ostream &  o,
file_position< StringT > const &  pos 
)
inline
template<typename E , class T , class A , class S >
std::basic_ostream<typename flex_string<E, T, A, S>::value_type, typename flex_string<E, T, A, S>::traits_type>& boost::wave::util::operator<< ( std::basic_ostream< typename flex_string< E, T, A, S >::value_type, typename flex_string< E, T, A, S >::traits_type > &  os,
const flex_string< E, T, A, S > &  str 
)
template<typename E , class T , class A , class S >
bool boost::wave::util::operator<= ( const flex_string< E, T, A, S > &  lhs,
const flex_string< E, T, A, S > &  rhs 
)
inline
template<typename E , class T , class A , class S >
bool boost::wave::util::operator<= ( const flex_string< E, T, A, S > &  lhs,
const typename flex_string< E, T, A, S >::value_type *  rhs 
)
inline
template<typename E , class T , class A , class S >
bool boost::wave::util::operator<= ( const typename flex_string< E, T, A, S >::value_type *  lhs,
const flex_string< E, T, A, S > &  rhs 
)
template<typename StringT >
bool boost::wave::util::operator== ( file_position< StringT > const &  lhs,
file_position< StringT > const &  rhs 
)
template<class T >
bool boost::wave::util::operator== ( const mallocator< T > &  ,
const mallocator< T > &   
)
inline
template<typename E , class T , class A , class S >
bool boost::wave::util::operator== ( const flex_string< E, T, A, S > &  lhs,
const flex_string< E, T, A, S > &  rhs 
)
inline
template<typename E , class T , class A , class S >
bool boost::wave::util::operator== ( const typename flex_string< E, T, A, S >::value_type *  lhs,
const flex_string< E, T, A, S > &  rhs 
)
inline
template<typename E , class T , class A , class S >
bool boost::wave::util::operator== ( const flex_string< E, T, A, S > &  lhs,
const typename flex_string< E, T, A, S >::value_type *  rhs 
)
inline
template<typename E , class T , class A , class S >
bool boost::wave::util::operator> ( const flex_string< E, T, A, S > &  lhs,
const flex_string< E, T, A, S > &  rhs 
)
inline
template<typename E , class T , class A , class S >
bool boost::wave::util::operator> ( const flex_string< E, T, A, S > &  lhs,
const typename flex_string< E, T, A, S >::value_type *  rhs 
)
inline
template<typename E , class T , class A , class S >
bool boost::wave::util::operator> ( const typename flex_string< E, T, A, S >::value_type *  lhs,
const flex_string< E, T, A, S > &  rhs 
)
template<typename E , class T , class A , class S >
bool boost::wave::util::operator>= ( const flex_string< E, T, A, S > &  lhs,
const flex_string< E, T, A, S > &  rhs 
)
template<typename E , class T , class A , class S >
bool boost::wave::util::operator>= ( const flex_string< E, T, A, S > &  lhs,
const typename flex_string< E, T, A, S >::value_type *  rhs 
)
template<typename E , class T , class A , class S >
bool boost::wave::util::operator>= ( const typename flex_string< E, T, A, S >::value_type *  lhs,
const flex_string< E, T, A, S > &  rhs 
)
inline
template<typename E , class T , class A , class S >
std::basic_istream<typename flex_string<E, T, A, S>::value_type, typename flex_string<E, T, A, S>::traits_type>& boost::wave::util::operator>> ( std::basic_istream< typename flex_string< E, T, A, S >::value_type, typename flex_string< E, T, A, S >::traits_type > &  is,
flex_string< E, T, A, S > &  str 
)
inline
template<class Allocator >
Allocator::pointer boost::wave::util::Reallocate ( Allocator &  alloc,
typename Allocator::pointer  p,
typename Allocator::size_type  oldObjCount,
typename Allocator::size_type  newObjCount,
void *   
)
template<class Allocator >
Allocator::pointer boost::wave::util::Reallocate ( Allocator &  alloc,
typename Allocator::pointer  p,
typename Allocator::size_type  oldObjCount,
typename Allocator::size_type  newObjCount,
mallocator< void > *   
)
template<typename Context >
void boost::wave::util::report_invalid_concatenation ( Context &  ctx,
typename Context::token_type const &  prev,
typename Context::token_type const &  next,
typename Context::position_type const &  main_pos 
)
inline
template<typename ParseNodeT , typename ContainerT , typename PositionT >
bool boost::wave::util::retrieve_macrodefinition ( ParseNodeT const &  node,
boost::spirit::classic::parser_id  id,
ContainerT &  macrodefinition,
PositionT &  act_pos,
bool  update_position 
)
inline
template<typename ContextT , typename ParseNodeT , typename TokenT , typename PositionT >
bool boost::wave::util::retrieve_macroname ( ContextT &  ctx,
ParseNodeT const &  node,
boost::spirit::classic::parser_id  id,
TokenT &  macroname,
PositionT &  act_pos,
bool  update_position 
)
inline
template<typename Exception , typename S1 , typename Pos >
void boost::wave::util::throw_ ( typename Exception::error_code  code,
S1  msg,
Pos const &  pos 
)
template<typename Exception , typename Context , typename S1 , typename Pos >
void boost::wave::util::throw_ ( Context &  ctx,
typename Exception::error_code  code,
S1  msg,
Pos const &  pos 
)
template<typename Exception , typename S1 , typename Pos , typename S2 >
void boost::wave::util::throw_ ( typename Exception::error_code  code,
S1  msg,
Pos const &  pos,
S2  name 
)
template<typename Exception , typename Context , typename S1 , typename Pos1 , typename S2 >
void boost::wave::util::throw_ ( Context &  ctx,
typename Exception::error_code  code,
S1  msg,
Pos1 const &  pos,
S2  name 
)
template<typename Target , typename Src >
impl::to_string_helper<Target, Src>::type boost::wave::util::to_string ( Src const &  src)
inline