pugixml.cc File Reference

#include "pugixml.hpp"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <assert.h>
#include <limits.h>
#include <math.h>
#include <float.h>
#include <istream>
#include <ostream>
#include <string>
#include <new>
#include <stdint.h>

Go to the source code of this file.

Classes
struct	xml_memory_management_function_storage< T >
struct	auto_deleter< T >
struct	xml_memory_page
struct	xml_memory_string_header
struct	xml_allocator
struct	pugi::xml_attribute_struct
struct	pugi::xml_node_struct
struct	xml_extra_buffer
struct	xml_document_struct
struct	opt_false
struct	opt_true
struct	utf8_counter
struct	utf8_writer
struct	utf16_counter
struct	utf16_writer
struct	utf32_counter
struct	utf32_writer
struct	latin1_writer
struct	utf8_decoder
struct	utf16_decoder< opt_swap >
struct	utf32_decoder< opt_swap >
struct	latin1_decoder
struct	wchar_selector< 2 >
struct	wchar_selector< 4 >
struct	wchar_decoder
struct	gap
struct	strconv_pcdata_impl< opt_trim, opt_eol, opt_escape >
struct	strconv_attribute_impl< opt_escape >
struct	xml_parser
class	xml_buffered_writer
struct	xml_stream_chunk< T >
struct	name_null_sentry
struct	equal_to
struct	not_equal_to
struct	less
struct	less_equal
struct	xpath_memory_block
struct	xpath_allocator
struct	xpath_allocator_capture
struct	xpath_stack
struct	xpath_stack_data
class	xpath_string
struct	document_order_comparator
struct	namespace_uri_predicate
struct	xpath_variable_boolean
struct	xpath_variable_number
struct	xpath_variable_string
struct	xpath_variable_node_set
class	xpath_node_set_raw
struct	xpath_context
struct	xpath_lexer_string
class	xpath_lexer
struct	axis_to_type< N >
class	xpath_ast_node
struct	xpath_parser
struct	xpath_parser::binary_op_t
struct	xpath_query_impl

Namespaces
namespace	pugi

Macros
#define	SOURCE_PUGIXML_CPP
#define	PUGI__NO_INLINE
#define	PUGI__UNLIKELY(cond)
#define	PUGI__STATIC_ASSERT(cond)
#define	PUGI__DMC_VOLATILE
#define	PUGI__UNSIGNED_OVERFLOW
#define	PUGI__SNPRINTF   sprintf
#define	PUGI__NS_BEGIN   namespace pugi { namespace impl { namespace {
#define	PUGI__NS_END   } } }
#define	PUGI__FN
#define	PUGI__FN_NO_INLINE   PUGI__NO_INLINE
#define	PUGI__GETHEADER_IMPL(object, page, flags)
#define	PUGI__GETPAGE_IMPL(header)
#define	PUGI__GETPAGE(n)
#define	PUGI__NODETYPE(n)
#define	PUGI__IS_CHARTYPE_IMPL(c, ct, table)
#define	PUGI__IS_CHARTYPE(c, ct)
#define	PUGI__IS_CHARTYPEX(c, ct)
#define	PUGI__SCANCHAR(ch)
#define	PUGI__SCANCHARTYPE(ct)
#define	PUGI__ENDSWITH(c, e)
#define	PUGI__SKIPWS()
#define	PUGI__OPTSET(OPT)
#define	PUGI__PUSHNODE(TYPE)
#define	PUGI__POPNODE()
#define	PUGI__SCANFOR(X)
#define	PUGI__SCANWHILE(X)
#define	PUGI__SCANWHILE_UNROLL(X)
#define	PUGI__ENDSEG()
#define	PUGI__THROW_ERROR(err, m)
#define	PUGI__CHECK_ERROR(err, m)

Typedefs
typedef xml_memory_management_function_storage< int >	xml_memory
typedef wchar_selector< sizeof(wchar_t)>::counter	wchar_counter
typedef wchar_selector< sizeof(wchar_t)>::writer	wchar_writer
typedef char_t *(*	strconv_pcdata_t) (char_t *)
typedef char_t *(*	strconv_attribute_t) (char_t *, char_t)

Enumerations
enum	chartype_t {   ct_parse_pcdata = 1 , ct_parse_attr = 2 , ct_parse_attr_ws = 4 , ct_space = 8 ,   ct_parse_cdata = 16 , ct_parse_comment = 32 , ct_symbol = 64 , ct_start_symbol = 128 }
enum	chartypex_t {   ctx_special_pcdata = 1 , ctx_special_attr = 2 , ctx_start_symbol = 4 , ctx_digit = 8 ,   ctx_symbol = 16 }
enum	indent_flags_t { indent_newline = 1 , indent_indent = 2 }
enum	lexeme_t {   lex_none = 0 , lex_equal , lex_not_equal , lex_less ,   lex_greater , lex_less_or_equal , lex_greater_or_equal , lex_plus ,   lex_minus , lex_multiply , lex_union , lex_var_ref ,   lex_open_brace , lex_close_brace , lex_quoted_string , lex_number ,   lex_slash , lex_double_slash , lex_open_square_brace , lex_close_square_brace ,   lex_string , lex_comma , lex_axis_attribute , lex_dot ,   lex_double_dot , lex_double_colon , lex_eof }
enum	ast_type_t {   ast_unknown , ast_op_or , ast_op_and , ast_op_equal ,   ast_op_not_equal , ast_op_less , ast_op_greater , ast_op_less_or_equal ,   ast_op_greater_or_equal , ast_op_add , ast_op_subtract , ast_op_multiply ,   ast_op_divide , ast_op_mod , ast_op_negate , ast_op_union ,   ast_predicate , ast_filter , ast_string_constant , ast_number_constant ,   ast_variable , ast_func_last , ast_func_position , ast_func_count ,   ast_func_id , ast_func_local_name_0 , ast_func_local_name_1 , ast_func_namespace_uri_0 ,   ast_func_namespace_uri_1 , ast_func_name_0 , ast_func_name_1 , ast_func_string_0 ,   ast_func_string_1 , ast_func_concat , ast_func_starts_with , ast_func_contains ,   ast_func_substring_before , ast_func_substring_after , ast_func_substring_2 , ast_func_substring_3 ,   ast_func_string_length_0 , ast_func_string_length_1 , ast_func_normalize_space_0 , ast_func_normalize_space_1 ,   ast_func_translate , ast_func_boolean , ast_func_not , ast_func_true ,   ast_func_false , ast_func_lang , ast_func_number_0 , ast_func_number_1 ,   ast_func_sum , ast_func_floor , ast_func_ceiling , ast_func_round ,   ast_step , ast_step_root , ast_opt_translate_table , ast_opt_compare_attribute }
enum	axis_t {   axis_ancestor , axis_ancestor_or_self , axis_attribute , axis_child ,   axis_descendant , axis_descendant_or_self , axis_following , axis_following_sibling ,   axis_namespace , axis_parent , axis_preceding , axis_preceding_sibling ,   axis_self }
enum	nodetest_t {   nodetest_none , nodetest_name , nodetest_type_node , nodetest_type_comment ,   nodetest_type_pi , nodetest_type_text , nodetest_pi , nodetest_all ,   nodetest_all_in_namespace }
enum	predicate_t { predicate_default , predicate_posinv , predicate_constant , predicate_constant_one }
enum	nodeset_eval_t { nodeset_eval_all , nodeset_eval_any , nodeset_eval_first }

Functions
PUGI__NS_BEGIN PUGI__FN void *	default_allocate (size_t size)
PUGI__FN void	default_deallocate (void *ptr)
PUGI__NS_END PUGI__NS_BEGIN PUGI__FN size_t	strlength (const char_t *s)
PUGI__FN bool	strequal (const char_t *src, const char_t *dst)
PUGI__FN bool	strequalrange (const char_t *lhs, const char_t *rhs, size_t count)
PUGI__FN size_t	strlength_wide (const wchar_t *s)
template<typename Object>
xml_allocator &	get_allocator (const Object *object)
template<typename Object>
xml_document_struct &	get_document (const Object *object)
PUGI__NS_END PUGI__NS_BEGIN xml_attribute_struct *	allocate_attribute (xml_allocator &alloc)
xml_node_struct *	allocate_node (xml_allocator &alloc, xml_node_type type)
void	destroy_attribute (xml_attribute_struct *a, xml_allocator &alloc)
void	destroy_node (xml_node_struct *n, xml_allocator &alloc)
void	append_node (xml_node_struct *child, xml_node_struct *node)
void	prepend_node (xml_node_struct *child, xml_node_struct *node)
void	insert_node_after (xml_node_struct *child, xml_node_struct *node)
void	insert_node_before (xml_node_struct *child, xml_node_struct *node)
void	remove_node (xml_node_struct *node)
void	append_attribute (xml_attribute_struct *attr, xml_node_struct *node)
void	prepend_attribute (xml_attribute_struct *attr, xml_node_struct *node)
void	insert_attribute_after (xml_attribute_struct *attr, xml_attribute_struct *place, xml_node_struct *node)
void	insert_attribute_before (xml_attribute_struct *attr, xml_attribute_struct *place, xml_node_struct *node)
void	remove_attribute (xml_attribute_struct *attr, xml_node_struct *node)
PUGI__FN_NO_INLINE xml_node_struct *	append_new_node (xml_node_struct *node, xml_allocator &alloc, xml_node_type type=node_element)
PUGI__FN_NO_INLINE xml_attribute_struct *	append_new_attribute (xml_node_struct *node, xml_allocator &alloc)
PUGI__NS_END PUGI__NS_BEGIN uint16_t	endian_swap (uint16_t value)
uint32_t	endian_swap (uint32_t value)
PUGI__FN bool	is_little_endian ()
PUGI__FN xml_encoding	get_wchar_encoding ()
PUGI__FN bool	parse_declaration_encoding (const uint8_t *data, size_t size, const uint8_t *&out_encoding, size_t &out_length)
PUGI__FN xml_encoding	guess_buffer_encoding (const uint8_t *data, size_t size)
PUGI__FN xml_encoding	get_buffer_encoding (xml_encoding encoding, const void *contents, size_t size)
PUGI__FN bool	get_mutable_buffer (char_t *&out_buffer, size_t &out_length, const void *contents, size_t size, bool is_mutable)
template<typename D>
PUGI__FN bool	convert_buffer_generic (char_t *&out_buffer, size_t &out_length, const void *contents, size_t size, D)
PUGI__FN size_t	get_latin1_7bit_prefix_length (const uint8_t *data, size_t size)
PUGI__FN bool	convert_buffer_latin1 (char_t *&out_buffer, size_t &out_length, const void *contents, size_t size, bool is_mutable)
PUGI__FN bool	convert_buffer (char_t *&out_buffer, size_t &out_length, xml_encoding encoding, const void *contents, size_t size, bool is_mutable)
PUGI__FN size_t	as_utf8_begin (const wchar_t *str, size_t length)
PUGI__FN void	as_utf8_end (char *buffer, size_t size, const wchar_t *str, size_t length)
PUGI__FN std::string	as_utf8_impl (const wchar_t *str, size_t length)
PUGI__FN std::basic_string< wchar_t >	as_wide_impl (const char *str, size_t size)
template<typename Header>
bool	strcpy_insitu_allow (size_t length, const Header &header, uintptr_t header_mask, char_t *target)
template<typename String, typename Header>
PUGI__FN bool	strcpy_insitu (String &dest, Header &header, uintptr_t header_mask, const char_t *source, size_t source_length)
PUGI__FN char_t *	strconv_escape (char_t *s, gap &g)
PUGI__FN char_t *	strconv_comment (char_t *s, char_t endch)
PUGI__FN char_t *	strconv_cdata (char_t *s, char_t endch)
PUGI__FN strconv_pcdata_t	get_strconv_pcdata (unsigned int optmask)
PUGI__FN strconv_attribute_t	get_strconv_attribute (unsigned int optmask)
xml_parse_result	make_parse_result (xml_parse_status status, ptrdiff_t offset=0)
PUGI__FN xml_encoding	get_write_native_encoding ()
PUGI__FN xml_encoding	get_write_encoding (xml_encoding encoding)
template<typename D, typename T>
PUGI__FN size_t	convert_buffer_output_generic (typename T::value_type dest, const char_t *data, size_t length, D, T)
template<typename D, typename T>
PUGI__FN size_t	convert_buffer_output_generic (typename T::value_type dest, const char_t *data, size_t length, D, T, bool opt_swap)
PUGI__FN size_t	get_valid_length (const char_t *data, size_t length)
PUGI__FN size_t	convert_buffer_output (char_t *, uint8_t *r_u8, uint16_t *r_u16, uint32_t *r_u32, const char_t *data, size_t length, xml_encoding encoding)
PUGI__FN void	text_output_escaped (xml_buffered_writer &writer, const char_t *s, chartypex_t type, unsigned int flags)
PUGI__FN void	text_output (xml_buffered_writer &writer, const char_t *s, chartypex_t type, unsigned int flags)
PUGI__FN void	text_output_cdata (xml_buffered_writer &writer, const char_t *s)
PUGI__FN void	text_output_indent (xml_buffered_writer &writer, const char_t *indent, size_t indent_length, unsigned int depth)
PUGI__FN void	node_output_comment (xml_buffered_writer &writer, const char_t *s)
PUGI__FN void	node_output_pi_value (xml_buffered_writer &writer, const char_t *s)
PUGI__FN void	node_output_attributes (xml_buffered_writer &writer, xml_node_struct *node, const char_t *indent, size_t indent_length, unsigned int flags, unsigned int depth)
PUGI__FN bool	node_output_start (xml_buffered_writer &writer, xml_node_struct *node, const char_t *indent, size_t indent_length, unsigned int flags, unsigned int depth)
PUGI__FN void	node_output_end (xml_buffered_writer &writer, xml_node_struct *node)
PUGI__FN void	node_output_simple (xml_buffered_writer &writer, xml_node_struct *node, unsigned int flags)
PUGI__FN void	node_output (xml_buffered_writer &writer, xml_node_struct *root, const char_t *indent, unsigned int flags, unsigned int depth)
PUGI__FN bool	has_declaration (xml_node_struct *node)
PUGI__FN bool	is_attribute_of (xml_attribute_struct *attr, xml_node_struct *node)
PUGI__FN bool	allow_insert_attribute (xml_node_type parent)
PUGI__FN bool	allow_insert_child (xml_node_type parent, xml_node_type child)
PUGI__FN bool	allow_move (xml_node parent, xml_node child)
template<typename String, typename Header>
PUGI__FN void	node_copy_string (String &dest, Header &header, uintptr_t header_mask, char_t *source, Header &source_header, xml_allocator *alloc)
PUGI__FN void	node_copy_contents (xml_node_struct *dn, xml_node_struct *sn, xml_allocator *shared_alloc)
PUGI__FN void	node_copy_tree (xml_node_struct *dn, xml_node_struct *sn)
PUGI__FN void	node_copy_attribute (xml_attribute_struct *da, xml_attribute_struct *sa)
bool	is_text_node (xml_node_struct *node)
template<typename U>
PUGI__FN PUGI__UNSIGNED_OVERFLOW U	string_to_integer (const char_t *value, U minv, U maxv)
PUGI__FN int	get_value_int (const char_t *value)
PUGI__FN unsigned int	get_value_uint (const char_t *value)
PUGI__FN double	get_value_double (const char_t *value)
PUGI__FN float	get_value_float (const char_t *value)
PUGI__FN bool	get_value_bool (const char_t *value)
template<typename U>
PUGI__FN PUGI__UNSIGNED_OVERFLOW char_t *	integer_to_string (char_t *begin, char_t *end, U value, bool negative)
template<typename String, typename Header>
PUGI__FN bool	set_value_ascii (String &dest, Header &header, uintptr_t header_mask, char *buf)
template<typename U, typename String, typename Header>
PUGI__FN bool	set_value_integer (String &dest, Header &header, uintptr_t header_mask, U value, bool negative)
template<typename String, typename Header>
PUGI__FN bool	set_value_convert (String &dest, Header &header, uintptr_t header_mask, float value, int precision)
template<typename String, typename Header>
PUGI__FN bool	set_value_convert (String &dest, Header &header, uintptr_t header_mask, double value, int precision)
template<typename String, typename Header>
PUGI__FN bool	set_value_bool (String &dest, Header &header, uintptr_t header_mask, bool value)
PUGI__FN xml_parse_result	load_buffer_impl (xml_document_struct *doc, xml_node_struct *root, void *contents, size_t size, unsigned int options, xml_encoding encoding, bool is_mutable, bool own, char_t **out_buffer)
PUGI__FN xml_parse_status	get_file_size (FILE *file, size_t &out_result)
PUGI__FN size_t	zero_terminate_buffer (void *buffer, size_t size, xml_encoding encoding)
PUGI__FN xml_parse_result	load_file_impl (xml_document_struct *doc, FILE *file, unsigned int options, xml_encoding encoding, char_t **out_buffer)
PUGI__FN void	close_file (FILE *file)
template<typename T>
PUGI__FN xml_parse_status	load_stream_data_noseek (std::basic_istream< T > &stream, void **out_buffer, size_t *out_size)
template<typename T>
PUGI__FN xml_parse_status	load_stream_data_seek (std::basic_istream< T > &stream, void **out_buffer, size_t *out_size)
template<typename T>
PUGI__FN xml_parse_result	load_stream_impl (xml_document_struct *doc, std::basic_istream< T > &stream, unsigned int options, xml_encoding encoding, char_t **out_buffer)
PUGI__FN char *	convert_path_heap (const wchar_t *str)
PUGI__FN FILE *	open_file_wide (const wchar_t *path, const wchar_t *mode)
PUGI__FN FILE *	open_file (const char *path, const char *mode)
PUGI__FN bool	save_file_impl (const xml_document &doc, FILE *file, const char_t *indent, unsigned int flags, xml_encoding encoding)
std::basic_string< char, std::char_traits< char >, std::allocator< char > > PUGIXML_FUNCTION	pugi::as_utf8 (const wchar_t *str)
PUGI__FN std::string PUGIXML_FUNCTION	pugi::as_utf8 (const std::basic_string< wchar_t > &str)
std::basic_string< wchar_t, std::char_traits< wchar_t >, std::allocator< wchar_t > > PUGIXML_FUNCTION	pugi::as_wide (const char *str)
PUGI__FN std::basic_string< wchar_t > PUGIXML_FUNCTION	pugi::as_wide (const std::string &str)
void PUGIXML_FUNCTION	pugi::set_memory_management_functions (allocation_function allocate, deallocation_function deallocate)
allocation_function PUGIXML_FUNCTION	pugi::get_memory_allocation_function ()
deallocation_function PUGIXML_FUNCTION	pugi::get_memory_deallocation_function ()
template<typename T>
void	swap (T &lhs, T &rhs)
template<typename I, typename Pred>
PUGI__FN I	min_element (I begin, I end, const Pred &pred)
template<typename I>
PUGI__FN void	reverse (I begin, I end)
template<typename I>
PUGI__FN I	unique (I begin, I end)
template<typename T, typename Pred>
PUGI__FN void	insertion_sort (T *begin, T *end, const Pred &pred)
template<typename I, typename Pred>
I	median3 (I first, I middle, I last, const Pred &pred)
template<typename T, typename Pred>
PUGI__FN void	partition3 (T *begin, T *end, T pivot, const Pred &pred, T **out_eqbeg, T **out_eqend)
template<typename I, typename Pred>
PUGI__FN void	sort (I begin, I end, const Pred &pred)
PUGI__FN bool	hash_insert (const void **table, size_t size, const void *key)
PUGI__NS_END PUGI__NS_BEGIN PUGI__FN bool	starts_with (const char_t *string, const char_t *pattern)
PUGI__FN const char_t *	find_char (const char_t *s, char_t c)
PUGI__FN const char_t *	find_substring (const char_t *s, const char_t *p)
PUGI__FN char_t	tolower_ascii (char_t ch)
PUGI__FN xpath_string	string_value (const xpath_node &na, xpath_allocator *alloc)
PUGI__FN bool	node_is_before_sibling (xml_node_struct *ln, xml_node_struct *rn)
PUGI__FN bool	node_is_before (xml_node_struct *ln, xml_node_struct *rn)
PUGI__FN bool	node_is_ancestor (xml_node_struct *parent, xml_node_struct *node)
PUGI__FN const void *	document_buffer_order (const xpath_node &xnode)
PUGI__FN double	gen_nan ()
PUGI__FN bool	is_nan (double value)
PUGI__FN const char_t *	convert_number_to_string_special (double value)
PUGI__FN bool	convert_number_to_boolean (double value)
PUGI__FN void	truncate_zeros (char *begin, char *end)
PUGI__FN void	convert_number_to_mantissa_exponent (double value, char(&buffer)[32], char **out_mantissa, int *out_exponent)
PUGI__FN xpath_string	convert_number_to_string (double value, xpath_allocator *alloc)
PUGI__FN bool	check_string_to_number_format (const char_t *string)
PUGI__FN double	convert_string_to_number (const char_t *string)
PUGI__FN bool	convert_string_to_number_scratch (char_t(&buffer)[32], const char_t *begin, const char_t *end, double *out_result)
PUGI__FN double	round_nearest (double value)
PUGI__FN double	round_nearest_nzero (double value)
PUGI__FN const char_t *	qualified_name (const xpath_node &node)
PUGI__FN const char_t *	local_name (const xpath_node &node)
PUGI__FN const char_t *	namespace_uri (xml_node node)
PUGI__FN const char_t *	namespace_uri (xml_attribute attr, xml_node parent)
PUGI__FN const char_t *	namespace_uri (const xpath_node &node)
PUGI__FN char_t *	normalize_space (char_t *buffer)
PUGI__FN char_t *	translate (char_t *buffer, const char_t *from, const char_t *to, size_t to_length)
PUGI__FN unsigned char *	translate_table_generate (xpath_allocator *alloc, const char_t *from, const char_t *to)
PUGI__FN char_t *	translate_table (char_t *buffer, const unsigned char *table)
bool	is_xpath_attribute (const char_t *name)
PUGI__FN PUGI__UNSIGNED_OVERFLOW unsigned int	hash_string (const char_t *str)
template<typename T>
PUGI__FN T *	new_xpath_variable (const char_t *name)
PUGI__FN xpath_variable *	new_xpath_variable (xpath_value_type type, const char_t *name)
template<typename T>
PUGI__FN void	delete_xpath_variable (T *var)
PUGI__FN void	delete_xpath_variable (xpath_value_type type, xpath_variable *var)
PUGI__FN bool	copy_xpath_variable (xpath_variable *lhs, const xpath_variable *rhs)
PUGI__FN bool	get_variable_scratch (char_t(&buffer)[32], xpath_variable_set *set, const char_t *begin, const char_t *end, xpath_variable **out_result)
PUGI__NS_END PUGI__NS_BEGIN PUGI__FN xpath_node_set::type_t	xpath_get_order (const xpath_node *begin, const xpath_node *end)
PUGI__FN xpath_node_set::type_t	xpath_sort (xpath_node *begin, xpath_node *end, xpath_node_set::type_t type, bool rev)
PUGI__FN xpath_node	xpath_first (const xpath_node *begin, const xpath_node *end, xpath_node_set::type_t type)
PUGI__FN impl::xpath_ast_node *	evaluate_node_set_prepare (xpath_query_impl *impl)

Variables
template<typename T>
allocation_function	xml_memory_management_function_storage< T >::allocate = default_allocate
template<typename T>
deallocation_function	xml_memory_management_function_storage< T >::deallocate = default_deallocate
template<axis_t N>
const axis_t	axis_to_type< N >::axis = N

Macro Definition Documentation

PUGI__CHECK_ERROR

#define PUGI__CHECK_ERROR	(		err,
			m )

Value:

{ if (*s == 0) PUGI__THROW_ERROR(err, m); }

Definition at line 2614 of file pugixml.cc.

Referenced by xml_parser::parse_exclamation(), and xml_parser::parse_question().

PUGI__DMC_VOLATILE

#define PUGI__DMC_VOLATILE

Definition at line 106 of file pugixml.cc.

Referenced by translate().

PUGI__ENDSEG

#define PUGI__ENDSEG

(

)

Value:

{ ch = *s; *s = 0; ++s; }

Definition at line 2612 of file pugixml.cc.

Referenced by xml_parser::parse_question(), and xml_parser::parse_tree().

PUGI__ENDSWITH

#define PUGI__ENDSWITH	(		c,
			e )

Value:

((c) == (e) || ((c) == 0 && endch == (e)))

Definition at line 2604 of file pugixml.cc.

Referenced by xml_parser::parse_exclamation(), xml_parser::parse_question(), xml_parser::parse_tree(), strconv_cdata(), and strconv_comment().

PUGI__FN

#define PUGI__FN

Definition at line 164 of file pugixml.cc.

Referenced by pugi::xpath_variable_set::add(), allow_insert_attribute(), allow_insert_child(), allow_move(), pugi::xml_node::append_attribute(), pugi::xml_node::append_buffer(), pugi::xml_node::append_child(), pugi::xml_node::append_child(), pugi::xml_node::append_copy(), pugi::xml_node::append_copy(), pugi::xml_node::append_move(), pugi::xml_attribute::as_bool(), pugi::xml_text::as_bool(), pugi::xml_attribute::as_double(), pugi::xml_text::as_double(), pugi::xml_attribute::as_float(), pugi::xml_text::as_float(), pugi::xml_attribute::as_int(), pugi::xml_text::as_int(), pugi::xml_attribute::as_string(), pugi::xml_text::as_string(), pugi::xml_attribute::as_uint(), pugi::xml_text::as_uint(), pugi::as_utf8(), pugi::as_utf8(), as_utf8_begin(), as_utf8_end(), as_utf8_impl(), pugi::as_wide(), pugi::as_wide(), as_wide_impl(), pugi::xml_node::attribute(), pugi::xml_node::attribute(), pugi::xpath_node::attribute(), pugi::xml_node::attributes(), pugi::xml_node::attributes_begin(), pugi::xml_node::attributes_end(), pugi::xml_node::begin(), pugi::xml_tree_walker::begin(), pugi::xpath_node_set::begin(), check_string_to_number_format(), pugi::xml_node::child(), pugi::xml_node::child_value(), pugi::xml_node::child_value(), pugi::xml_node::children(), pugi::xml_node::children(), close_file(), convert_buffer(), convert_buffer_generic(), convert_buffer_latin1(), convert_buffer_output(), convert_buffer_output_generic(), convert_buffer_output_generic(), convert_number_to_boolean(), convert_number_to_mantissa_exponent(), convert_number_to_string(), convert_number_to_string_special(), convert_path_heap(), convert_string_to_number(), convert_string_to_number_scratch(), copy_xpath_variable(), pugi::xml_text::data(), default_allocate(), default_deallocate(), delete_xpath_variable(), delete_xpath_variable(), pugi::xml_tree_walker::depth(), pugi::xml_parse_result::description(), pugi::xpath_parse_result::description(), document_buffer_order(), pugi::xml_document::document_element(), pugi::xml_attribute::empty(), pugi::xml_node::empty(), pugi::xml_text::empty(), pugi::xpath_node_set::empty(), pugi::xml_node::end(), pugi::xml_tree_walker::end(), pugi::xpath_node_set::end(), pugi::xpath_query::evaluate_boolean(), pugi::xpath_query::evaluate_node(), pugi::xpath_query::evaluate_node_set(), evaluate_node_set_prepare(), pugi::xpath_query::evaluate_number(), pugi::xpath_query::evaluate_string(), pugi::xpath_query::evaluate_string(), find_char(), pugi::xml_node::find_child_by_attribute(), pugi::xml_node::find_child_by_attribute(), find_substring(), pugi::xpath_node_set::first(), pugi::xml_node::first_attribute(), pugi::xml_node::first_child(), pugi::xml_node::first_element_by_path(), gen_nan(), pugi::xml_text::get(), pugi::xpath_variable_set::get(), pugi::xpath_variable_set::get(), pugi::xpath_variable::get_boolean(), get_buffer_encoding(), get_file_size(), get_latin1_7bit_prefix_length(), pugi::get_memory_allocation_function(), pugi::get_memory_deallocation_function(), get_mutable_buffer(), pugi::xpath_variable::get_node_set(), pugi::xpath_variable::get_number(), get_strconv_attribute(), get_strconv_pcdata(), pugi::xpath_variable::get_string(), get_valid_length(), get_value_bool(), get_value_double(), get_value_float(), get_value_int(), get_value_uint(), get_variable_scratch(), get_wchar_encoding(), get_write_encoding(), get_write_native_encoding(), guess_buffer_encoding(), has_declaration(), hash_insert(), hash_string(), pugi::xml_attribute::hash_value(), pugi::xml_node::hash_value(), pugi::xml_node::insert_attribute_after(), pugi::xml_node::insert_attribute_before(), pugi::xml_node::insert_child_after(), pugi::xml_node::insert_child_after(), pugi::xml_node::insert_child_before(), pugi::xml_node::insert_child_before(), pugi::xml_node::insert_copy_after(), pugi::xml_node::insert_copy_after(), pugi::xml_node::insert_copy_before(), pugi::xml_node::insert_copy_before(), pugi::xml_node::insert_move_after(), pugi::xml_node::insert_move_before(), insertion_sort(), integer_to_string(), pugi::xml_attribute::internal_object(), pugi::xml_node::internal_object(), is_attribute_of(), is_little_endian(), is_nan(), pugi::xml_node::last_attribute(), pugi::xml_node::last_child(), pugi::xml_document::load(), pugi::xml_document::load(), pugi::xml_document::load(), pugi::xml_document::load_buffer(), load_buffer_impl(), pugi::xml_document::load_buffer_inplace(), pugi::xml_document::load_buffer_inplace_own(), pugi::xml_document::load_file(), pugi::xml_document::load_file(), load_file_impl(), load_stream_data_noseek(), load_stream_data_seek(), load_stream_impl(), pugi::xml_document::load_string(), local_name(), min_element(), pugi::xml_attribute::name(), pugi::xml_node::name(), pugi::xpath_variable::name(), namespace_uri(), namespace_uri(), namespace_uri(), new_xpath_variable(), new_xpath_variable(), pugi::xml_attribute::next_attribute(), pugi::xml_node::next_sibling(), pugi::xml_node::next_sibling(), pugi::xpath_node::node(), node_copy_attribute(), node_copy_contents(), node_copy_string(), node_copy_tree(), node_is_ancestor(), node_is_before(), node_is_before_sibling(), node_output(), node_output_attributes(), node_output_comment(), node_output_end(), node_output_pi_value(), node_output_simple(), node_output_start(), normalize_space(), pugi::xml_node::offset_debug(), open_file(), open_file_wide(), pugi::xml_parse_result::operator bool(), pugi::xpath_parse_result::operator bool(), pugi::xml_attribute::operator unspecified_bool_type(), pugi::xml_node::operator unspecified_bool_type(), pugi::xml_text::operator unspecified_bool_type(), pugi::xpath_node::operator unspecified_bool_type(), pugi::xpath_query::operator unspecified_bool_type(), pugi::xml_attribute::operator!(), pugi::xml_node::operator!(), pugi::xml_text::operator!(), pugi::xpath_node::operator!(), pugi::xpath_query::operator!(), pugi::xml_attribute::operator!=(), pugi::xml_attribute_iterator::operator!=(), pugi::xml_named_node_iterator::operator!=(), pugi::xml_node::operator!=(), pugi::xml_node_iterator::operator!=(), pugi::xpath_node::operator!=(), pugi::xml_attribute_iterator::operator*(), pugi::xml_named_node_iterator::operator*(), pugi::xml_node_iterator::operator*(), pugi::xml_attribute_iterator::operator++(), pugi::xml_attribute_iterator::operator++(), pugi::xml_named_node_iterator::operator++(), pugi::xml_named_node_iterator::operator++(), pugi::xml_node_iterator::operator++(), pugi::xml_node_iterator::operator++(), pugi::xml_attribute_iterator::operator--(), pugi::xml_attribute_iterator::operator--(), pugi::xml_named_node_iterator::operator--(), pugi::xml_named_node_iterator::operator--(), pugi::xml_node_iterator::operator--(), pugi::xml_node_iterator::operator--(), pugi::xml_attribute_iterator::operator->(), pugi::xml_named_node_iterator::operator->(), pugi::xml_node_iterator::operator->(), pugi::xml_attribute::operator<(), pugi::xml_node::operator<(), pugi::xml_attribute::operator<=(), pugi::xml_node::operator<=(), pugi::xml_attribute::operator=(), pugi::xml_attribute::operator=(), pugi::xml_attribute::operator=(), pugi::xml_attribute::operator=(), pugi::xml_attribute::operator=(), pugi::xml_attribute::operator=(), pugi::xml_attribute::operator=(), pugi::xml_attribute::operator=(), pugi::xml_text::operator=(), pugi::xml_text::operator=(), pugi::xml_text::operator=(), pugi::xml_text::operator=(), pugi::xml_text::operator=(), pugi::xml_text::operator=(), pugi::xml_text::operator=(), pugi::xml_text::operator=(), pugi::xpath_node_set::operator=(), pugi::xpath_variable_set::operator=(), pugi::xml_attribute::operator==(), pugi::xml_attribute_iterator::operator==(), pugi::xml_named_node_iterator::operator==(), pugi::xml_node::operator==(), pugi::xml_node_iterator::operator==(), pugi::xpath_node::operator==(), pugi::xml_attribute::operator>(), pugi::xml_node::operator>(), pugi::xml_attribute::operator>=(), pugi::xml_node::operator>=(), pugi::xpath_node_set::operator[](), pugi::xml_node::parent(), pugi::xpath_node::parent(), parse_declaration_encoding(), partition3(), pugi::xml_node::path(), pugi::xml_node::prepend_attribute(), pugi::xml_node::prepend_child(), pugi::xml_node::prepend_child(), pugi::xml_node::prepend_copy(), pugi::xml_node::prepend_copy(), pugi::xml_node::prepend_move(), pugi::xml_attribute::previous_attribute(), pugi::xml_node::previous_sibling(), pugi::xml_node::previous_sibling(), pugi::xml_node::print(), pugi::xml_node::print(), pugi::xml_node::print(), qualified_name(), pugi::xml_node::remove_attribute(), pugi::xml_node::remove_attribute(), pugi::xml_node::remove_attributes(), pugi::xml_node::remove_child(), pugi::xml_node::remove_child(), pugi::xml_node::remove_children(), pugi::xml_document::reset(), pugi::xml_document::reset(), pugi::xpath_exception::result(), pugi::xpath_query::result(), pugi::xpath_query::return_type(), reverse(), pugi::xml_node::root(), round_nearest(), round_nearest_nzero(), pugi::xml_document::save(), pugi::xml_document::save(), pugi::xml_document::save(), pugi::xml_document::save_file(), pugi::xml_document::save_file(), save_file_impl(), pugi::xml_node::select_node(), pugi::xml_node::select_node(), pugi::xml_node::select_nodes(), pugi::xml_node::select_nodes(), pugi::xml_node::select_single_node(), pugi::xml_node::select_single_node(), pugi::xml_text::set(), pugi::xml_text::set(), pugi::xml_text::set(), pugi::xml_text::set(), pugi::xml_text::set(), pugi::xml_text::set(), pugi::xml_text::set(), pugi::xml_text::set(), pugi::xml_text::set(), pugi::xml_text::set(), pugi::xml_text::set(), pugi::xpath_variable::set(), pugi::xpath_variable::set(), pugi::xpath_variable::set(), pugi::xpath_variable::set(), pugi::xpath_variable_set::set(), pugi::xpath_variable_set::set(), pugi::xpath_variable_set::set(), pugi::xpath_variable_set::set(), pugi::set_memory_management_functions(), pugi::xml_attribute::set_name(), pugi::xml_node::set_name(), pugi::xml_attribute::set_value(), pugi::xml_attribute::set_value(), pugi::xml_attribute::set_value(), pugi::xml_attribute::set_value(), pugi::xml_attribute::set_value(), pugi::xml_attribute::set_value(), pugi::xml_attribute::set_value(), pugi::xml_attribute::set_value(), pugi::xml_attribute::set_value(), pugi::xml_attribute::set_value(), pugi::xml_attribute::set_value(), pugi::xml_node::set_value(), pugi::xml_node::set_value(), set_value_ascii(), set_value_bool(), set_value_convert(), set_value_convert(), set_value_integer(), pugi::xpath_node_set::size(), pugi::xpath_node_set::sort(), sort(), starts_with(), strconv_cdata(), strconv_comment(), strconv_escape(), strcpy_insitu(), strequal(), strequalrange(), string_to_integer(), string_value(), strlength(), strlength_wide(), pugi::xml_node::text(), text_output(), text_output_cdata(), text_output_escaped(), text_output_indent(), tolower_ascii(), translate(), translate_table(), translate_table_generate(), pugi::xml_node::traverse(), truncate_zeros(), pugi::xml_node::type(), pugi::xpath_node_set::type(), pugi::xpath_variable::type(), unique(), pugi::xml_attribute::value(), pugi::xml_node::value(), pugi::xpath_exception::what(), pugi::xml_writer_file::write(), pugi::xml_writer_stream::write(), pugi::xml_attribute::xml_attribute(), pugi::xml_attribute::xml_attribute(), pugi::xml_attribute_iterator::xml_attribute_iterator(), pugi::xml_attribute_iterator::xml_attribute_iterator(), pugi::xml_document::xml_document(), pugi::xml_named_node_iterator::xml_named_node_iterator(), pugi::xml_named_node_iterator::xml_named_node_iterator(), pugi::xml_node::xml_node(), pugi::xml_node::xml_node(), pugi::xml_node_iterator::xml_node_iterator(), pugi::xml_node_iterator::xml_node_iterator(), pugi::xml_parse_result::xml_parse_result(), pugi::xml_text::xml_text(), pugi::xml_tree_walker::xml_tree_walker(), pugi::xml_writer_file::xml_writer_file(), pugi::xml_writer_stream::xml_writer_stream(), pugi::xml_writer_stream::xml_writer_stream(), pugi::xpath_exception::xpath_exception(), xpath_first(), xpath_get_order(), pugi::xpath_node::xpath_node(), pugi::xpath_node::xpath_node(), pugi::xpath_node::xpath_node(), pugi::xpath_node_set::xpath_node_set(), pugi::xpath_node_set::xpath_node_set(), pugi::xpath_node_set::xpath_node_set(), pugi::xpath_parse_result::xpath_parse_result(), pugi::xpath_query::xpath_query(), pugi::xpath_query::xpath_query(), xpath_sort(), pugi::xpath_variable::xpath_variable(), pugi::xpath_variable_set::xpath_variable_set(), pugi::xpath_variable_set::xpath_variable_set(), zero_terminate_buffer(), pugi::xml_document::~xml_document(), pugi::xml_tree_walker::~xml_tree_walker(), pugi::xpath_node_set::~xpath_node_set(), pugi::xpath_query::~xpath_query(), and pugi::xpath_variable_set::~xpath_variable_set().

PUGI__FN_NO_INLINE

#define PUGI__FN_NO_INLINE   PUGI__NO_INLINE

Definition at line 165 of file pugixml.cc.

Referenced by xml_allocator::allocate_memory_oob(), append_new_attribute(), append_new_node(), and xpath_node_set_raw::push_back_grow().

PUGI__GETHEADER_IMPL

#define PUGI__GETHEADER_IMPL	(		object,
			page,
			flags )

Value:

(((reinterpret_cast<char*>(object) - reinterpret_cast<char*>(page)) << 8) | (flags))

Definition at line 450 of file pugixml.cc.

Referenced by pugi::xml_attribute_struct::xml_attribute_struct(), and pugi::xml_node_struct::xml_node_struct().

PUGI__GETPAGE

#define PUGI__GETPAGE

(

n

)

Value:

PUGI__GETPAGE_IMPL((n)->header)

Definition at line 455 of file pugixml.cc.

Referenced by destroy_attribute(), destroy_node(), get_allocator(), and get_document().

PUGI__GETPAGE_IMPL

#define PUGI__GETPAGE_IMPL

(

header

)

Value:

static_cast<impl::xml_memory_page*>(const_cast<void*>(static_cast<const void*>(reinterpret_cast<const char*>(&header) - (header >> 8))))

Definition at line 452 of file pugixml.cc.

Referenced by strcpy_insitu().

PUGI__IS_CHARTYPE

#define PUGI__IS_CHARTYPE	(		c,
			ct )

Value:

PUGI__IS_CHARTYPE_IMPL(c, ct, chartype_table)

Definition at line 1915 of file pugixml.cc.

Referenced by check_string_to_number_format(), xpath_lexer::next(), normalize_space(), strconv_pcdata_impl< opt_trim, opt_eol, opt_escape >::parse(), parse_declaration_encoding(), strconv_attribute_impl< opt_escape >::parse_eol(), xml_parser::parse_exclamation(), xpath_parser::parse_path_or_unary_expression(), xml_parser::parse_question(), strconv_attribute_impl< opt_escape >::parse_simple(), xml_parser::parse_tree(), strconv_attribute_impl< opt_escape >::parse_wconv(), strconv_attribute_impl< opt_escape >::parse_wnorm(), strconv_cdata(), strconv_comment(), and string_to_integer().

PUGI__IS_CHARTYPE_IMPL

#define PUGI__IS_CHARTYPE_IMPL	(		c,
			ct,
			table )

Value:

(table[static_cast<unsigned char>(c)] & (ct))

Definition at line 1912 of file pugixml.cc.

PUGI__IS_CHARTYPEX

#define PUGI__IS_CHARTYPEX	(		c,
			ct )

Value:

PUGI__IS_CHARTYPE_IMPL(c, ct, chartypex_table)

Definition at line 1916 of file pugixml.cc.

Referenced by check_string_to_number_format(), xpath_lexer::next(), and text_output_escaped().

PUGI__NO_INLINE

#define PUGI__NO_INLINE

Definition at line 89 of file pugixml.cc.

PUGI__NODETYPE

#define PUGI__NODETYPE

(

n

)

Value:

static_cast<xml_node_type>((n)->header & impl::xml_memory_page_type_mask)

Definition at line 456 of file pugixml.cc.

Referenced by pugi::xml_node::child_value(), pugi::xml_document::document_element(), has_declaration(), xml_parser::has_element_node_siblings(), is_text_node(), node_copy_tree(), node_output(), node_output_simple(), xml_parser::parse_tree(), pugi::xml_node::set_name(), pugi::xml_node::set_value(), pugi::xml_node::set_value(), and pugi::xml_node::type().

PUGI__NS_BEGIN

#define PUGI__NS_BEGIN   namespace pugi { namespace impl { namespace {

Definition at line 161 of file pugixml.cc.

PUGI__NS_END

#define PUGI__NS_END   } } }

Definition at line 162 of file pugixml.cc.

PUGI__OPTSET

#define PUGI__OPTSET

(

OPT

)

Value:

( optmsk & (OPT) )

Definition at line 2606 of file pugixml.cc.

Referenced by xml_parser::parse(), xml_parser::parse_exclamation(), xml_parser::parse_question(), and xml_parser::parse_tree().

PUGI__POPNODE

#define PUGI__POPNODE

(

)

Value:

{ cursor = cursor->parent; }

Definition at line 2608 of file pugixml.cc.

Referenced by xml_parser::parse_question(), and xml_parser::parse_tree().

PUGI__PUSHNODE

#define PUGI__PUSHNODE

(

TYPE

)

Value:

{ cursor = append_new_node(cursor, *alloc, TYPE); if (!cursor) PUGI__THROW_ERROR(status_out_of_memory, s); }

Definition at line 2607 of file pugixml.cc.

Referenced by xml_parser::parse_exclamation(), xml_parser::parse_question(), and xml_parser::parse_tree().

PUGI__SCANCHAR

#define PUGI__SCANCHAR

(

ch

)

Value:

{ if (offset >= size || data[offset] != ch) return false; offset++; }

Referenced by parse_declaration_encoding().

PUGI__SCANCHARTYPE

#define PUGI__SCANCHARTYPE

(

ct

)

Value:

{ while (offset < size && PUGI__IS_CHARTYPE(data[offset], ct)) offset++; }

Referenced by parse_declaration_encoding().

PUGI__SCANFOR

#define PUGI__SCANFOR

(

X

)

Value:

{ while (*s != 0 && !(X)) ++s; }

Definition at line 2609 of file pugixml.cc.

Referenced by xml_parser::parse_doctype_primitive(), xml_parser::parse_exclamation(), xml_parser::parse_question(), and xml_parser::parse_tree().

PUGI__SCANWHILE

#define PUGI__SCANWHILE

(

X

)

Value:

{ while (X) ++s; }

Definition at line 2610 of file pugixml.cc.

Referenced by xml_parser::parse_question().

PUGI__SCANWHILE_UNROLL

#define PUGI__SCANWHILE_UNROLL

(

X

)

Value:

{ for (;;) { char_t ss = s[0]; if (PUGI__UNLIKELY(!(X))) { break; } ss = s[1]; if (PUGI__UNLIKELY(!(X))) { s += 1; break; } ss = s[2]; if (PUGI__UNLIKELY(!(X))) { s += 2; break; } ss = s[3]; if (PUGI__UNLIKELY(!(X))) { s += 3; break; } s += 4; } }

Definition at line 2611 of file pugixml.cc.

Referenced by strconv_pcdata_impl< opt_trim, opt_eol, opt_escape >::parse(), strconv_attribute_impl< opt_escape >::parse_eol(), strconv_attribute_impl< opt_escape >::parse_simple(), xml_parser::parse_tree(), strconv_attribute_impl< opt_escape >::parse_wconv(), strconv_attribute_impl< opt_escape >::parse_wnorm(), strconv_cdata(), strconv_comment(), and text_output_escaped().

PUGI__SKIPWS

#define PUGI__SKIPWS

(

)

Value:

{ while (PUGI__IS_CHARTYPE(*s, ct_space)) ++s; }

Definition at line 2605 of file pugixml.cc.

Referenced by xml_parser::parse_question(), and xml_parser::parse_tree().

PUGI__SNPRINTF

#define PUGI__SNPRINTF   sprintf

Definition at line 147 of file pugixml.cc.

Referenced by convert_number_to_mantissa_exponent(), set_value_convert(), and set_value_convert().

PUGI__STATIC_ASSERT

#define PUGI__STATIC_ASSERT

(

cond

)

Value:

{ static const char condition_failed[(cond) ? 1 : -1] = {0}; (void)condition_failed[0]; }

Definition at line 100 of file pugixml.cc.

Referenced by xml_allocator::allocate_string(), convert_buffer_output_generic(), convert_buffer_output_generic(), gen_nan(), get_strconv_attribute(), get_strconv_pcdata(), get_wchar_encoding(), string_to_integer(), and xml_buffered_writer::xml_buffered_writer().

PUGI__THROW_ERROR

#define PUGI__THROW_ERROR	(		err,
			m )

Value:

return error_offset = m, error_status = err, static_cast<char_t*>(0)

Definition at line 2613 of file pugixml.cc.

Referenced by xml_parser::parse_doctype_group(), xml_parser::parse_doctype_ignore(), xml_parser::parse_doctype_primitive(), xml_parser::parse_exclamation(), xml_parser::parse_question(), and xml_parser::parse_tree().

PUGI__UNLIKELY

#define PUGI__UNLIKELY

(

cond

)

Value:

(cond)

Definition at line 96 of file pugixml.cc.

Referenced by xml_allocator::allocate_memory().

PUGI__UNSIGNED_OVERFLOW

#define PUGI__UNSIGNED_OVERFLOW

Definition at line 117 of file pugixml.cc.

Referenced by hash_string(), integer_to_string(), and string_to_integer().

SOURCE_PUGIXML_CPP

#define SOURCE_PUGIXML_CPP

pugixml parser - version 1.13

Copyright (C) 2006-2022, by Arseny Kapoulkine (arsen.nosp@m.y.ka.nosp@m.poulk.nosp@m.ine@.nosp@m.gmail.nosp@m..com) Report bugs and download new versions at https://pugixml.org/

This library is distributed under the MIT License. See notice at the end of this file.

This work is based on the pugxml parser, which is: Copyright (C) 2003, by Kristen Wegner (krist.nosp@m.en@t.nosp@m.ima.n.nosp@m.et)

Definition at line 15 of file pugixml.cc.

Typedef Documentation

strconv_attribute_t

typedef char_t *(* strconv_attribute_t) (char_t *, char_t)

Definition at line 2743 of file pugixml.cc.

strconv_pcdata_t

typedef char_t *(* strconv_pcdata_t) (char_t *)

Definition at line 2672 of file pugixml.cc.

wchar_counter

typedef wchar_selector<sizeof(wchar_t)>::counter wchar_counter

Definition at line 1820 of file pugixml.cc.

wchar_writer

typedef wchar_selector<sizeof(wchar_t)>::writer wchar_writer

Definition at line 1821 of file pugixml.cc.

xml_memory

typedef xml_memory_management_function_storage<int> xml_memory

Definition at line 208 of file pugixml.cc.

Enumeration Type Documentation

ast_type_t

enum ast_type_t

Enumerator
ast_unknown
ast_op_or
ast_op_and
ast_op_equal
ast_op_not_equal
ast_op_less
ast_op_greater
ast_op_less_or_equal
ast_op_greater_or_equal
ast_op_add
ast_op_subtract
ast_op_multiply
ast_op_divide
ast_op_mod
ast_op_negate
ast_op_union
ast_predicate
ast_filter
ast_string_constant
ast_number_constant
ast_variable
ast_func_last
ast_func_position
ast_func_count
ast_func_id
ast_func_local_name_0
ast_func_local_name_1
ast_func_namespace_uri_0
ast_func_namespace_uri_1
ast_func_name_0
ast_func_name_1
ast_func_string_0
ast_func_string_1
ast_func_concat
ast_func_starts_with
ast_func_contains
ast_func_substring_before
ast_func_substring_after
ast_func_substring_2
ast_func_substring_3
ast_func_string_length_0
ast_func_string_length_1
ast_func_normalize_space_0
ast_func_normalize_space_1
ast_func_translate
ast_func_boolean
ast_func_not
ast_func_true
ast_func_false
ast_func_lang
ast_func_number_0
ast_func_number_1
ast_func_sum
ast_func_floor
ast_func_ceiling
ast_func_round
ast_step
ast_step_root
ast_opt_translate_table
ast_opt_compare_attribute

Definition at line 9553 of file pugixml.cc.

    {
        ast_unknown,
        ast_op_or,                      // left or right
        ast_op_and,                     // left and right
        ast_op_equal,                   // left = right
        ast_op_not_equal,               // left != right
        ast_op_less,                    // left < right
        ast_op_greater,                 // left > right
        ast_op_less_or_equal,           // left <= right
        ast_op_greater_or_equal,        // left >= right
        ast_op_add,                     // left + right
        ast_op_subtract,                // left - right
        ast_op_multiply,                // left * right
        ast_op_divide,                  // left / right
        ast_op_mod,                     // left % right
        ast_op_negate,                  // left - right
        ast_op_union,                   // left | right
        ast_predicate,                  // apply predicate to set; next points to next predicate
        ast_filter,                     // select * from left where right
        ast_string_constant,            // string constant
        ast_number_constant,            // number constant
        ast_variable,                   // variable
        ast_func_last,                  // last()
        ast_func_position,              // position()
        ast_func_count,                 // count(left)
        ast_func_id,                    // id(left)
        ast_func_local_name_0,          // local-name()
        ast_func_local_name_1,          // local-name(left)
        ast_func_namespace_uri_0,       // namespace-uri()
        ast_func_namespace_uri_1,       // namespace-uri(left)
        ast_func_name_0,                // name()
        ast_func_name_1,                // name(left)
        ast_func_string_0,              // string()
        ast_func_string_1,              // string(left)
        ast_func_concat,                // concat(left, right, siblings)
        ast_func_starts_with,           // starts_with(left, right)
        ast_func_contains,              // contains(left, right)
        ast_func_substring_before,      // substring-before(left, right)
        ast_func_substring_after,       // substring-after(left, right)
        ast_func_substring_2,           // substring(left, right)
        ast_func_substring_3,           // substring(left, right, third)
        ast_func_string_length_0,       // string-length()
        ast_func_string_length_1,       // string-length(left)
        ast_func_normalize_space_0,     // normalize-space()
        ast_func_normalize_space_1,     // normalize-space(left)
        ast_func_translate,             // translate(left, right, third)
        ast_func_boolean,               // boolean(left)
        ast_func_not,                   // not(left)
        ast_func_true,                  // true()
        ast_func_false,                 // false()
        ast_func_lang,                  // lang(left)
        ast_func_number_0,              // number()
        ast_func_number_1,              // number(left)
        ast_func_sum,                   // sum(left)
        ast_func_floor,                 // floor(left)
        ast_func_ceiling,               // ceiling(left)
        ast_func_round,                 // round(left)
        ast_step,                       // process set left with step
        ast_step_root,                  // select root node
 
        ast_opt_translate_table,        // translate(left, right, third) where right/third are constants
        ast_opt_compare_attribute       // @name = 'string'
    };

axis_t

enum axis_t

Enumerator
axis_ancestor
axis_ancestor_or_self
axis_attribute
axis_child
axis_descendant
axis_descendant_or_self
axis_following
axis_following_sibling
axis_namespace
axis_parent
axis_preceding
axis_preceding_sibling
axis_self

Definition at line 9618 of file pugixml.cc.

    {
        axis_ancestor,
        axis_ancestor_or_self,
        axis_attribute,
        axis_child,
        axis_descendant,
        axis_descendant_or_self,
        axis_following,
        axis_following_sibling,
        axis_namespace,
        axis_parent,
        axis_preceding,
        axis_preceding_sibling,
        axis_self
    };

chartype_t

enum chartype_t

Enumerator
ct_parse_pcdata
ct_parse_attr
ct_parse_attr_ws
ct_space
ct_parse_cdata
ct_parse_comment
ct_symbol
ct_start_symbol

Definition at line 1845 of file pugixml.cc.

    {
        ct_parse_pcdata = 1,    // \0, &, \r, <
        ct_parse_attr = 2,      // \0, &, \r, ', "
        ct_parse_attr_ws = 4,   // \0, &, \r, ', ", \n, tab
        ct_space = 8,           // \r, \n, space, tab
        ct_parse_cdata = 16,    // \0, ], >, \r
        ct_parse_comment = 32,  // \0, -, >, \r
        ct_symbol = 64,         // Any symbol > 127, a-z, A-Z, 0-9, _, :, -, .
        ct_start_symbol = 128   // Any symbol > 127, a-z, A-Z, _, :
    };

chartypex_t

enum chartypex_t

Enumerator
ctx_special_pcdata
ctx_special_attr
ctx_start_symbol
ctx_digit
ctx_symbol

Definition at line 1878 of file pugixml.cc.

    {
        ctx_special_pcdata = 1,   // Any symbol >= 0 and < 32 (except \t, \r, \n), &, <, >
        ctx_special_attr = 2,     // Any symbol >= 0 and < 32, &, <, ", '
        ctx_start_symbol = 4,     // Any symbol > 127, a-z, A-Z, _
        ctx_digit = 8,            // 0-9
        ctx_symbol = 16           // Any symbol > 127, a-z, A-Z, 0-9, _, -, .
    };

indent_flags_t

enum indent_flags_t

Enumerator
indent_newline
indent_indent

Definition at line 4247 of file pugixml.cc.

    {
        indent_newline = 1,
        indent_indent = 2
    };

lexeme_t

enum lexeme_t

Enumerator
lex_none
lex_equal
lex_not_equal
lex_less
lex_greater
lex_less_or_equal
lex_greater_or_equal
lex_plus
lex_minus
lex_multiply
lex_union
lex_var_ref
lex_open_brace
lex_close_brace
lex_quoted_string
lex_number
lex_slash
lex_double_slash
lex_open_square_brace
lex_close_square_brace
lex_string
lex_comma
lex_axis_attribute
lex_dot
lex_double_dot
lex_double_colon
lex_eof

Definition at line 9199 of file pugixml.cc.

    {
        lex_none = 0,
        lex_equal,
        lex_not_equal,
        lex_less,
        lex_greater,
        lex_less_or_equal,
        lex_greater_or_equal,
        lex_plus,
        lex_minus,
        lex_multiply,
        lex_union,
        lex_var_ref,
        lex_open_brace,
        lex_close_brace,
        lex_quoted_string,
        lex_number,
        lex_slash,
        lex_double_slash,
        lex_open_square_brace,
        lex_close_square_brace,
        lex_string,
        lex_comma,
        lex_axis_attribute,
        lex_dot,
        lex_double_dot,
        lex_double_colon,
        lex_eof
    };

nodeset_eval_t

enum nodeset_eval_t

Enumerator
nodeset_eval_all
nodeset_eval_any
nodeset_eval_first

Definition at line 9656 of file pugixml.cc.

    {
        nodeset_eval_all,
        nodeset_eval_any,
        nodeset_eval_first
    };

nodetest_t

enum nodetest_t

Enumerator
nodetest_none
nodetest_name
nodetest_type_node
nodetest_type_comment
nodetest_type_pi
nodetest_type_text
nodetest_pi
nodetest_all
nodetest_all_in_namespace

Definition at line 9635 of file pugixml.cc.

    {
        nodetest_none,
        nodetest_name,
        nodetest_type_node,
        nodetest_type_comment,
        nodetest_type_pi,
        nodetest_type_text,
        nodetest_pi,
        nodetest_all,
        nodetest_all_in_namespace
    };

predicate_t

enum predicate_t

Enumerator
predicate_default
predicate_posinv
predicate_constant
predicate_constant_one

Definition at line 9648 of file pugixml.cc.

    {
        predicate_default,
        predicate_posinv,
        predicate_constant,
        predicate_constant_one
    };

Function Documentation

allocate_attribute()

PUGI__NS_END PUGI__NS_BEGIN xml_attribute_struct * allocate_attribute ( xml_allocator & alloc )

inline

Definition at line 1176 of file pugixml.cc.

    {
        xml_memory_page* page;
        void* memory = alloc.allocate_object(sizeof(xml_attribute_struct), page);
        if (!memory) return 0;
 
        return new (memory) xml_attribute_struct(page);
    }

Referenced by append_new_attribute().

allocate_node()

xml_node_struct * allocate_node ( xml_allocator & alloc, xml_node_type type )

inline

Definition at line 1185 of file pugixml.cc.

    {
        xml_memory_page* page;
        void* memory = alloc.allocate_object(sizeof(xml_node_struct), page);
        if (!memory) return 0;
 
        return new (memory) xml_node_struct(page, type);
    }

Referenced by append_new_node().

allow_insert_attribute()

PUGI__FN bool allow_insert_attribute

(

xml_node_type

parent

)

Definition at line 4368 of file pugixml.cc.

    {
        return parent == node_element || parent == node_declaration;
    }

allow_insert_child()

PUGI__FN bool allow_insert_child	(	xml_node_type	parent,
		xml_node_type	child )

Definition at line 4373 of file pugixml.cc.

    {
        if (parent != node_document && parent != node_element) return false;
        if (child == node_document || child == node_null) return false;
        if (parent != node_document && (child == node_declaration || child == node_doctype)) return false;
 
        return true;
    }

Referenced by allow_move().

allow_move()

PUGI__FN bool allow_move	(	xml_node	parent,
		xml_node	child )

Definition at line 4382 of file pugixml.cc.

    {
        // check that child can be a child of parent
        if (!allow_insert_child(parent.type(), child.type()))
            return false;
 
        // check that node is not moved between documents
        if (parent.root() != child.root())
            return false;
 
        // check that new parent is not in the child subtree
        xml_node cur = parent;
 
        while (cur)
        {
            if (cur == child)
                return false;
 
            cur = cur.parent();
        }
 
        return true;
    }

append_attribute()

void append_attribute ( xml_attribute_struct * attr, xml_node_struct * node )

inline

Definition at line 1333 of file pugixml.cc.

    {
        xml_attribute_struct* head = node->first_attribute;
 
        if (head)
        {
            xml_attribute_struct* tail = head->prev_attribute_c;
 
            tail->next_attribute = attr;
            attr->prev_attribute_c = tail;
            head->prev_attribute_c = attr;
        }
        else
        {
            node->first_attribute = attr;
            attr->prev_attribute_c = attr;
        }
    }

Referenced by append_new_attribute().

append_new_attribute()

PUGI__FN_NO_INLINE xml_attribute_struct * append_new_attribute	(	xml_node_struct *	node,
		xml_allocator &	alloc )

Definition at line 1427 of file pugixml.cc.

    {
        if (!alloc.reserve()) return 0;
 
        xml_attribute_struct* attr = allocate_attribute(alloc);
        if (!attr) return 0;
 
        append_attribute(attr, node);
 
        return attr;
    }

Referenced by node_copy_contents(), and xml_parser::parse_tree().

append_new_node()

PUGI__FN_NO_INLINE xml_node_struct * append_new_node	(	xml_node_struct *	node,
		xml_allocator &	alloc,
		xml_node_type	type = node_element )

Definition at line 1415 of file pugixml.cc.

    {
        if (!alloc.reserve()) return 0;
 
        xml_node_struct* child = allocate_node(alloc, type);
        if (!child) return 0;
 
        append_node(child, node);
 
        return child;
    }

Referenced by node_copy_tree().

append_node()

void append_node ( xml_node_struct * child, xml_node_struct * node )

inline

Definition at line 1234 of file pugixml.cc.

    {
        child->parent = node;
 
        xml_node_struct* head = node->first_child;
 
        if (head)
        {
            xml_node_struct* tail = head->prev_sibling_c;
 
            tail->next_sibling = child;
            child->prev_sibling_c = tail;
            head->prev_sibling_c = child;
        }
        else
        {
            node->first_child = child;
            child->prev_sibling_c = child;
        }
    }

Referenced by append_new_node().

as_utf8_begin()

PUGI__FN size_t as_utf8_begin	(	const wchar_t *	str,
		size_t	length )

Definition at line 2297 of file pugixml.cc.

    {
        // get length in utf8 characters
        return wchar_decoder::process(str, length, 0, utf8_counter());
    }

Referenced by as_utf8_impl(), and convert_path_heap().

as_utf8_end()

PUGI__FN void as_utf8_end	(	char *	buffer,
		size_t	size,
		const wchar_t *	str,
		size_t	length )

Definition at line 2303 of file pugixml.cc.

    {
        // convert to utf8
        uint8_t* begin = reinterpret_cast<uint8_t*>(buffer);
        uint8_t* end = wchar_decoder::process(str, length, begin, utf8_writer());
 
        assert(begin + size == end);
        (void)!end;
        (void)!size;
    }

Referenced by as_utf8_impl(), and convert_path_heap().

as_utf8_impl()

PUGI__FN std::string as_utf8_impl	(	const wchar_t *	str,
		size_t	length )

Definition at line 2315 of file pugixml.cc.

    {
        // first pass: get length in utf8 characters
        size_t size = as_utf8_begin(str, length);
 
        // allocate resulting string
        std::string result;
        result.resize(size);
 
        // second pass: convert to utf8
        if (size > 0) as_utf8_end(&result[0], size, str, length);
 
        return result;
    }

as_wide_impl()

PUGI__FN std::basic_string< wchar_t > as_wide_impl	(	const char *	str,
		size_t	size )

Definition at line 2330 of file pugixml.cc.

    {
        const uint8_t* data = reinterpret_cast<const uint8_t*>(str);
 
        // first pass: get length in wchar_t units
        size_t length = utf8_decoder::process(data, size, 0, wchar_counter());
 
        // allocate resulting string
        std::basic_string<wchar_t> result;
        result.resize(length);
 
        // second pass: convert to wchar_t
        if (length > 0)
        {
            wchar_writer::value_type begin = reinterpret_cast<wchar_writer::value_type>(&result[0]);
            wchar_writer::value_type end = utf8_decoder::process(data, size, begin, wchar_writer());
 
            assert(begin + length == end);
            (void)!end;
        }
 
        return result;
    }

check_string_to_number_format()

PUGI__FN bool check_string_to_number_format

(

const char_t *

string

)

Definition at line 8515 of file pugixml.cc.

    {
        // parse leading whitespace
        while (PUGI__IS_CHARTYPE(*string, ct_space)) ++string;
 
        // parse sign
        if (*string == '-') ++string;
 
        if (!*string) return false;
 
        // if there is no integer part, there should be a decimal part with at least one digit
        if (!PUGI__IS_CHARTYPEX(string[0], ctx_digit) && (string[0] != '.' || !PUGI__IS_CHARTYPEX(string[1], ctx_digit))) return false;
 
        // parse integer part
        while (PUGI__IS_CHARTYPEX(*string, ctx_digit)) ++string;
 
        // parse decimal part
        if (*string == '.')
        {
            ++string;
 
            while (PUGI__IS_CHARTYPEX(*string, ctx_digit)) ++string;
        }
 
        // parse trailing whitespace
        while (PUGI__IS_CHARTYPE(*string, ct_space)) ++string;
 
        return *string == 0;
    }

Referenced by convert_string_to_number().

close_file()

PUGI__FN void close_file

(

FILE *

file

)

Definition at line 4849 of file pugixml.cc.

    {
        fclose(file);
    }

convert_buffer()

PUGI__FN bool convert_buffer	(	char_t *&	out_buffer,
		size_t &	out_length,
		xml_encoding	encoding,
		const void *	contents,
		size_t	size,
		bool	is_mutable )

Definition at line 2262 of file pugixml.cc.

    {
        // fast path: no conversion required
        if (encoding == encoding_utf8)
            return get_mutable_buffer(out_buffer, out_length, contents, size, is_mutable);
 
        // source encoding is utf16
        if (encoding == encoding_utf16_be || encoding == encoding_utf16_le)
        {
            xml_encoding native_encoding = is_little_endian() ? encoding_utf16_le : encoding_utf16_be;
 
            return (native_encoding == encoding) ?
                convert_buffer_generic(out_buffer, out_length, contents, size, utf16_decoder<opt_false>()) :
                convert_buffer_generic(out_buffer, out_length, contents, size, utf16_decoder<opt_true>());
        }
 
        // source encoding is utf32
        if (encoding == encoding_utf32_be || encoding == encoding_utf32_le)
        {
            xml_encoding native_encoding = is_little_endian() ? encoding_utf32_le : encoding_utf32_be;
 
            return (native_encoding == encoding) ?
                convert_buffer_generic(out_buffer, out_length, contents, size, utf32_decoder<opt_false>()) :
                convert_buffer_generic(out_buffer, out_length, contents, size, utf32_decoder<opt_true>());
        }
 
        // source encoding is latin1
        if (encoding == encoding_latin1)
            return convert_buffer_latin1(out_buffer, out_length, contents, size, is_mutable);
 
        assert(false && "Invalid encoding"); // unreachable
        return false;
    }

convert_buffer_generic()

template<typename D>

PUGI__FN bool convert_buffer_generic	(	char_t *&	out_buffer,
		size_t &	out_length,
		const void *	contents,
		size_t	size,
		D	)

Definition at line 2191 of file pugixml.cc.

    {
        const typename D::type* data = static_cast<const typename D::type*>(contents);
        size_t data_length = size / sizeof(typename D::type);
 
        // first pass: get length in utf8 units
        size_t length = D::process(data, data_length, 0, utf8_counter());
 
        // allocate buffer of suitable length
        char_t* buffer = static_cast<char_t*>(xml_memory::allocate((length + 1) * sizeof(char_t)));
        if (!buffer) return false;
 
        // second pass: convert utf16 input to utf8
        uint8_t* obegin = reinterpret_cast<uint8_t*>(buffer);
        uint8_t* oend = D::process(data, data_length, obegin, utf8_writer());
 
        assert(oend == obegin + length);
        *oend = 0;
 
        out_buffer = buffer;
        out_length = length + 1;
 
        return true;
    }

Referenced by convert_buffer().

convert_buffer_latin1()

PUGI__FN bool convert_buffer_latin1	(	char_t *&	out_buffer,
		size_t &	out_length,
		const void *	contents,
		size_t	size,
		bool	is_mutable )

Definition at line 2225 of file pugixml.cc.

    {
        const uint8_t* data = static_cast<const uint8_t*>(contents);
        size_t data_length = size;
 
        // get size of prefix that does not need utf8 conversion
        size_t prefix_length = get_latin1_7bit_prefix_length(data, data_length);
        assert(prefix_length <= data_length);
 
        const uint8_t* postfix = data + prefix_length;
        size_t postfix_length = data_length - prefix_length;
 
        // if no conversion is needed, just return the original buffer
        if (postfix_length == 0) return get_mutable_buffer(out_buffer, out_length, contents, size, is_mutable);
 
        // first pass: get length in utf8 units
        size_t length = prefix_length + latin1_decoder::process(postfix, postfix_length, 0, utf8_counter());
 
        // allocate buffer of suitable length
        char_t* buffer = static_cast<char_t*>(xml_memory::allocate((length + 1) * sizeof(char_t)));
        if (!buffer) return false;
 
        // second pass: convert latin1 input to utf8
        memcpy(buffer, data, prefix_length);
 
        uint8_t* obegin = reinterpret_cast<uint8_t*>(buffer);
        uint8_t* oend = latin1_decoder::process(postfix, postfix_length, obegin + prefix_length, utf8_writer());
 
        assert(oend == obegin + length);
        *oend = 0;
 
        out_buffer = buffer;
        out_length = length + 1;
 
        return true;
    }

Referenced by convert_buffer().

convert_buffer_output()

PUGI__FN size_t convert_buffer_output	(	char_t *	,
		uint8_t *	r_u8,
		uint16_t *	r_u16,
		uint32_t *	r_u32,
		const char_t *	data,
		size_t	length,
		xml_encoding	encoding )

Definition at line 3685 of file pugixml.cc.

    {
        if (encoding == encoding_utf16_be || encoding == encoding_utf16_le)
        {
            xml_encoding native_encoding = is_little_endian() ? encoding_utf16_le : encoding_utf16_be;
 
            return convert_buffer_output_generic(r_u16, data, length, utf8_decoder(), utf16_writer(), native_encoding != encoding);
        }
 
        if (encoding == encoding_utf32_be || encoding == encoding_utf32_le)
        {
            xml_encoding native_encoding = is_little_endian() ? encoding_utf32_le : encoding_utf32_be;
 
            return convert_buffer_output_generic(r_u32, data, length, utf8_decoder(), utf32_writer(), native_encoding != encoding);
        }
 
        if (encoding == encoding_latin1)
            return convert_buffer_output_generic(r_u8, data, length, utf8_decoder(), latin1_writer());
 
        assert(false && "Invalid encoding"); // unreachable
        return 0;
    }

Referenced by xml_buffered_writer::flush().

convert_buffer_output_generic() [1/2]

template<typename D, typename T>

PUGI__FN size_t convert_buffer_output_generic	(	typename T::value_type	dest,
		const char_t *	data,
		size_t	length,
		D	,
		T	)

Definition at line 3598 of file pugixml.cc.

    {
        PUGI__STATIC_ASSERT(sizeof(char_t) == sizeof(typename D::type));
 
        typename T::value_type end = D::process(reinterpret_cast<const typename D::type*>(data), length, dest, T());
 
        return static_cast<size_t>(end - dest) * sizeof(*dest);
    }

Referenced by convert_buffer_output().

convert_buffer_output_generic() [2/2]

template<typename D, typename T>

PUGI__FN size_t convert_buffer_output_generic	(	typename T::value_type	dest,
		const char_t *	data,
		size_t	length,
		D	,
		T	,
		bool	opt_swap )

Definition at line 3607 of file pugixml.cc.

    {
        PUGI__STATIC_ASSERT(sizeof(char_t) == sizeof(typename D::type));
 
        typename T::value_type end = D::process(reinterpret_cast<const typename D::type*>(data), length, dest, T());
 
        if (opt_swap)
        {
            for (typename T::value_type i = dest; i != end; ++i)
                *i = endian_swap(*i);
        }
 
        return static_cast<size_t>(end - dest) * sizeof(*dest);
    }

convert_number_to_boolean()

PUGI__FN bool convert_number_to_boolean

(

double

value

)

Definition at line 8391 of file pugixml.cc.

    {
        return (value != 0 && !is_nan(value));
    }

Referenced by xpath_ast_node::eval_boolean().

convert_number_to_mantissa_exponent()

PUGI__FN void convert_number_to_mantissa_exponent	(	double	value,
		char(&)	buffer[32],
		char **	out_mantissa,
		int *	out_exponent )

Definition at line 8419 of file pugixml.cc.

    {
        // get a scientific notation value with IEEE DBL_DIG decimals
        PUGI__SNPRINTF(buffer, "%.*e", DBL_DIG, value);
 
        // get the exponent (possibly negative)
        char* exponent_string = strchr(buffer, 'e');
        assert(exponent_string);
 
        int exponent = atoi(exponent_string + 1);
 
        // extract mantissa string: skip sign
        char* mantissa = buffer[0] == '-' ? buffer + 1 : buffer;
        assert(mantissa[0] != '0' && mantissa[1] == '.');
 
        // divide mantissa by 10 to eliminate integer part
        mantissa[1] = mantissa[0];
        mantissa++;
        exponent++;
 
        // remove extra mantissa digits and zero-terminate mantissa
        truncate_zeros(mantissa, exponent_string);
 
        // fill results
        *out_mantissa = mantissa;
        *out_exponent = exponent;
    }

Referenced by convert_number_to_string().

convert_number_to_string()

PUGI__FN xpath_string convert_number_to_string	(	double	value,
		xpath_allocator *	alloc )

Definition at line 8448 of file pugixml.cc.

    {
        // try special number conversion
        const char_t* special = convert_number_to_string_special(value);
        if (special) return xpath_string::from_const(special);
 
        // get mantissa + exponent form
        char mantissa_buffer[32];
 
        char* mantissa;
        int exponent;
        convert_number_to_mantissa_exponent(value, mantissa_buffer, &mantissa, &exponent);
 
        // allocate a buffer of suitable length for the number
        size_t result_size = strlen(mantissa_buffer) + (exponent > 0 ? exponent : -exponent) + 4;
        char_t* result = static_cast<char_t*>(alloc->allocate(sizeof(char_t) * result_size));
        if (!result) return xpath_string();
 
        // make the number!
        char_t* s = result;
 
        // sign
        if (value < 0) *s++ = '-';
 
        // integer part
        if (exponent <= 0)
        {
            *s++ = '0';
        }
        else
        {
            while (exponent > 0)
            {
                assert(*mantissa == 0 || static_cast<unsigned int>(*mantissa - '0') <= 9);
                *s++ = *mantissa ? *mantissa++ : '0';
                exponent--;
            }
        }
 
        // fractional part
        if (*mantissa)
        {
            // decimal point
            *s++ = '.';
 
            // extra zeroes from negative exponent
            while (exponent < 0)
            {
                *s++ = '0';
                exponent++;
            }
 
            // extra mantissa digits
            while (*mantissa)
            {
                assert(static_cast<unsigned int>(*mantissa - '0') <= 9);
                *s++ = *mantissa++;
            }
        }
 
        // zero-terminate
        assert(s < result + result_size);
        *s = 0;
 
        return xpath_string::from_heap_preallocated(result, s);
    }

Referenced by xpath_ast_node::eval_string().

convert_number_to_string_special()

PUGI__FN const char_t * convert_number_to_string_special

(

double

value

)

Definition at line 8359 of file pugixml.cc.

    {
    #if defined(PUGI__MSVC_CRT_VERSION) || defined(__BORLANDC__)
        if (_finite(value)) return (value == 0) ? PUGIXML_TEXT("0") : 0;
        if (_isnan(value)) return PUGIXML_TEXT("NaN");
        return value > 0 ? PUGIXML_TEXT("Infinity") : PUGIXML_TEXT("-Infinity");
    #elif defined(fpclassify) && defined(FP_NAN) && defined(FP_INFINITE) && defined(FP_ZERO)
        switch (fpclassify(value))
        {
        case FP_NAN:
            return PUGIXML_TEXT("NaN");
 
        case FP_INFINITE:
            return value > 0 ? PUGIXML_TEXT("Infinity") : PUGIXML_TEXT("-Infinity");
 
        case FP_ZERO:
            return PUGIXML_TEXT("0");
 
        default:
            return 0;
        }
    #else
        // fallback
        const volatile double v = value;
 
        if (v == 0) return PUGIXML_TEXT("0");
        if (v != v) return PUGIXML_TEXT("NaN");
        if (v * 2 == v) return value > 0 ? PUGIXML_TEXT("Infinity") : PUGIXML_TEXT("-Infinity");
        return 0;
    #endif
    }

Referenced by convert_number_to_string().

convert_path_heap()

PUGI__FN char * convert_path_heap

(

const wchar_t *

str

)

Definition at line 5015 of file pugixml.cc.

    {
        assert(str);
 
        // first pass: get length in utf8 characters
        size_t length = strlength_wide(str);
        size_t size = as_utf8_begin(str, length);
 
        // allocate resulting string
        char* result = static_cast<char*>(xml_memory::allocate(size + 1));
        if (!result) return 0;
 
        // second pass: convert to utf8
        as_utf8_end(result, size, str, length);
 
        // zero-terminate
        result[size] = 0;
 
        return result;
    }

Referenced by open_file_wide().

convert_string_to_number()

PUGI__FN double convert_string_to_number

(

const char_t *

string

)

Definition at line 8545 of file pugixml.cc.

    {
        // check string format
        if (!check_string_to_number_format(string)) return gen_nan();
 
        // parse string
    #ifdef PUGIXML_WCHAR_MODE
        return wcstod(string, 0);
    #else
        return strtod(string, 0);
    #endif
    }

Referenced by convert_string_to_number_scratch(), and xpath_ast_node::eval_number().

convert_string_to_number_scratch()

PUGI__FN bool convert_string_to_number_scratch	(	char_t(&)	buffer[32],
		const char_t *	begin,
		const char_t *	end,
		double *	out_result )

Definition at line 8558 of file pugixml.cc.

    {
        size_t length = static_cast<size_t>(end - begin);
        char_t* scratch = buffer;
 
        if (length >= sizeof(buffer) / sizeof(buffer[0]))
        {
            // need to make dummy on-heap copy
            scratch = static_cast<char_t*>(xml_memory::allocate((length + 1) * sizeof(char_t)));
            if (!scratch) return false;
        }
 
        // copy string to zero-terminated buffer and perform conversion
        memcpy(scratch, begin, length * sizeof(char_t));
        scratch[length] = 0;
 
        *out_result = convert_string_to_number(scratch);
 
        // free dummy buffer
        if (scratch != buffer) xml_memory::deallocate(scratch);
 
        return true;
    }

Referenced by xpath_parser::parse_primary_expression().

copy_xpath_variable()

PUGI__FN bool copy_xpath_variable	(	xpath_variable *	lhs,
		const xpath_variable *	rhs )

Definition at line 8925 of file pugixml.cc.

    {
        switch (rhs->type())
        {
        case xpath_type_node_set:
            return lhs->set(static_cast<const xpath_variable_node_set*>(rhs)->value);
 
        case xpath_type_number:
            return lhs->set(static_cast<const xpath_variable_number*>(rhs)->value);
 
        case xpath_type_string:
            return lhs->set(static_cast<const xpath_variable_string*>(rhs)->value);
 
        case xpath_type_boolean:
            return lhs->set(static_cast<const xpath_variable_boolean*>(rhs)->value);
 
        default:
            assert(false && "Invalid variable type"); // unreachable
            return false;
        }
    }

default_allocate()

PUGI__NS_BEGIN PUGI__FN void * default_allocate

(

size_t

size

)

Definition at line 186 of file pugixml.cc.

    {
        return malloc(size);
    }

default_deallocate()

PUGI__FN void default_deallocate

(

void *

ptr

)

Definition at line 191 of file pugixml.cc.

    {
        free(ptr);
    }

delete_xpath_variable() [1/2]

template<typename T>

PUGI__FN void delete_xpath_variable

(

T *

var

)

Definition at line 8894 of file pugixml.cc.

    {
        var->~T();
        xml_memory::deallocate(var);
    }

Referenced by delete_xpath_variable().

delete_xpath_variable() [2/2]

PUGI__FN void delete_xpath_variable	(	xpath_value_type	type,
		xpath_variable *	var )

Definition at line 8900 of file pugixml.cc.

    {
        switch (type)
        {
        case xpath_type_node_set:
            delete_xpath_variable(static_cast<xpath_variable_node_set*>(var));
            break;
 
        case xpath_type_number:
            delete_xpath_variable(static_cast<xpath_variable_number*>(var));
            break;
 
        case xpath_type_string:
            delete_xpath_variable(static_cast<xpath_variable_string*>(var));
            break;
 
        case xpath_type_boolean:
            delete_xpath_variable(static_cast<xpath_variable_boolean*>(var));
            break;
 
        default:
            assert(false && "Invalid variable type"); // unreachable
        }
    }

destroy_attribute()

void destroy_attribute ( xml_attribute_struct * a, xml_allocator & alloc )

inline

Definition at line 1194 of file pugixml.cc.

    {
        if (a->header & impl::xml_memory_page_name_allocated_mask)
            alloc.deallocate_string(a->name);
 
        if (a->header & impl::xml_memory_page_value_allocated_mask)
            alloc.deallocate_string(a->value);
 
        alloc.deallocate_memory(a, sizeof(xml_attribute_struct), PUGI__GETPAGE(a));
    }

Referenced by destroy_node().

destroy_node()

void destroy_node ( xml_node_struct * n, xml_allocator & alloc )

inline

Definition at line 1205 of file pugixml.cc.

    {
        if (n->header & impl::xml_memory_page_name_allocated_mask)
            alloc.deallocate_string(n->name);
 
        if (n->header & impl::xml_memory_page_value_allocated_mask)
            alloc.deallocate_string(n->value);
 
        for (xml_attribute_struct* attr = n->first_attribute; attr; )
        {
            xml_attribute_struct* next = attr->next_attribute;
 
            destroy_attribute(attr, alloc);
 
            attr = next;
        }
 
        for (xml_node_struct* child = n->first_child; child; )
        {
            xml_node_struct* next = child->next_sibling;
 
            destroy_node(child, alloc);
 
            child = next;
        }
 
        alloc.deallocate_memory(n, sizeof(xml_node_struct), PUGI__GETPAGE(n));
    }

Referenced by destroy_node().

document_buffer_order()

PUGI__FN const void * document_buffer_order

(

const xpath_node &

xnode

)

Definition at line 8246 of file pugixml.cc.

    {
        xml_node_struct* node = xnode.node().internal_object();
 
        if (node)
        {
            if ((get_document(node).header & xml_memory_page_contents_shared_mask) == 0)
            {
                if (node->name && (node->header & impl::xml_memory_page_name_allocated_or_shared_mask) == 0) return node->name;
                if (node->value && (node->header & impl::xml_memory_page_value_allocated_or_shared_mask) == 0) return node->value;
            }
 
            return 0;
        }
 
        xml_attribute_struct* attr = xnode.attribute().internal_object();
 
        if (attr)
        {
            if ((get_document(attr).header & xml_memory_page_contents_shared_mask) == 0)
            {
                if ((attr->header & impl::xml_memory_page_name_allocated_or_shared_mask) == 0) return attr->name;
                if ((attr->header & impl::xml_memory_page_value_allocated_or_shared_mask) == 0) return attr->value;
            }
 
            return 0;
        }
 
        return 0;
    }

Referenced by document_order_comparator::operator()().

endian_swap() [1/2]

PUGI__NS_END PUGI__NS_BEGIN uint16_t endian_swap ( uint16_t value )

inline

Definition at line 1455 of file pugixml.cc.

    {
        return static_cast<uint16_t>(((value & 0xff) << 8) | (value >> 8));
    }

Referenced by convert_buffer_output_generic(), utf16_decoder< opt_false >::process(), and utf32_decoder< opt_false >::process().

endian_swap() [2/2]

uint32_t endian_swap ( uint32_t value )

inline

Definition at line 1460 of file pugixml.cc.

    {
        return ((value & 0xff) << 24) | ((value & 0xff00) << 8) | ((value & 0xff0000) >> 8) | (value >> 24);
    }

evaluate_node_set_prepare()

PUGI__FN impl::xpath_ast_node * evaluate_node_set_prepare

(

xpath_query_impl *

impl

)

Definition at line 12283 of file pugixml.cc.

    {
        if (!impl) return 0;
 
        if (impl->root->rettype() != xpath_type_node_set)
        {
        #ifdef PUGIXML_NO_EXCEPTIONS
            return 0;
        #else
            xpath_parse_result res;
            res.error = "Expression does not evaluate to node set";
 
            throw xpath_exception(res);
        #endif
        }
 
        return impl->root;
    }

find_char()

PUGI__FN const char_t * find_char	(	const char_t *	s,
		char_t	c )

Definition at line 8093 of file pugixml.cc.

    {
    #ifdef PUGIXML_WCHAR_MODE
        return wcschr(s, c);
    #else
        return strchr(s, c);
    #endif
    }

Referenced by local_name(), namespace_uri_predicate::namespace_uri_predicate(), and translate().

find_substring()

PUGI__FN const char_t * find_substring	(	const char_t *	s,
		const char_t *	p )

Definition at line 8102 of file pugixml.cc.

    {
    #ifdef PUGIXML_WCHAR_MODE
        // MSVC6 wcsstr bug workaround (if s is empty it always returns 0)
        return (*p == 0) ? s : wcsstr(s, p);
    #else
        return strstr(s, p);
    #endif
    }

Referenced by xpath_ast_node::eval_boolean(), and xpath_ast_node::eval_string().

gen_nan()

PUGI__FN double gen_nan

(

)

Definition at line 8331 of file pugixml.cc.

    {
    #if defined(__STDC_IEC_559__) || ((FLT_RADIX - 0 == 2) && (FLT_MAX_EXP - 0 == 128) && (FLT_MANT_DIG - 0 == 24))
        PUGI__STATIC_ASSERT(sizeof(float) == sizeof(uint32_t));
        typedef uint32_t UI; // BCC5 workaround
        union { float f; UI i; } u;
        u.i = 0x7fc00000;
        return double(u.f);
    #else
        // fallback
        const volatile double zero = 0.0;
        return zero / zero;
    #endif
    }

Referenced by convert_string_to_number().

get_allocator()

template<typename Object>

xml_allocator & get_allocator ( const Object * object )

inline

Definition at line 1159 of file pugixml.cc.

    {
        assert(object);
 
        return *PUGI__GETPAGE(object)->allocator;
    }

Referenced by node_copy_attribute(), node_copy_contents(), and node_copy_tree().

get_buffer_encoding()

PUGI__FN xml_encoding get_buffer_encoding	(	xml_encoding	encoding,
		const void *	contents,
		size_t	size )

Definition at line 2037 of file pugixml.cc.

    {
        // replace wchar encoding with utf implementation
        if (encoding == encoding_wchar) return get_wchar_encoding();
 
        // replace utf16 encoding with utf16 with specific endianness
        if (encoding == encoding_utf16) return is_little_endian() ? encoding_utf16_le : encoding_utf16_be;
 
        // replace utf32 encoding with utf32 with specific endianness
        if (encoding == encoding_utf32) return is_little_endian() ? encoding_utf32_le : encoding_utf32_be;
 
        // only do autodetection if no explicit encoding is requested
        if (encoding != encoding_auto) return encoding;
 
        // try to guess encoding (based on XML specification, Appendix F.1)
        const uint8_t* data = static_cast<const uint8_t*>(contents);
 
        return guess_buffer_encoding(data, size);
    }

Referenced by load_file_impl(), and load_stream_impl().

get_document()

template<typename Object>

xml_document_struct & get_document ( const Object * object )

inline

Definition at line 1166 of file pugixml.cc.

    {
        assert(object);
 
        return *static_cast<xml_document_struct*>(PUGI__GETPAGE(object)->allocator);
    }

Referenced by document_buffer_order().

get_file_size()

PUGI__FN xml_parse_status get_file_size	(	FILE *	file,
		size_t &	out_result )

Definition at line 4756 of file pugixml.cc.

    {
    #if defined(PUGI__MSVC_CRT_VERSION) && PUGI__MSVC_CRT_VERSION >= 1400
        // there are 64-bit versions of fseek/ftell, let's use them
        typedef __int64 length_type;
 
        _fseeki64(file, 0, SEEK_END);
        length_type length = _ftelli64(file);
        _fseeki64(file, 0, SEEK_SET);
    #elif defined(__MINGW32__) && !defined(__NO_MINGW_LFS) && (!defined(__STRICT_ANSI__) || defined(__MINGW64_VERSION_MAJOR))
        // there are 64-bit versions of fseek/ftell, let's use them
        typedef off64_t length_type;
 
        fseeko64(file, 0, SEEK_END);
        length_type length = ftello64(file);
        fseeko64(file, 0, SEEK_SET);
    #else
        // if this is a 32-bit OS, long is enough; if this is a unix system, long is 64-bit, which is enough; otherwise we can't do anything anyway.
        typedef long length_type;
 
        fseek(file, 0, SEEK_END);
        length_type length = ftell(file);
        fseek(file, 0, SEEK_SET);
    #endif
 
        // check for I/O errors
        if (length < 0) return status_io_error;
 
        // check for overflow
        size_t result = static_cast<size_t>(length);
 
        if (static_cast<length_type>(result) != length) return status_out_of_memory;
 
        // finalize
        out_result = result;
 
        return status_ok;
    }

Referenced by load_file_impl().

get_latin1_7bit_prefix_length()

PUGI__FN size_t get_latin1_7bit_prefix_length	(	const uint8_t *	data,
		size_t	size )

Definition at line 2216 of file pugixml.cc.

    {
        for (size_t i = 0; i < size; ++i)
            if (data[i] > 127)
                return i;
 
        return size;
    }

Referenced by convert_buffer_latin1().

get_mutable_buffer()

PUGI__FN bool get_mutable_buffer	(	char_t *&	out_buffer,
		size_t &	out_length,
		const void *	contents,
		size_t	size,
		bool	is_mutable )

Definition at line 2057 of file pugixml.cc.

    {
        size_t length = size / sizeof(char_t);
 
        if (is_mutable)
        {
            out_buffer = static_cast<char_t*>(const_cast<void*>(contents));
            out_length = length;
        }
        else
        {
            char_t* buffer = static_cast<char_t*>(xml_memory::allocate((length + 1) * sizeof(char_t)));
            if (!buffer) return false;
 
            if (contents)
                memcpy(buffer, contents, length * sizeof(char_t));
            else
                assert(length == 0);
 
            buffer[length] = 0;
 
            out_buffer = buffer;
            out_length = length + 1;
        }
 
        return true;
    }

Referenced by convert_buffer(), and convert_buffer_latin1().

get_strconv_attribute()

PUGI__FN strconv_attribute_t get_strconv_attribute

(

unsigned int

optmask

)

Definition at line 2894 of file pugixml.cc.

    {
        PUGI__STATIC_ASSERT(parse_escapes == 0x10 && parse_eol == 0x20 && parse_wconv_attribute == 0x40 && parse_wnorm_attribute == 0x80);
 
        switch ((optmask >> 4) & 15) // get bitmask for flags (wnorm wconv eol escapes); this simultaneously checks 4 options from assertion above
        {
        case 0:  return strconv_attribute_impl<opt_false>::parse_simple;
        case 1:  return strconv_attribute_impl<opt_true>::parse_simple;
        case 2:  return strconv_attribute_impl<opt_false>::parse_eol;
        case 3:  return strconv_attribute_impl<opt_true>::parse_eol;
        case 4:  return strconv_attribute_impl<opt_false>::parse_wconv;
        case 5:  return strconv_attribute_impl<opt_true>::parse_wconv;
        case 6:  return strconv_attribute_impl<opt_false>::parse_wconv;
        case 7:  return strconv_attribute_impl<opt_true>::parse_wconv;
        case 8:  return strconv_attribute_impl<opt_false>::parse_wnorm;
        case 9:  return strconv_attribute_impl<opt_true>::parse_wnorm;
        case 10: return strconv_attribute_impl<opt_false>::parse_wnorm;
        case 11: return strconv_attribute_impl<opt_true>::parse_wnorm;
        case 12: return strconv_attribute_impl<opt_false>::parse_wnorm;
        case 13: return strconv_attribute_impl<opt_true>::parse_wnorm;
        case 14: return strconv_attribute_impl<opt_false>::parse_wnorm;
        case 15: return strconv_attribute_impl<opt_true>::parse_wnorm;
        default: assert(false); return 0; // unreachable
        }
    }

Referenced by xml_parser::parse_tree().

get_strconv_pcdata()

PUGI__FN strconv_pcdata_t get_strconv_pcdata

(

unsigned int

optmask

)

Definition at line 2725 of file pugixml.cc.

    {
        PUGI__STATIC_ASSERT(parse_escapes == 0x10 && parse_eol == 0x20 && parse_trim_pcdata == 0x0800);
 
        switch (((optmask >> 4) & 3) | ((optmask >> 9) & 4)) // get bitmask for flags (trim eol escapes); this simultaneously checks 3 options from assertion above
        {
        case 0: return strconv_pcdata_impl<opt_false, opt_false, opt_false>::parse;
        case 1: return strconv_pcdata_impl<opt_false, opt_false, opt_true>::parse;
        case 2: return strconv_pcdata_impl<opt_false, opt_true, opt_false>::parse;
        case 3: return strconv_pcdata_impl<opt_false, opt_true, opt_true>::parse;
        case 4: return strconv_pcdata_impl<opt_true, opt_false, opt_false>::parse;
        case 5: return strconv_pcdata_impl<opt_true, opt_false, opt_true>::parse;
        case 6: return strconv_pcdata_impl<opt_true, opt_true, opt_false>::parse;
        case 7: return strconv_pcdata_impl<opt_true, opt_true, opt_true>::parse;
        default: assert(false); return 0; // unreachable
        }
    }

Referenced by xml_parser::parse_tree().

get_valid_length()

PUGI__FN size_t get_valid_length	(	const char_t *	data,
		size_t	length )

Definition at line 3669 of file pugixml.cc.

    {
        if (length < 5) return 0;
 
        for (size_t i = 1; i <= 4; ++i)
        {
            uint8_t ch = static_cast<uint8_t>(data[length - i]);
 
            // either a standalone character or a leading one
            if ((ch & 0xc0) != 0x80) return length - i;
        }
 
        // there are four non-leading characters at the end, sequence tail is broken so might as well process the whole chunk
        return length;
    }

Referenced by xml_buffered_writer::write_direct(), and xml_buffered_writer::write_string().

get_value_bool()

PUGI__FN bool get_value_bool

(

const char_t *

value

)

Definition at line 4624 of file pugixml.cc.

    {
        // only look at first char
        char_t first = *value;
 
        // 1*, t* (true), T* (True), y* (yes), Y* (YES)
        return (first == '1' || first == 't' || first == 'T' || first == 'y' || first == 'Y');
    }

get_value_double()

PUGI__FN double get_value_double

(

const char_t *

value

)

Definition at line 4606 of file pugixml.cc.

    {
    #ifdef PUGIXML_WCHAR_MODE
        return wcstod(value, 0);
    #else
        return strtod(value, 0);
    #endif
    }

get_value_float()

PUGI__FN float get_value_float

(

const char_t *

value

)

Definition at line 4615 of file pugixml.cc.

    {
    #ifdef PUGIXML_WCHAR_MODE
        return static_cast<float>(wcstod(value, 0));
    #else
        return static_cast<float>(strtod(value, 0));
    #endif
    }

get_value_int()

PUGI__FN int get_value_int

(

const char_t *

value

)

Definition at line 4596 of file pugixml.cc.

    {
        return string_to_integer<unsigned int>(value, static_cast<unsigned int>(INT_MIN), INT_MAX);
    }

get_value_uint()

PUGI__FN unsigned int get_value_uint

(

const char_t *

value

)

Definition at line 4601 of file pugixml.cc.

    {
        return string_to_integer<unsigned int>(value, 0, UINT_MAX);
    }

get_variable_scratch()

PUGI__FN bool get_variable_scratch	(	char_t(&)	buffer[32],
		xpath_variable_set *	set,
		const char_t *	begin,
		const char_t *	end,
		xpath_variable **	out_result )

Definition at line 8947 of file pugixml.cc.

    {
        size_t length = static_cast<size_t>(end - begin);
        char_t* scratch = buffer;
 
        if (length >= sizeof(buffer) / sizeof(buffer[0]))
        {
            // need to make dummy on-heap copy
            scratch = static_cast<char_t*>(xml_memory::allocate((length + 1) * sizeof(char_t)));
            if (!scratch) return false;
        }
 
        // copy string to zero-terminated buffer and perform lookup
        memcpy(scratch, begin, length * sizeof(char_t));
        scratch[length] = 0;
 
        *out_result = set->get(scratch);
 
        // free dummy buffer
        if (scratch != buffer) xml_memory::deallocate(scratch);
 
        return true;
    }

Referenced by xpath_parser::parse_primary_expression().

get_wchar_encoding()

PUGI__FN xml_encoding get_wchar_encoding

(

)

Definition at line 1925 of file pugixml.cc.

    {
        PUGI__STATIC_ASSERT(sizeof(wchar_t) == 2 || sizeof(wchar_t) == 4);
 
        if (sizeof(wchar_t) == 2)
            return is_little_endian() ? encoding_utf16_le : encoding_utf16_be;
        else
            return is_little_endian() ? encoding_utf32_le : encoding_utf32_be;
    }

Referenced by get_buffer_encoding(), get_write_encoding(), get_write_native_encoding(), and zero_terminate_buffer().

get_write_encoding()

PUGI__FN xml_encoding get_write_encoding

(

xml_encoding

encoding

)

Definition at line 3580 of file pugixml.cc.

    {
        // replace wchar encoding with utf implementation
        if (encoding == encoding_wchar) return get_wchar_encoding();
 
        // replace utf16 encoding with utf16 with specific endianness
        if (encoding == encoding_utf16) return is_little_endian() ? encoding_utf16_le : encoding_utf16_be;
 
        // replace utf32 encoding with utf32 with specific endianness
        if (encoding == encoding_utf32) return is_little_endian() ? encoding_utf32_le : encoding_utf32_be;
 
        // only do autodetection if no explicit encoding is requested
        if (encoding != encoding_auto) return encoding;
 
        // assume utf8 encoding
        return encoding_utf8;
    }

Referenced by xml_buffered_writer::xml_buffered_writer().

get_write_native_encoding()

PUGI__FN xml_encoding get_write_native_encoding

(

)

Definition at line 3571 of file pugixml.cc.

    {
    #ifdef PUGIXML_WCHAR_MODE
        return get_wchar_encoding();
    #else
        return encoding_utf8;
    #endif
    }

Referenced by xml_buffered_writer::flush(), and xml_buffered_writer::write_direct().

guess_buffer_encoding()

PUGI__FN xml_encoding guess_buffer_encoding	(	const uint8_t *	data,
		size_t	size )

Definition at line 1989 of file pugixml.cc.

    {
        // skip encoding autodetection if input buffer is too small
        if (size < 4) return encoding_utf8;
 
        uint8_t d0 = data[0], d1 = data[1], d2 = data[2], d3 = data[3];
 
        // look for BOM in first few bytes
        if (d0 == 0 && d1 == 0 && d2 == 0xfe && d3 == 0xff) return encoding_utf32_be;
        if (d0 == 0xff && d1 == 0xfe && d2 == 0 && d3 == 0) return encoding_utf32_le;
        if (d0 == 0xfe && d1 == 0xff) return encoding_utf16_be;
        if (d0 == 0xff && d1 == 0xfe) return encoding_utf16_le;
        if (d0 == 0xef && d1 == 0xbb && d2 == 0xbf) return encoding_utf8;
 
        // look for <, <? or <?xm in various encodings
        if (d0 == 0 && d1 == 0 && d2 == 0 && d3 == 0x3c) return encoding_utf32_be;
        if (d0 == 0x3c && d1 == 0 && d2 == 0 && d3 == 0) return encoding_utf32_le;
        if (d0 == 0 && d1 == 0x3c && d2 == 0 && d3 == 0x3f) return encoding_utf16_be;
        if (d0 == 0x3c && d1 == 0 && d2 == 0x3f && d3 == 0) return encoding_utf16_le;
 
        // look for utf16 < followed by node name (this may fail, but is better than utf8 since it's zero terminated so early)
        if (d0 == 0 && d1 == 0x3c) return encoding_utf16_be;
        if (d0 == 0x3c && d1 == 0) return encoding_utf16_le;
 
        // no known BOM detected; parse declaration
        const uint8_t* enc = 0;
        size_t enc_length = 0;
 
        if (d0 == 0x3c && d1 == 0x3f && d2 == 0x78 && d3 == 0x6d && parse_declaration_encoding(data, size, enc, enc_length))
        {
            // iso-8859-1 (case-insensitive)
            if (enc_length == 10
                && (enc[0] | ' ') == 'i' && (enc[1] | ' ') == 's' && (enc[2] | ' ') == 'o'
                && enc[3] == '-' && enc[4] == '8' && enc[5] == '8' && enc[6] == '5' && enc[7] == '9'
                && enc[8] == '-' && enc[9] == '1')
                return encoding_latin1;
 
            // latin1 (case-insensitive)
            if (enc_length == 6
                && (enc[0] | ' ') == 'l' && (enc[1] | ' ') == 'a' && (enc[2] | ' ') == 't'
                && (enc[3] | ' ') == 'i' && (enc[4] | ' ') == 'n'
                && enc[5] == '1')
                return encoding_latin1;
        }
 
        return encoding_utf8;
    }

Referenced by get_buffer_encoding().

has_declaration()

PUGI__FN bool has_declaration

(

xml_node_struct *

node

)

Definition at line 4346 of file pugixml.cc.

    {
        for (xml_node_struct* child = node->first_child; child; child = child->next_sibling)
        {
            xml_node_type type = PUGI__NODETYPE(child);
 
            if (type == node_declaration) return true;
            if (type == node_element) return false;
        }
 
        return false;
    }

hash_insert()

PUGI__FN bool hash_insert	(	const void **	table,
		size_t	size,
		const void *	key )

Definition at line 7708 of file pugixml.cc.

    {
        assert(key);
 
        unsigned int h = static_cast<unsigned int>(reinterpret_cast<uintptr_t>(key));
 
        // MurmurHash3 32-bit finalizer
        h ^= h >> 16;
        h *= 0x85ebca6bu;
        h ^= h >> 13;
        h *= 0xc2b2ae35u;
        h ^= h >> 16;
 
        size_t hashmod = size - 1;
        size_t bucket = h & hashmod;
 
        for (size_t probe = 0; probe <= hashmod; ++probe)
        {
            if (table[bucket] == 0)
            {
                table[bucket] = key;
                return true;
            }
 
            if (table[bucket] == key)
                return false;
 
            // hash collision, quadratic probing
            bucket = (bucket + probe + 1) & hashmod;
        }
 
        assert(false && "Hash table is full"); // unreachable
        return false;
    }

Referenced by xpath_node_set_raw::remove_duplicates().

hash_string()

PUGI__FN PUGI__UNSIGNED_OVERFLOW unsigned int hash_string

(

const char_t *

str

)

Definition at line 8838 of file pugixml.cc.

    {
        // Jenkins one-at-a-time hash (http://en.wikipedia.org/wiki/Jenkins_hash_function#one-at-a-time)
        unsigned int result = 0;
 
        while (*str)
        {
            result += static_cast<unsigned int>(*str++);
            result += result << 10;
            result ^= result >> 6;
        }
 
        result += result << 3;
        result ^= result >> 11;
        result += result << 15;
 
        return result;
    }

insert_attribute_after()

void insert_attribute_after ( xml_attribute_struct * attr, xml_attribute_struct * place, xml_node_struct * node )

inline

Definition at line 1368 of file pugixml.cc.

    {
        xml_attribute_struct* next = place->next_attribute;
 
        if (next)
            next->prev_attribute_c = attr;
        else
            node->first_attribute->prev_attribute_c = attr;
 
        attr->next_attribute = next;
        attr->prev_attribute_c = place;
        place->next_attribute = attr;
    }

insert_attribute_before()

void insert_attribute_before ( xml_attribute_struct * attr, xml_attribute_struct * place, xml_node_struct * node )

inline

Definition at line 1382 of file pugixml.cc.

    {
        xml_attribute_struct* prev = place->prev_attribute_c;
 
        if (prev->next_attribute)
            prev->next_attribute = attr;
        else
            node->first_attribute = attr;
 
        attr->prev_attribute_c = prev;
        attr->next_attribute = place;
        place->prev_attribute_c = attr;
    }

insert_node_after()

void insert_node_after ( xml_node_struct * child, xml_node_struct * node )

inline

Definition at line 1273 of file pugixml.cc.

    {
        xml_node_struct* parent = node->parent;
 
        child->parent = parent;
 
        xml_node_struct* next = node->next_sibling;
 
        if (next)
            next->prev_sibling_c = child;
        else
            parent->first_child->prev_sibling_c = child;
 
        child->next_sibling = next;
        child->prev_sibling_c = node;
 
        node->next_sibling = child;
    }

insert_node_before()

void insert_node_before ( xml_node_struct * child, xml_node_struct * node )

inline

Definition at line 1292 of file pugixml.cc.

    {
        xml_node_struct* parent = node->parent;
 
        child->parent = parent;
 
        xml_node_struct* prev = node->prev_sibling_c;
 
        if (prev->next_sibling)
            prev->next_sibling = child;
        else
            parent->first_child = child;
 
        child->prev_sibling_c = prev;
        child->next_sibling = node;
 
        node->prev_sibling_c = child;
    }

insertion_sort()

template<typename T, typename Pred>

PUGI__FN void insertion_sort	(	T *	begin,
		T *	end,
		const Pred &	pred )

Definition at line 7617 of file pugixml.cc.

    {
        if (begin == end)
            return;
 
        for (T* it = begin + 1; it != end; ++it)
        {
            T val = *it;
            T* hole = it;
 
            // move hole backwards
            while (hole > begin && pred(val, *(hole - 1)))
            {
                *hole = *(hole - 1);
                hole--;
            }
 
            // fill hole with element
            *hole = val;
        }
    }

Referenced by sort().

integer_to_string()

template<typename U>

PUGI__FN PUGI__UNSIGNED_OVERFLOW char_t * integer_to_string	(	char_t *	begin,
		char_t *	end,
		U	value,
		bool	negative )

Definition at line 4645 of file pugixml.cc.

    {
        char_t* result = end - 1;
        U rest = negative ? 0 - value : value;
 
        do
        {
            *result-- = static_cast<char_t>('0' + (rest % 10));
            rest /= 10;
        }
        while (rest);
 
        assert(result >= begin);
        (void)begin;
 
        *result = '-';
 
        return result + !negative;
    }

Referenced by set_value_integer().

is_attribute_of()

PUGI__FN bool is_attribute_of	(	xml_attribute_struct *	attr,
		xml_node_struct *	node )

Definition at line 4359 of file pugixml.cc.

    {
        for (xml_attribute_struct* a = node->first_attribute; a; a = a->next_attribute)
            if (a == attr)
                return true;
 
        return false;
    }

is_little_endian()

PUGI__FN bool is_little_endian

(

)

Definition at line 1918 of file pugixml.cc.

    {
        unsigned int ui = 1;
 
        return *reinterpret_cast<unsigned char*>(&ui) == 1;
    }

Referenced by convert_buffer(), convert_buffer_output(), get_buffer_encoding(), get_wchar_encoding(), and get_write_encoding().

is_nan()

PUGI__FN bool is_nan

(

double

value

)

Definition at line 8346 of file pugixml.cc.

    {
    #if defined(PUGI__MSVC_CRT_VERSION) || defined(__BORLANDC__)
        return !!_isnan(value);
    #elif defined(fpclassify) && defined(FP_NAN)
        return fpclassify(value) == FP_NAN;
    #else
        // fallback
        const volatile double v = value;
        return v != v;
    #endif
    }

Referenced by convert_number_to_boolean(), and xpath_ast_node::eval_string().

is_text_node()

bool is_text_node ( xml_node_struct * node )

inline

Definition at line 4506 of file pugixml.cc.

    {
        xml_node_type type = PUGI__NODETYPE(node);
 
        return type == node_pcdata || type == node_cdata;
    }

is_xpath_attribute()

bool is_xpath_attribute ( const char_t * name )

inline

Definition at line 8786 of file pugixml.cc.

    {
        return !(starts_with(name, PUGIXML_TEXT("xmlns")) && (name[5] == 0 || name[5] == ':'));
    }

Referenced by xpath_ast_node::eval_boolean().

load_buffer_impl()

PUGI__FN xml_parse_result load_buffer_impl	(	xml_document_struct *	doc,
		xml_node_struct *	root,
		void *	contents,
		size_t	size,
		unsigned int	options,
		xml_encoding	encoding,
		bool	is_mutable,
		bool	own,
		char_t **	out_buffer )

Definition at line 4716 of file pugixml.cc.

    {
        // check input buffer
        if (!contents && size) return make_parse_result(status_io_error);
 
        // get actual encoding
        xml_encoding buffer_encoding = impl::get_buffer_encoding(encoding, contents, size);
 
        // if convert_buffer below throws bad_alloc, we still need to deallocate contents if we own it
        auto_deleter<void> contents_guard(own ? contents : 0, xml_memory::deallocate);
 
        // get private buffer
        char_t* buffer = 0;
        size_t length = 0;
 
        // coverity[var_deref_model]
        if (!impl::convert_buffer(buffer, length, buffer_encoding, contents, size, is_mutable)) return impl::make_parse_result(status_out_of_memory);
 
        // after this we either deallocate contents (below) or hold on to it via doc->buffer, so we don't need to guard it
        contents_guard.release();
 
        // delete original buffer if we performed a conversion
        if (own && buffer != contents && contents) impl::xml_memory::deallocate(contents);
 
        // grab onto buffer if it's our buffer, user is responsible for deallocating contents himself
        if (own || buffer != contents) *out_buffer = buffer;
 
        // store buffer for offset_debug
        doc->buffer = buffer;
 
        // parse
        xml_parse_result res = impl::xml_parser::parse(buffer, length, doc, root, options);
 
        // remember encoding
        res.encoding = buffer_encoding;
 
        return res;
    }

Referenced by load_file_impl(), and load_stream_impl().

load_file_impl()

PUGI__FN xml_parse_result load_file_impl	(	xml_document_struct *	doc,
		FILE *	file,
		unsigned int	options,
		xml_encoding	encoding,
		char_t **	out_buffer )

Definition at line 4820 of file pugixml.cc.

    {
        if (!file) return make_parse_result(status_file_not_found);
 
        // get file size (can result in I/O errors)
        size_t size = 0;
        xml_parse_status size_status = get_file_size(file, size);
        if (size_status != status_ok) return make_parse_result(size_status);
 
        size_t max_suffix_size = sizeof(char_t);
 
        // allocate buffer for the whole file
        char* contents = static_cast<char*>(xml_memory::allocate(size + max_suffix_size));
        if (!contents) return make_parse_result(status_out_of_memory);
 
        // read file in memory
        size_t read_size = fread(contents, 1, size, file);
 
        if (read_size != size)
        {
            xml_memory::deallocate(contents);
            return make_parse_result(status_io_error);
        }
 
        xml_encoding real_encoding = get_buffer_encoding(encoding, contents, size);
 
        return load_buffer_impl(doc, doc, contents, zero_terminate_buffer(contents, size, real_encoding), options, real_encoding, true, true, out_buffer);
    }

load_stream_data_noseek()

template<typename T>

PUGI__FN xml_parse_status load_stream_data_noseek	(	std::basic_istream< T > &	stream,
		void **	out_buffer,
		size_t *	out_size )

Definition at line 4888 of file pugixml.cc.

    {
        auto_deleter<xml_stream_chunk<T> > chunks(0, xml_stream_chunk<T>::destroy);
 
        // read file to a chunk list
        size_t total = 0;
        xml_stream_chunk<T>* last = 0;
 
        while (!stream.eof())
        {
            // allocate new chunk
            xml_stream_chunk<T>* chunk = xml_stream_chunk<T>::create();
            if (!chunk) return status_out_of_memory;
 
            // append chunk to list
            if (last) last = last->next = chunk;
            else chunks.data = last = chunk;
 
            // read data to chunk
            stream.read(chunk->data, static_cast<std::streamsize>(sizeof(chunk->data) / sizeof(T)));
            chunk->size = static_cast<size_t>(stream.gcount()) * sizeof(T);
 
            // read may set failbit | eofbit in case gcount() is less than read length, so check for other I/O errors
            if (stream.bad() || (!stream.eof() && stream.fail())) return status_io_error;
 
            // guard against huge files (chunk size is small enough to make this overflow check work)
            if (total + chunk->size < total) return status_out_of_memory;
            total += chunk->size;
        }
 
        size_t max_suffix_size = sizeof(char_t);
 
        // copy chunk list to a contiguous buffer
        char* buffer = static_cast<char*>(xml_memory::allocate(total + max_suffix_size));
        if (!buffer) return status_out_of_memory;
 
        char* write = buffer;
 
        for (xml_stream_chunk<T>* chunk = chunks.data; chunk; chunk = chunk->next)
        {
            assert(write + chunk->size <= buffer + total);
            memcpy(write, chunk->data, chunk->size);
            write += chunk->size;
        }
 
        assert(write == buffer + total);
 
        // return buffer
        *out_buffer = buffer;
        *out_size = total;
 
        return status_ok;
    }

Referenced by load_stream_impl().

load_stream_data_seek()

template<typename T>

PUGI__FN xml_parse_status load_stream_data_seek	(	std::basic_istream< T > &	stream,
		void **	out_buffer,
		size_t *	out_size )

Definition at line 4942 of file pugixml.cc.

    {
        // get length of remaining data in stream
        typename std::basic_istream<T>::pos_type pos = stream.tellg();
        stream.seekg(0, std::ios::end);
        std::streamoff length = stream.tellg() - pos;
        stream.seekg(pos);
 
        if (stream.fail() || pos < 0) return status_io_error;
 
        // guard against huge files
        size_t read_length = static_cast<size_t>(length);
 
        if (static_cast<std::streamsize>(read_length) != length || length < 0) return status_out_of_memory;
 
        size_t max_suffix_size = sizeof(char_t);
 
        // read stream data into memory (guard against stream exceptions with buffer holder)
        auto_deleter<void> buffer(xml_memory::allocate(read_length * sizeof(T) + max_suffix_size), xml_memory::deallocate);
        if (!buffer.data) return status_out_of_memory;
 
        stream.read(static_cast<T*>(buffer.data), static_cast<std::streamsize>(read_length));
 
        // read may set failbit | eofbit in case gcount() is less than read_length (i.e. line ending conversion), so check for other I/O errors
        if (stream.bad() || (!stream.eof() && stream.fail())) return status_io_error;
 
        // return buffer
        size_t actual_length = static_cast<size_t>(stream.gcount());
        assert(actual_length <= read_length);
 
        *out_buffer = buffer.release();
        *out_size = actual_length * sizeof(T);
 
        return status_ok;
    }

Referenced by load_stream_impl().

load_stream_impl()

template<typename T>

PUGI__FN xml_parse_result load_stream_impl	(	xml_document_struct *	doc,
		std::basic_istream< T > &	stream,
		unsigned int	options,
		xml_encoding	encoding,
		char_t **	out_buffer )

Definition at line 4978 of file pugixml.cc.

    {
        void* buffer = 0;
        size_t size = 0;
        xml_parse_status status = status_ok;
 
        // if stream has an error bit set, bail out (otherwise tellg() can fail and we'll clear error bits)
        if (stream.fail()) return make_parse_result(status_io_error);
 
        // load stream to memory (using seek-based implementation if possible, since it's faster and takes less memory)
        if (stream.tellg() < 0)
        {
            stream.clear(); // clear error flags that could be set by a failing tellg
            status = load_stream_data_noseek(stream, &buffer, &size);
        }
        else
            status = load_stream_data_seek(stream, &buffer, &size);
 
        if (status != status_ok) return make_parse_result(status);
 
        xml_encoding real_encoding = get_buffer_encoding(encoding, buffer, size);
 
        return load_buffer_impl(doc, doc, buffer, zero_terminate_buffer(buffer, size, real_encoding), options, real_encoding, true, true, out_buffer);
    }

local_name()

PUGI__FN const char_t * local_name

(

const xpath_node &

node

)

Definition at line 8599 of file pugixml.cc.

    {
        const char_t* name = qualified_name(node);
        const char_t* p = find_char(name, ':');
 
        return p ? p + 1 : name;
    }

Referenced by xpath_ast_node::eval_string().

make_parse_result()

xml_parse_result make_parse_result ( xml_parse_status status, ptrdiff_t offset = 0 )

inline

Definition at line 2920 of file pugixml.cc.

    {
        xml_parse_result result;
        result.status = status;
        result.offset = offset;
 
        return result;
    }

Referenced by load_buffer_impl(), load_file_impl(), load_stream_impl(), and xml_parser::parse().

median3()

template<typename I, typename Pred>

I median3 ( I first, I middle, I last, const Pred & pred )

inline

Definition at line 7639 of file pugixml.cc.

    {
        if (pred(*middle, *first))
            swap(middle, first);
        if (pred(*last, *middle))
            swap(last, middle);
        if (pred(*middle, *first))
            swap(middle, first);
 
        return middle;
    }

Referenced by sort().

min_element()

template<typename I, typename Pred>

PUGI__FN I min_element	(	I	begin,
		I	end,
		const Pred &	pred )

Definition at line 7575 of file pugixml.cc.

    {
        I result = begin;
 
        for (I it = begin + 1; it != end; ++it)
            if (pred(*it, *result))
                result = it;
 
        return result;
    }

Referenced by xpath_first().

namespace_uri() [1/3]

PUGI__FN const char_t * namespace_uri

(

const xpath_node &

node

)

Definition at line 8669 of file pugixml.cc.

    {
        return node.attribute() ? namespace_uri(node.attribute(), node.parent()) : namespace_uri(node.node());
    }

namespace_uri() [2/3]

PUGI__FN const char_t * namespace_uri	(	xml_attribute	attr,
		xml_node	parent )

Definition at line 8648 of file pugixml.cc.

    {
        namespace_uri_predicate pred = attr.name();
 
        // Default namespace does not apply to attributes
        if (!pred.prefix) return PUGIXML_TEXT("");
 
        xml_node p = parent;
 
        while (p)
        {
            xml_attribute a = p.find_attribute(pred);
 
            if (a) return a.value();
 
            p = p.parent();
        }
 
        return PUGIXML_TEXT("");
    }

namespace_uri() [3/3]

PUGI__FN const char_t * namespace_uri

(

xml_node

node

)

Definition at line 8630 of file pugixml.cc.

    {
        namespace_uri_predicate pred = node.name();
 
        xml_node p = node;
 
        while (p)
        {
            xml_attribute a = p.find_attribute(pred);
 
            if (a) return a.value();
 
            p = p.parent();
        }
 
        return PUGIXML_TEXT("");
    }

Referenced by xpath_ast_node::eval_string(), and namespace_uri().

new_xpath_variable() [1/2]

template<typename T>

PUGI__FN T * new_xpath_variable

(

const char_t *

name

)

Definition at line 8857 of file pugixml.cc.

    {
        size_t length = strlength(name);
        if (length == 0) return 0; // empty variable names are invalid
 
        // $$ we can't use offsetof(T, name) because T is non-POD, so we just allocate additional length characters
        void* memory = xml_memory::allocate(sizeof(T) + length * sizeof(char_t));
        if (!memory) return 0;
 
        T* result = new (memory) T();
 
        memcpy(result->name, name, (length + 1) * sizeof(char_t));
 
        return result;
    }

Referenced by new_xpath_variable().

new_xpath_variable() [2/2]

PUGI__FN xpath_variable * new_xpath_variable	(	xpath_value_type	type,
		const char_t *	name )

Definition at line 8873 of file pugixml.cc.

    {
        switch (type)
        {
        case xpath_type_node_set:
            return new_xpath_variable<xpath_variable_node_set>(name);
 
        case xpath_type_number:
            return new_xpath_variable<xpath_variable_number>(name);
 
        case xpath_type_string:
            return new_xpath_variable<xpath_variable_string>(name);
 
        case xpath_type_boolean:
            return new_xpath_variable<xpath_variable_boolean>(name);
 
        default:
            return 0;
        }
    }

node_copy_attribute()

PUGI__FN void node_copy_attribute	(	xml_attribute_struct *	da,
		xml_attribute_struct *	sa )

Definition at line 4497 of file pugixml.cc.

    {
        xml_allocator& alloc = get_allocator(da);
        xml_allocator* shared_alloc = (&alloc == &get_allocator(sa)) ? &alloc : 0;
 
        node_copy_string(da->name, da->header, xml_memory_page_name_allocated_mask, sa->name, sa->header, shared_alloc);
        node_copy_string(da->value, da->header, xml_memory_page_value_allocated_mask, sa->value, sa->header, shared_alloc);
    }

node_copy_contents()

PUGI__FN void node_copy_contents	(	xml_node_struct *	dn,
		xml_node_struct *	sn,
		xml_allocator *	shared_alloc )

Definition at line 4426 of file pugixml.cc.

    {
        node_copy_string(dn->name, dn->header, xml_memory_page_name_allocated_mask, sn->name, sn->header, shared_alloc);
        node_copy_string(dn->value, dn->header, xml_memory_page_value_allocated_mask, sn->value, sn->header, shared_alloc);
 
        for (xml_attribute_struct* sa = sn->first_attribute; sa; sa = sa->next_attribute)
        {
            xml_attribute_struct* da = append_new_attribute(dn, get_allocator(dn));
 
            if (da)
            {
                node_copy_string(da->name, da->header, xml_memory_page_name_allocated_mask, sa->name, sa->header, shared_alloc);
                node_copy_string(da->value, da->header, xml_memory_page_value_allocated_mask, sa->value, sa->header, shared_alloc);
            }
        }
    }

Referenced by node_copy_tree().

node_copy_string()

template<typename String, typename Header>

PUGI__FN void node_copy_string	(	String &	dest,
		Header &	header,
		uintptr_t	header_mask,
		char_t *	source,
		Header &	source_header,
		xml_allocator *	alloc )

Definition at line 4407 of file pugixml.cc.

    {
        assert(!dest && (header & header_mask) == 0);
 
        if (source)
        {
            if (alloc && (source_header & header_mask) == 0)
            {
                dest = source;
 
                // since strcpy_insitu can reuse document buffer memory we need to mark both source and dest as shared
                header |= xml_memory_page_contents_shared_mask;
                source_header |= xml_memory_page_contents_shared_mask;
            }
            else
                strcpy_insitu(dest, header, header_mask, source, strlength(source));
        }
    }

Referenced by node_copy_attribute(), and node_copy_contents().

node_copy_tree()

PUGI__FN void node_copy_tree	(	xml_node_struct *	dn,
		xml_node_struct *	sn )

Definition at line 4443 of file pugixml.cc.

    {
        xml_allocator& alloc = get_allocator(dn);
        xml_allocator* shared_alloc = (&alloc == &get_allocator(sn)) ? &alloc : 0;
 
        node_copy_contents(dn, sn, shared_alloc);
 
        xml_node_struct* dit = dn;
        xml_node_struct* sit = sn->first_child;
 
        while (sit && sit != sn)
        {
            // loop invariant: dit is inside the subtree rooted at dn
            assert(dit);
 
            // when a tree is copied into one of the descendants, we need to skip that subtree to avoid an infinite loop
            if (sit != dn)
            {
                xml_node_struct* copy = append_new_node(dit, alloc, PUGI__NODETYPE(sit));
 
                if (copy)
                {
                    node_copy_contents(copy, sit, shared_alloc);
 
                    if (sit->first_child)
                    {
                        dit = copy;
                        sit = sit->first_child;
                        continue;
                    }
                }
            }
 
            // continue to the next node
            do
            {
                if (sit->next_sibling)
                {
                    sit = sit->next_sibling;
                    break;
                }
 
                sit = sit->parent;
                dit = dit->parent;
 
                // loop invariant: dit is inside the subtree rooted at dn while sit is inside sn
                assert(sit == sn || dit);
            }
            while (sit != sn);
        }
 
        assert(!sit || dit == dn->parent);
    }

node_is_ancestor()

PUGI__FN bool node_is_ancestor	(	xml_node_struct *	parent,
		xml_node_struct *	node )

Definition at line 8239 of file pugixml.cc.

    {
        while (node && node != parent) node = node->parent;
 
        return parent && node == parent;
    }

node_is_before()

PUGI__FN bool node_is_before	(	xml_node_struct *	ln,
		xml_node_struct *	rn )

Definition at line 8196 of file pugixml.cc.

    {
        // find common ancestor at the same depth, if any
        xml_node_struct* lp = ln;
        xml_node_struct* rp = rn;
 
        while (lp && rp && lp->parent != rp->parent)
        {
            lp = lp->parent;
            rp = rp->parent;
        }
 
        // parents are the same!
        if (lp && rp) return node_is_before_sibling(lp, rp);
 
        // nodes are at different depths, need to normalize heights
        bool left_higher = !lp;
 
        while (lp)
        {
            lp = lp->parent;
            ln = ln->parent;
        }
 
        while (rp)
        {
            rp = rp->parent;
            rn = rn->parent;
        }
 
        // one node is the ancestor of the other
        if (ln == rn) return left_higher;
 
        // find common ancestor... again
        while (ln->parent != rn->parent)
        {
            ln = ln->parent;
            rn = rn->parent;
        }
 
        return node_is_before_sibling(ln, rn);
    }

Referenced by document_order_comparator::operator()().

node_is_before_sibling()

PUGI__FN bool node_is_before_sibling	(	xml_node_struct *	ln,
		xml_node_struct *	rn )

Definition at line 8172 of file pugixml.cc.

    {
        assert(ln->parent == rn->parent);
 
        // there is no common ancestor (the shared parent is null), nodes are from different documents
        if (!ln->parent) return ln < rn;
 
        // determine sibling order
        xml_node_struct* ls = ln;
        xml_node_struct* rs = rn;
 
        while (ls && rs)
        {
            if (ls == rn) return true;
            if (rs == ln) return false;
 
            ls = ls->next_sibling;
            rs = rs->next_sibling;
        }
 
        // if rn sibling chain ended ln must be before rn
        return !rs;
    }

Referenced by node_is_before().

node_output()

PUGI__FN void node_output	(	xml_buffered_writer &	writer,
		xml_node_struct *	root,
		const char_t *	indent,
		unsigned int	flags,
		unsigned int	depth )

Definition at line 4253 of file pugixml.cc.

    {
        size_t indent_length = ((flags & (format_indent | format_indent_attributes)) && (flags & format_raw) == 0) ? strlength(indent) : 0;
        unsigned int indent_flags = indent_indent;
 
        xml_node_struct* node = root;
 
        do
        {
            assert(node);
 
            // begin writing current node
            if (PUGI__NODETYPE(node) == node_pcdata || PUGI__NODETYPE(node) == node_cdata)
            {
                node_output_simple(writer, node, flags);
 
                indent_flags = 0;
            }
            else
            {
                if ((indent_flags & indent_newline) && (flags & format_raw) == 0)
                    writer.write('\n');
 
                if ((indent_flags & indent_indent) && indent_length)
                    text_output_indent(writer, indent, indent_length, depth);
 
                if (PUGI__NODETYPE(node) == node_element)
                {
                    indent_flags = indent_newline | indent_indent;
 
                    if (node_output_start(writer, node, indent, indent_length, flags, depth))
                    {
                        // element nodes can have value if parse_embed_pcdata was used
                        if (node->value)
                            indent_flags = 0;
 
                        node = node->first_child;
                        depth++;
                        continue;
                    }
                }
                else if (PUGI__NODETYPE(node) == node_document)
                {
                    indent_flags = indent_indent;
 
                    if (node->first_child)
                    {
                        node = node->first_child;
                        continue;
                    }
                }
                else
                {
                    node_output_simple(writer, node, flags);
 
                    indent_flags = indent_newline | indent_indent;
                }
            }
 
            // continue to the next node
            while (node != root)
            {
                if (node->next_sibling)
                {
                    node = node->next_sibling;
                    break;
                }
 
                node = node->parent;
 
                // write closing node
                if (PUGI__NODETYPE(node) == node_element)
                {
                    depth--;
 
                    if ((indent_flags & indent_newline) && (flags & format_raw) == 0)
                        writer.write('\n');
 
                    if ((indent_flags & indent_indent) && indent_length)
                        text_output_indent(writer, indent, indent_length, depth);
 
                    node_output_end(writer, node);
 
                    indent_flags = indent_newline | indent_indent;
                }
            }
        }
        while (node != root);
 
        if ((indent_flags & indent_newline) && (flags & format_raw) == 0)
            writer.write('\n');
    }

node_output_attributes()

PUGI__FN void node_output_attributes	(	xml_buffered_writer &	writer,
		xml_node_struct *	node,
		const char_t *	indent,
		size_t	indent_length,
		unsigned int	flags,
		unsigned int	depth )

Definition at line 4091 of file pugixml.cc.

    {
        const char_t* default_name = PUGIXML_TEXT(":anonymous");
        const char_t enquotation_char = (flags & format_attribute_single_quote) ? '\'' : '"';
 
        for (xml_attribute_struct* a = node->first_attribute; a; a = a->next_attribute)
        {
            if ((flags & (format_indent_attributes | format_raw)) == format_indent_attributes)
            {
                writer.write('\n');
 
                text_output_indent(writer, indent, indent_length, depth + 1);
            }
            else
            {
                writer.write(' ');
            }
 
            writer.write_string(a->name ? a->name + 0 : default_name);
            writer.write('=', enquotation_char);
 
            if (a->value)
                text_output(writer, a->value, ctx_special_attr, flags);
 
            writer.write(enquotation_char);
        }
    }

Referenced by node_output_simple(), and node_output_start().

node_output_comment()

PUGI__FN void node_output_comment	(	xml_buffered_writer &	writer,
		const char_t *	s )

Definition at line 4045 of file pugixml.cc.

    {
        writer.write('<', '!', '-', '-');
 
        while (*s)
        {
            const char_t* prev = s;
 
            // look for -\0 or -- sequence - we can't output it since -- is illegal in comment body
            while (*s && !(s[0] == '-' && (s[1] == '-' || s[1] == 0))) ++s;
 
            writer.write_buffer(prev, static_cast<size_t>(s - prev));
 
            if (*s)
            {
                assert(*s == '-');
 
                writer.write('-', ' ');
                ++s;
            }
        }
 
        writer.write('-', '-', '>');
    }

Referenced by node_output_simple().

node_output_end()

PUGI__FN void node_output_end	(	xml_buffered_writer &	writer,
		xml_node_struct *	node )

Definition at line 4181 of file pugixml.cc.

    {
        const char_t* default_name = PUGIXML_TEXT(":anonymous");
        const char_t* name = node->name ? node->name + 0 : default_name;
 
        writer.write('<', '/');
        writer.write_string(name);
        writer.write('>');
    }

Referenced by node_output().

node_output_pi_value()

PUGI__FN void node_output_pi_value	(	xml_buffered_writer &	writer,
		const char_t *	s )

Definition at line 4070 of file pugixml.cc.

    {
        while (*s)
        {
            const char_t* prev = s;
 
            // look for ?> sequence - we can't output it since ?> terminates PI
            while (*s && !(s[0] == '?' && s[1] == '>')) ++s;
 
            writer.write_buffer(prev, static_cast<size_t>(s - prev));
 
            if (*s)
            {
                assert(s[0] == '?' && s[1] == '>');
 
                writer.write('?', ' ', '>');
                s += 2;
            }
        }
    }

Referenced by node_output_simple().

node_output_simple()

PUGI__FN void node_output_simple	(	xml_buffered_writer &	writer,
		xml_node_struct *	node,
		unsigned int	flags )

Definition at line 4191 of file pugixml.cc.

    {
        const char_t* default_name = PUGIXML_TEXT(":anonymous");
 
        switch (PUGI__NODETYPE(node))
        {
            case node_pcdata:
                text_output(writer, node->value ? node->value + 0 : PUGIXML_TEXT(""), ctx_special_pcdata, flags);
                break;
 
            case node_cdata:
                text_output_cdata(writer, node->value ? node->value + 0 : PUGIXML_TEXT(""));
                break;
 
            case node_comment:
                node_output_comment(writer, node->value ? node->value + 0 : PUGIXML_TEXT(""));
                break;
 
            case node_pi:
                writer.write('<', '?');
                writer.write_string(node->name ? node->name + 0 : default_name);
 
                if (node->value)
                {
                    writer.write(' ');
                    node_output_pi_value(writer, node->value);
                }
 
                writer.write('?', '>');
                break;
 
            case node_declaration:
                writer.write('<', '?');
                writer.write_string(node->name ? node->name + 0 : default_name);
                node_output_attributes(writer, node, PUGIXML_TEXT(""), 0, flags | format_raw, 0);
                writer.write('?', '>');
                break;
 
            case node_doctype:
                writer.write('<', '!', 'D', 'O', 'C');
                writer.write('T', 'Y', 'P', 'E');
 
                if (node->value)
                {
                    writer.write(' ');
                    writer.write_string(node->value);
                }
 
                writer.write('>');
                break;
 
            default:
                assert(false && "Invalid node type"); // unreachable
        }
    }

Referenced by node_output().

node_output_start()

PUGI__FN bool node_output_start	(	xml_buffered_writer &	writer,
		xml_node_struct *	node,
		const char_t *	indent,
		size_t	indent_length,
		unsigned int	flags,
		unsigned int	depth )

Definition at line 4119 of file pugixml.cc.

    {
        const char_t* default_name = PUGIXML_TEXT(":anonymous");
        const char_t* name = node->name ? node->name + 0 : default_name;
 
        writer.write('<');
        writer.write_string(name);
 
        if (node->first_attribute)
            node_output_attributes(writer, node, indent, indent_length, flags, depth);
 
        // element nodes can have value if parse_embed_pcdata was used
        if (!node->value)
        {
            if (!node->first_child)
            {
                if (flags & format_no_empty_element_tags)
                {
                    writer.write('>', '<', '/');
                    writer.write_string(name);
                    writer.write('>');
 
                    return false;
                }
                else
                {
                    if ((flags & format_raw) == 0)
                        writer.write(' ');
 
                    writer.write('/', '>');
 
                    return false;
                }
            }
            else
            {
                writer.write('>');
 
                return true;
            }
        }
        else
        {
            writer.write('>');
 
            text_output(writer, node->value, ctx_special_pcdata, flags);
 
            if (!node->first_child)
            {
                writer.write('<', '/');
                writer.write_string(name);
                writer.write('>');
 
                return false;
            }
            else
            {
                return true;
            }
        }
    }

Referenced by node_output().

normalize_space()

PUGI__FN char_t * normalize_space

(

char_t *

buffer

)

Definition at line 8674 of file pugixml.cc.

    {
        char_t* write = buffer;
 
        for (char_t* it = buffer; *it; )
        {
            char_t ch = *it++;
 
            if (PUGI__IS_CHARTYPE(ch, ct_space))
            {
                // replace whitespace sequence with single space
                while (PUGI__IS_CHARTYPE(*it, ct_space)) it++;
 
                // avoid leading spaces
                if (write != buffer) *write++ = ' ';
            }
            else *write++ = ch;
        }
 
        // remove trailing space
        if (write != buffer && PUGI__IS_CHARTYPE(write[-1], ct_space)) write--;
 
        // zero-terminate
        *write = 0;
 
        return write;
    }

Referenced by xpath_ast_node::eval_string().

open_file()

PUGI__FN FILE * open_file	(	const char *	path,
		const char *	mode )

Definition at line 5056 of file pugixml.cc.

    {
#if defined(PUGI__MSVC_CRT_VERSION) && PUGI__MSVC_CRT_VERSION >= 1400
        FILE* file = 0;
        return fopen_s(&file, path, mode) == 0 ? file : 0;
#else
        return fopen(path, mode);
#endif
    }

open_file_wide()

PUGI__FN FILE * open_file_wide	(	const wchar_t *	path,
		const wchar_t *	mode )

Definition at line 5036 of file pugixml.cc.

    {
        // there is no standard function to open wide paths, so our best bet is to try utf8 path
        char* path_utf8 = convert_path_heap(path);
        if (!path_utf8) return 0;
 
        // convert mode to ASCII (we mirror _wfopen interface)
        char mode_ascii[4] = {0};
        for (size_t i = 0; mode[i]; ++i) mode_ascii[i] = static_cast<char>(mode[i]);
 
        // try to open the utf8 path
        FILE* result = fopen(path_utf8, mode_ascii);
 
        // free dummy buffer
        xml_memory::deallocate(path_utf8);
 
        return result;
    }

parse_declaration_encoding()

PUGI__FN bool parse_declaration_encoding	(	const uint8_t *	data,
		size_t	size,
		const uint8_t *&	out_encoding,
		size_t &	out_length )

Definition at line 1935 of file pugixml.cc.

    {
    #define PUGI__SCANCHAR(ch) { if (offset >= size || data[offset] != ch) return false; offset++; }
    #define PUGI__SCANCHARTYPE(ct) { while (offset < size && PUGI__IS_CHARTYPE(data[offset], ct)) offset++; }
 
        // check if we have a non-empty XML declaration
        if (size < 6 || !((data[0] == '<') & (data[1] == '?') & (data[2] == 'x') & (data[3] == 'm') & (data[4] == 'l') && PUGI__IS_CHARTYPE(data[5], ct_space)))
            return false;
 
        // scan XML declaration until the encoding field
        for (size_t i = 6; i + 1 < size; ++i)
        {
            // declaration can not contain ? in quoted values
            if (data[i] == '?')
                return false;
 
            if (data[i] == 'e' && data[i + 1] == 'n')
            {
                size_t offset = i;
 
                // encoding follows the version field which can't contain 'en' so this has to be the encoding if XML is well formed
                PUGI__SCANCHAR('e'); PUGI__SCANCHAR('n'); PUGI__SCANCHAR('c'); PUGI__SCANCHAR('o');
                PUGI__SCANCHAR('d'); PUGI__SCANCHAR('i'); PUGI__SCANCHAR('n'); PUGI__SCANCHAR('g');
 
                // S? = S?
                PUGI__SCANCHARTYPE(ct_space);
                PUGI__SCANCHAR('=');
                PUGI__SCANCHARTYPE(ct_space);
 
                // the only two valid delimiters are ' and "
                uint8_t delimiter = (offset < size && data[offset] == '"') ? '"' : '\'';
 
                PUGI__SCANCHAR(delimiter);
 
                size_t start = offset;
 
                out_encoding = data + offset;
 
                PUGI__SCANCHARTYPE(ct_symbol);
 
                out_length = offset - start;
 
                PUGI__SCANCHAR(delimiter);
 
                return true;
            }
        }
 
        return false;
 
    #undef PUGI__SCANCHAR
    #undef PUGI__SCANCHARTYPE
    }

Referenced by guess_buffer_encoding().

partition3()

template<typename T, typename Pred>

PUGI__FN void partition3	(	T *	begin,
		T *	end,
		T	pivot,
		const Pred &	pred,
		T **	out_eqbeg,
		T **	out_eqend )

Definition at line 7651 of file pugixml.cc.

    {
        // invariant: array is split into 4 groups: = < ? > (each variable denotes the boundary between the groups)
        T* eq = begin;
        T* lt = begin;
        T* gt = end;
 
        while (lt < gt)
        {
            if (pred(*lt, pivot))
                lt++;
            else if (*lt == pivot)
                swap(*eq++, *lt++);
            else
                swap(*lt, *--gt);
        }
 
        // we now have just 4 groups: = < >; move equal elements to the middle
        T* eqbeg = gt;
 
        for (T* it = begin; it != eq; ++it)
            swap(*it, *--eqbeg);
 
        *out_eqbeg = eqbeg;
        *out_eqend = gt;
    }

Referenced by sort().

prepend_attribute()

void prepend_attribute ( xml_attribute_struct * attr, xml_node_struct * node )

inline

Definition at line 1352 of file pugixml.cc.

    {
        xml_attribute_struct* head = node->first_attribute;
 
        if (head)
        {
            attr->prev_attribute_c = head->prev_attribute_c;
            head->prev_attribute_c = attr;
        }
        else
            attr->prev_attribute_c = attr;
 
        attr->next_attribute = head;
        node->first_attribute = attr;
    }

prepend_node()

void prepend_node ( xml_node_struct * child, xml_node_struct * node )

inline

Definition at line 1255 of file pugixml.cc.

    {
        child->parent = node;
 
        xml_node_struct* head = node->first_child;
 
        if (head)
        {
            child->prev_sibling_c = head->prev_sibling_c;
            head->prev_sibling_c = child;
        }
        else
            child->prev_sibling_c = child;
 
        child->next_sibling = head;
        node->first_child = child;
    }

qualified_name()

PUGI__FN const char_t * qualified_name

(

const xpath_node &

node

)

Definition at line 8594 of file pugixml.cc.

    {
        return node.attribute() ? node.attribute().name() : node.node().name();
    }

Referenced by xpath_ast_node::eval_string(), and local_name().

remove_attribute()

void remove_attribute ( xml_attribute_struct * attr, xml_node_struct * node )

inline

Definition at line 1396 of file pugixml.cc.

    {
        xml_attribute_struct* next = attr->next_attribute;
        xml_attribute_struct* prev = attr->prev_attribute_c;
 
        if (next)
            next->prev_attribute_c = prev;
        else
            node->first_attribute->prev_attribute_c = prev;
 
        if (prev->next_attribute)
            prev->next_attribute = next;
        else
            node->first_attribute = next;
 
        attr->prev_attribute_c = 0;
        attr->next_attribute = 0;
    }

remove_node()

void remove_node ( xml_node_struct * node )

inline

Definition at line 1311 of file pugixml.cc.

    {
        xml_node_struct* parent = node->parent;
 
        xml_node_struct* next = node->next_sibling;
        xml_node_struct* prev = node->prev_sibling_c;
 
        if (next)
            next->prev_sibling_c = prev;
        else
            parent->first_child->prev_sibling_c = prev;
 
        if (prev->next_sibling)
            prev->next_sibling = next;
        else
            parent->first_child = next;
 
        node->parent = 0;
        node->prev_sibling_c = 0;
        node->next_sibling = 0;
    }

reverse()

template<typename I>

PUGI__FN void reverse	(	I	begin,
		I	end )

Definition at line 7586 of file pugixml.cc.

    {
        while (end - begin > 1)
            swap(*begin++, *--end);
    }

Referenced by pugi::xpath_node_set::sort(), and xpath_sort().

round_nearest()

PUGI__FN double round_nearest

(

double

value

)

Definition at line 8582 of file pugixml.cc.

    {
        return floor(value + 0.5);
    }

Referenced by xpath_ast_node::eval_string().

round_nearest_nzero()

PUGI__FN double round_nearest_nzero

(

double

value

)

Definition at line 8587 of file pugixml.cc.

    {
        // same as round_nearest, but returns -0 for [-0.5, -0]
        // ceil is used to differentiate between +0 and -0 (we return -0 for [-0.5, -0] and +0 for +0)
        return (value >= -0.5 && value <= 0) ? ceil(value) : floor(value + 0.5);
    }

Referenced by xpath_ast_node::eval_number().

save_file_impl()

PUGI__FN bool save_file_impl	(	const xml_document &	doc,
		FILE *	file,
		const char_t *	indent,
		unsigned int	flags,
		xml_encoding	encoding )

Definition at line 5066 of file pugixml.cc.

    {
        if (!file) return false;
 
        xml_writer_file writer(file);
        doc.save(writer, indent, flags, encoding);
 
        return fflush(file) == 0 && ferror(file) == 0;
    }

set_value_ascii()

template<typename String, typename Header>

PUGI__FN bool set_value_ascii	(	String &	dest,
		Header &	header,
		uintptr_t	header_mask,
		char *	buf )

Definition at line 4667 of file pugixml.cc.

    {
    #ifdef PUGIXML_WCHAR_MODE
        char_t wbuf[128];
        assert(strlen(buf) < sizeof(wbuf) / sizeof(wbuf[0]));
 
        size_t offset = 0;
        for (; buf[offset]; ++offset) wbuf[offset] = buf[offset];
 
        return strcpy_insitu(dest, header, header_mask, wbuf, offset);
    #else
        return strcpy_insitu(dest, header, header_mask, buf, strlen(buf));
    #endif
    }

Referenced by set_value_convert(), and set_value_convert().

set_value_bool()

template<typename String, typename Header>

PUGI__FN bool set_value_bool	(	String &	dest,
		Header &	header,
		uintptr_t	header_mask,
		bool	value )

Definition at line 4711 of file pugixml.cc.

    {
        return strcpy_insitu(dest, header, header_mask, value ? PUGIXML_TEXT("true") : PUGIXML_TEXT("false"), value ? 4 : 5);
    }

set_value_convert() [1/2]

template<typename String, typename Header>

PUGI__FN bool set_value_convert	(	String &	dest,
		Header &	header,
		uintptr_t	header_mask,
		double	value,
		int	precision )

Definition at line 4702 of file pugixml.cc.

    {
        char buf[128];
        PUGI__SNPRINTF(buf, "%.*g", precision, value);
 
        return set_value_ascii(dest, header, header_mask, buf);
    }

set_value_convert() [2/2]

template<typename String, typename Header>

PUGI__FN bool set_value_convert	(	String &	dest,
		Header &	header,
		uintptr_t	header_mask,
		float	value,
		int	precision )

Definition at line 4693 of file pugixml.cc.

    {
        char buf[128];
        PUGI__SNPRINTF(buf, "%.*g", precision, double(value));
 
        return set_value_ascii(dest, header, header_mask, buf);
    }

set_value_integer()

template<typename U, typename String, typename Header>

PUGI__FN bool set_value_integer	(	String &	dest,
		Header &	header,
		uintptr_t	header_mask,
		U	value,
		bool	negative )

Definition at line 4683 of file pugixml.cc.

    {
        char_t buf[64];
        char_t* end = buf + sizeof(buf) / sizeof(buf[0]);
        char_t* begin = integer_to_string(buf, end, value, negative);
 
        return strcpy_insitu(dest, header, header_mask, begin, end - begin);
    }

sort()

template<typename I, typename Pred>

PUGI__FN void sort	(	I	begin,
		I	end,
		const Pred &	pred )

Definition at line 7678 of file pugixml.cc.

    {
        // sort large chunks
        while (end - begin > 16)
        {
            // find median element
            I middle = begin + (end - begin) / 2;
            I median = median3(begin, middle, end - 1, pred);
 
            // partition in three chunks (< = >)
            I eqbeg, eqend;
            partition3(begin, end, *median, pred, &eqbeg, &eqend);
 
            // loop on larger half
            if (eqbeg - begin > end - eqend)
            {
                sort(eqend, end, pred);
                end = eqbeg;
            }
            else
            {
                sort(begin, eqbeg, pred);
                begin = eqend;
            }
        }
 
        // insertion sort small chunk
        insertion_sort(begin, end, pred);
    }

Referenced by G4gl2ps::beginPage(), __1DSortOut::Sort(), sort(), and xpath_sort().

starts_with()

PUGI__NS_END PUGI__NS_BEGIN PUGI__FN bool starts_with	(	const char_t *	string,
		const char_t *	pattern )

Definition at line 8082 of file pugixml.cc.

    {
        while (*pattern && *string == *pattern)
        {
            string++;
            pattern++;
        }
 
        return *pattern == 0;
    }

Referenced by xpath_ast_node::eval_boolean(), is_xpath_attribute(), and namespace_uri_predicate::operator()().

strconv_cdata()

PUGI__FN char_t * strconv_cdata	(	char_t *	s,
		char_t	endch )

Definition at line 2644 of file pugixml.cc.

    {
        gap g;
 
        while (true)
        {
            PUGI__SCANWHILE_UNROLL(!PUGI__IS_CHARTYPE(ss, ct_parse_cdata));
 
            if (*s == '\r') // Either a single 0x0d or 0x0d 0x0a pair
            {
                *s++ = '\n'; // replace first one with 0x0a
 
                if (*s == '\n') g.push(s, 1);
            }
            else if (s[0] == ']' && s[1] == ']' && PUGI__ENDSWITH(s[2], '>')) // CDATA ends here
            {
                *g.flush(s) = 0;
 
                return s + 1;
            }
            else if (*s == 0)
            {
                return 0;
            }
            else ++s;
        }
    }

Referenced by xml_parser::parse_exclamation().

strconv_comment()

PUGI__FN char_t * strconv_comment	(	char_t *	s,
		char_t	endch )

Definition at line 2616 of file pugixml.cc.

    {
        gap g;
 
        while (true)
        {
            PUGI__SCANWHILE_UNROLL(!PUGI__IS_CHARTYPE(ss, ct_parse_comment));
 
            if (*s == '\r') // Either a single 0x0d or 0x0d 0x0a pair
            {
                *s++ = '\n'; // replace first one with 0x0a
 
                if (*s == '\n') g.push(s, 1);
            }
            else if (s[0] == '-' && s[1] == '-' && PUGI__ENDSWITH(s[2], '>')) // comment ends here
            {
                *g.flush(s) = 0;
 
                return s + (s[2] == '>' ? 3 : 2);
            }
            else if (*s == 0)
            {
                return 0;
            }
            else ++s;
        }
    }

Referenced by xml_parser::parse_exclamation().

strconv_escape()

PUGI__FN char_t * strconv_escape	(	char_t *	s,
		gap &	g )

Definition at line 2463 of file pugixml.cc.

    {
        char_t* stre = s + 1;
 
        switch (*stre)
        {
            case '#':   // &#...
            {
                unsigned int ucsc = 0;
 
                if (stre[1] == 'x') // &#x... (hex code)
                {
                    stre += 2;
 
                    char_t ch = *stre;
 
                    if (ch == ';') return stre;
 
                    for (;;)
                    {
                        if (static_cast<unsigned int>(ch - '0') <= 9)
                            ucsc = 16 * ucsc + (ch - '0');
                        else if (static_cast<unsigned int>((ch | ' ') - 'a') <= 5)
                            ucsc = 16 * ucsc + ((ch | ' ') - 'a' + 10);
                        else if (ch == ';')
                            break;
                        else // cancel
                            return stre;
 
                        ch = *++stre;
                    }
 
                    ++stre;
                }
                else    // &#... (dec code)
                {
                    char_t ch = *++stre;
 
                    if (ch == ';') return stre;
 
                    for (;;)
                    {
                        if (static_cast<unsigned int>(ch - '0') <= 9)
                            ucsc = 10 * ucsc + (ch - '0');
                        else if (ch == ';')
                            break;
                        else // cancel
                            return stre;
 
                        ch = *++stre;
                    }
 
                    ++stre;
                }
 
            #ifdef PUGIXML_WCHAR_MODE
                s = reinterpret_cast<char_t*>(wchar_writer::any(reinterpret_cast<wchar_writer::value_type>(s), ucsc));
            #else
                s = reinterpret_cast<char_t*>(utf8_writer::any(reinterpret_cast<uint8_t*>(s), ucsc));
            #endif
 
                g.push(s, stre - s);
                return stre;
            }
 
            case 'a':   // &a
            {
                ++stre;
 
                if (*stre == 'm') // &am
                {
                    if (*++stre == 'p' && *++stre == ';') // &amp;
                    {
                        *s++ = '&';
                        ++stre;
 
                        g.push(s, stre - s);
                        return stre;
                    }
                }
                else if (*stre == 'p') // &ap
                {
                    if (*++stre == 'o' && *++stre == 's' && *++stre == ';') // &apos;
                    {
                        *s++ = '\'';
                        ++stre;
 
                        g.push(s, stre - s);
                        return stre;
                    }
                }
                break;
            }
 
            case 'g': // &g
            {
                if (*++stre == 't' && *++stre == ';') // &gt;
                {
                    *s++ = '>';
                    ++stre;
 
                    g.push(s, stre - s);
                    return stre;
                }
                break;
            }
 
            case 'l': // &l
            {
                if (*++stre == 't' && *++stre == ';') // &lt;
                {
                    *s++ = '<';
                    ++stre;
 
                    g.push(s, stre - s);
                    return stre;
                }
                break;
            }
 
            case 'q': // &q
            {
                if (*++stre == 'u' && *++stre == 'o' && *++stre == 't' && *++stre == ';') // &quot;
                {
                    *s++ = '"';
                    ++stre;
 
                    g.push(s, stre - s);
                    return stre;
                }
                break;
            }
 
            default:
                break;
        }
 
        return stre;
    }

Referenced by strconv_pcdata_impl< opt_trim, opt_eol, opt_escape >::parse(), strconv_attribute_impl< opt_escape >::parse_eol(), strconv_attribute_impl< opt_escape >::parse_simple(), strconv_attribute_impl< opt_escape >::parse_wconv(), and strconv_attribute_impl< opt_escape >::parse_wnorm().

strcpy_insitu()

template<typename String, typename Header>

PUGI__FN bool strcpy_insitu	(	String &	dest,
		Header &	header,
		uintptr_t	header_mask,
		const char_t *	source,
		size_t	source_length )

Definition at line 2373 of file pugixml.cc.

    {
        if (source_length == 0)
        {
            // empty string and null pointer are equivalent, so just deallocate old memory
            xml_allocator* alloc = PUGI__GETPAGE_IMPL(header)->allocator;
 
            if (header & header_mask) alloc->deallocate_string(dest);
 
            // mark the string as not allocated
            dest = 0;
            header &= ~header_mask;
 
            return true;
        }
        else if (dest && strcpy_insitu_allow(source_length, header, header_mask, dest))
        {
            // we can reuse old buffer, so just copy the new data (including zero terminator)
            memcpy(dest, source, source_length * sizeof(char_t));
            dest[source_length] = 0;
 
            return true;
        }
        else
        {
            xml_allocator* alloc = PUGI__GETPAGE_IMPL(header)->allocator;
 
            if (!alloc->reserve()) return false;
 
            // allocate new buffer
            char_t* buf = alloc->allocate_string(source_length + 1);
            if (!buf) return false;
 
            // copy the string (including zero terminator)
            memcpy(buf, source, source_length * sizeof(char_t));
            buf[source_length] = 0;
 
            // deallocate old buffer (*after* the above to protect against overlapping memory and/or allocation failures)
            if (header & header_mask) alloc->deallocate_string(dest);
 
            // the string is now allocated, so set the flag
            dest = buf;
            header |= header_mask;
 
            return true;
        }
    }

Referenced by node_copy_string(), set_value_ascii(), set_value_bool(), and set_value_integer().

strcpy_insitu_allow()

template<typename Header>

bool strcpy_insitu_allow ( size_t length, const Header & header, uintptr_t header_mask, char_t * target )

inline

Definition at line 2356 of file pugixml.cc.

    {
        // never reuse shared memory
        if (header & xml_memory_page_contents_shared_mask) return false;
 
        size_t target_length = strlength(target);
 
        // always reuse document buffer memory if possible
        if ((header & header_mask) == 0) return target_length >= length;
 
        // reuse heap memory if waste is not too great
        const size_t reuse_threshold = 32;
 
        return target_length >= length && (target_length < reuse_threshold || target_length - length < target_length / 2);
    }

Referenced by strcpy_insitu().

strequal()

PUGI__FN bool strequal	(	const char_t *	src,
		const char_t *	dst )

Definition at line 226 of file pugixml.cc.

    {
        assert(src && dst);
 
    #ifdef PUGIXML_WCHAR_MODE
        return wcscmp(src, dst) == 0;
    #else
        return strcmp(src, dst) == 0;
    #endif
    }

Referenced by xpath_ast_node::eval_boolean(), xpath_string::operator!=(), and xpath_string::operator==().

strequalrange()

PUGI__FN bool strequalrange	(	const char_t *	lhs,
		const char_t *	rhs,
		size_t	count )

Definition at line 238 of file pugixml.cc.

    {
        for (size_t i = 0; i < count; ++i)
            if (lhs[i] != rhs[i])
                return false;
 
        return lhs[count] == 0;
    }

Referenced by namespace_uri_predicate::operator()(), and xpath_lexer_string::operator==().

string_to_integer()

template<typename U>

PUGI__FN PUGI__UNSIGNED_OVERFLOW U string_to_integer	(	const char_t *	value,
		U	minv,
		U	maxv )

Definition at line 4514 of file pugixml.cc.

    {
        U result = 0;
        const char_t* s = value;
 
        while (PUGI__IS_CHARTYPE(*s, ct_space))
            s++;
 
        bool negative = (*s == '-');
 
        s += (*s == '+' || *s == '-');
 
        bool overflow = false;
 
        if (s[0] == '0' && (s[1] | ' ') == 'x')
        {
            s += 2;
 
            // since overflow detection relies on length of the sequence skip leading zeros
            while (*s == '0')
                s++;
 
            const char_t* start = s;
 
            for (;;)
            {
                if (static_cast<unsigned>(*s - '0') < 10)
                    result = result * 16 + (*s - '0');
                else if (static_cast<unsigned>((*s | ' ') - 'a') < 6)
                    result = result * 16 + ((*s | ' ') - 'a' + 10);
                else
                    break;
 
                s++;
            }
 
            size_t digits = static_cast<size_t>(s - start);
 
            overflow = digits > sizeof(U) * 2;
        }
        else
        {
            // since overflow detection relies on length of the sequence skip leading zeros
            while (*s == '0')
                s++;
 
            const char_t* start = s;
 
            for (;;)
            {
                if (static_cast<unsigned>(*s - '0') < 10)
                    result = result * 10 + (*s - '0');
                else
                    break;
 
                s++;
            }
 
            size_t digits = static_cast<size_t>(s - start);
 
            PUGI__STATIC_ASSERT(sizeof(U) == 8 || sizeof(U) == 4 || sizeof(U) == 2);
 
            const size_t max_digits10 = sizeof(U) == 8 ? 20 : sizeof(U) == 4 ? 10 : 5;
            const char_t max_lead = sizeof(U) == 8 ? '1' : sizeof(U) == 4 ? '4' : '6';
            const size_t high_bit = sizeof(U) * 8 - 1;
 
            overflow = digits >= max_digits10 && !(digits == max_digits10 && (*start < max_lead || (*start == max_lead && result >> high_bit)));
        }
 
        if (negative)
        {
            // Workaround for crayc++ CC-3059: Expected no overflow in routine.
        #ifdef _CRAYC
            return (overflow || result > ~minv + 1) ? minv : ~result + 1;
        #else
            return (overflow || result > 0 - minv) ? minv : 0 - result;
        #endif
        }
        else
            return (overflow || result > maxv) ? maxv : result;
    }

Referenced by get_value_int(), and get_value_uint().

string_value()

PUGI__FN xpath_string string_value	(	const xpath_node &	na,
		xpath_allocator *	alloc )

Definition at line 8118 of file pugixml.cc.

    {
        if (na.attribute())
            return xpath_string::from_const(na.attribute().value());
        else
        {
            xml_node n = na.node();
 
            switch (n.type())
            {
            case node_pcdata:
            case node_cdata:
            case node_comment:
            case node_pi:
                return xpath_string::from_const(n.value());
 
            case node_document:
            case node_element:
            {
                xpath_string result;
 
                // element nodes can have value if parse_embed_pcdata was used
                if (n.value()[0])
                    result.append(xpath_string::from_const(n.value()), alloc);
 
                xml_node cur = n.first_child();
 
                while (cur && cur != n)
                {
                    if (cur.type() == node_pcdata || cur.type() == node_cdata)
                        result.append(xpath_string::from_const(cur.value()), alloc);
 
                    if (cur.first_child())
                        cur = cur.first_child();
                    else if (cur.next_sibling())
                        cur = cur.next_sibling();
                    else
                    {
                        while (!cur.next_sibling() && cur != n)
                            cur = cur.parent();
 
                        if (cur != n) cur = cur.next_sibling();
                    }
                }
 
                return result;
            }
 
            default:
                return xpath_string();
            }
        }
    }

Referenced by xpath_ast_node::eval_number(), and xpath_ast_node::eval_string().

strlength()

PUGI__NS_END PUGI__NS_BEGIN PUGI__FN size_t strlength

(

const char_t *

s

)

Definition at line 214 of file pugixml.cc.

    {
        assert(s);
 
    #ifdef PUGIXML_WCHAR_MODE
        return wcslen(s);
    #else
        return strlen(s);
    #endif
    }

Referenced by xpath_string::data(), xpath_string::length(), new_xpath_variable(), node_copy_string(), node_output(), strcpy_insitu_allow(), and xml_buffered_writer::write_string().

strlength_wide()

PUGI__FN size_t strlength_wide

(

const wchar_t *

s

)

Definition at line 248 of file pugixml.cc.

    {
        assert(s);
 
    #ifdef PUGIXML_WCHAR_MODE
        return wcslen(s);
    #else
        const wchar_t* end = s;
        while (*end) end++;
        return static_cast<size_t>(end - s);
    #endif
    }

Referenced by convert_path_heap().

swap()

template<typename T>

void swap ( T & lhs, T & rhs )

inline

Definition at line 7568 of file pugixml.cc.

    {
        T temp = lhs;
        lhs = rhs;
        rhs = temp;
    }

Referenced by median3(), partition3(), reverse(), and G4OpBoundaryProcess::~G4OpBoundaryProcess().

text_output()

PUGI__FN void text_output	(	xml_buffered_writer &	writer,
		const char_t *	s,
		chartypex_t	type,
		unsigned int	flags )

Definition at line 3975 of file pugixml.cc.

    {
        if (flags & format_no_escapes)
            writer.write_string(s);
        else
            text_output_escaped(writer, s, type, flags);
    }

Referenced by node_output_attributes(), node_output_simple(), and node_output_start().

text_output_cdata()

PUGI__FN void text_output_cdata	(	xml_buffered_writer &	writer,
		const char_t *	s )

Definition at line 3983 of file pugixml.cc.

    {
        do
        {
            writer.write('<', '!', '[', 'C', 'D');
            writer.write('A', 'T', 'A', '[');
 
            const char_t* prev = s;
 
            // look for ]]> sequence - we can't output it as is since it terminates CDATA
            while (*s && !(s[0] == ']' && s[1] == ']' && s[2] == '>')) ++s;
 
            // skip ]] if we stopped at ]]>, > will go to the next CDATA section
            if (*s) s += 2;
 
            writer.write_buffer(prev, static_cast<size_t>(s - prev));
 
            writer.write(']', ']', '>');
        }
        while (*s);
    }

Referenced by node_output_simple().

text_output_escaped()

PUGI__FN void text_output_escaped	(	xml_buffered_writer &	writer,
		const char_t *	s,
		chartypex_t	type,
		unsigned int	flags )

Definition at line 3923 of file pugixml.cc.

    {
        while (*s)
        {
            const char_t* prev = s;
 
            // While *s is a usual symbol
            PUGI__SCANWHILE_UNROLL(!PUGI__IS_CHARTYPEX(ss, type));
 
            writer.write_buffer(prev, static_cast<size_t>(s - prev));
 
            switch (*s)
            {
                case 0: break;
                case '&':
                    writer.write('&', 'a', 'm', 'p', ';');
                    ++s;
                    break;
                case '<':
                    writer.write('&', 'l', 't', ';');
                    ++s;
                    break;
                case '>':
                    writer.write('&', 'g', 't', ';');
                    ++s;
                    break;
                case '"':
                    if (flags & format_attribute_single_quote)
                        writer.write('"');
                    else
                        writer.write('&', 'q', 'u', 'o', 't', ';');
                    ++s;
                    break;
                case '\'':
                    if (flags & format_attribute_single_quote)
                        writer.write('&', 'a', 'p', 'o', 's', ';');
                    else
                        writer.write('\'');
                    ++s;
                    break;
                default: // s is not a usual symbol
                {
                    unsigned int ch = static_cast<unsigned int>(*s++);
                    assert(ch < 32);
 
                    if (!(flags & format_skip_control_chars))
                        writer.write('&', '#', static_cast<char_t>((ch / 10) + '0'), static_cast<char_t>((ch % 10) + '0'), ';');
                }
            }
        }
    }

Referenced by text_output().

text_output_indent()

PUGI__FN void text_output_indent	(	xml_buffered_writer &	writer,
		const char_t *	indent,
		size_t	indent_length,
		unsigned int	depth )

Definition at line 4005 of file pugixml.cc.

    {
        switch (indent_length)
        {
        case 1:
        {
            for (unsigned int i = 0; i < depth; ++i)
                writer.write(indent[0]);
            break;
        }
 
        case 2:
        {
            for (unsigned int i = 0; i < depth; ++i)
                writer.write(indent[0], indent[1]);
            break;
        }
 
        case 3:
        {
            for (unsigned int i = 0; i < depth; ++i)
                writer.write(indent[0], indent[1], indent[2]);
            break;
        }
 
        case 4:
        {
            for (unsigned int i = 0; i < depth; ++i)
                writer.write(indent[0], indent[1], indent[2], indent[3]);
            break;
        }
 
        default:
        {
            for (unsigned int i = 0; i < depth; ++i)
                writer.write_buffer(indent, indent_length);
        }
        }
    }

Referenced by node_output(), and node_output_attributes().

tolower_ascii()

PUGI__FN char_t tolower_ascii

(

char_t

ch

)

Definition at line 8113 of file pugixml.cc.

    {
        return static_cast<unsigned int>(ch - 'A') < 26 ? static_cast<char_t>(ch | ' ') : ch;
    }

Referenced by xpath_ast_node::eval_boolean().

translate()

PUGI__FN char_t * translate	(	char_t *	buffer,
		const char_t *	from,
		const char_t *	to,
		size_t	to_length )

Definition at line 8702 of file pugixml.cc.

    {
        char_t* write = buffer;
 
        while (*buffer)
        {
            PUGI__DMC_VOLATILE char_t ch = *buffer++;
 
            const char_t* pos = find_char(from, ch);
 
            if (!pos)
                *write++ = ch; // do not process
            else if (static_cast<size_t>(pos - from) < to_length)
                *write++ = to[pos - from]; // replace
        }
 
        // zero-terminate
        *write = 0;
 
        return write;
    }

Referenced by xpath_ast_node::eval_string(), G4GDMLWriteStructure::PhysvolWrite(), and G4GDMLWriteStructure::TraverseVolumeTree().

translate_table()

PUGI__FN char_t * translate_table	(	char_t *	buffer,
		const unsigned char *	table )

Definition at line 8756 of file pugixml.cc.

    {
        char_t* write = buffer;
 
        while (*buffer)
        {
            char_t ch = *buffer++;
            unsigned int index = static_cast<unsigned int>(ch);
 
            if (index < 128)
            {
                unsigned char code = table[index];
 
                // code=128 means "skip character" (table size is 128 so 128 can be a special value)
                // this code skips these characters without extra branches
                *write = static_cast<char_t>(code);
                write += 1 - (code >> 7);
            }
            else
            {
                *write++ = ch;
            }
        }
 
        // zero-terminate
        *write = 0;
 
        return write;
    }

Referenced by xpath_ast_node::eval_string().

translate_table_generate()

PUGI__FN unsigned char * translate_table_generate	(	xpath_allocator *	alloc,
		const char_t *	from,
		const char_t *	to )

Definition at line 8724 of file pugixml.cc.

    {
        unsigned char table[128] = {0};
 
        while (*from)
        {
            unsigned int fc = static_cast<unsigned int>(*from);
            unsigned int tc = static_cast<unsigned int>(*to);
 
            if (fc >= 128 || tc >= 128)
                return 0;
 
            // code=128 means "skip character"
            if (!table[fc])
                table[fc] = static_cast<unsigned char>(tc ? tc : 128);
 
            from++;
            if (tc) to++;
        }
 
        for (int i = 0; i < 128; ++i)
            if (!table[i])
                table[i] = static_cast<unsigned char>(i);
 
        void* result = alloc->allocate(sizeof(table));
        if (!result) return 0;
 
        memcpy(result, table, sizeof(table));
 
        return static_cast<unsigned char*>(result);
    }

Referenced by xpath_ast_node::optimize_self().

truncate_zeros()

PUGI__FN void truncate_zeros	(	char *	begin,
		char *	end )

Definition at line 8396 of file pugixml.cc.

    {
        while (begin != end && end[-1] == '0') end--;
 
        *end = 0;
    }

Referenced by convert_number_to_mantissa_exponent().

unique()

template<typename I>

PUGI__FN I unique	(	I	begin,
		I	end )

Definition at line 7592 of file pugixml.cc.

    {
        // fast skip head
        while (end - begin > 1 && *begin != *(begin + 1))
            begin++;
 
        if (begin == end)
            return begin;
 
        // last written element
        I write = begin++;
 
        // merge unique elements
        while (begin != end)
        {
            if (*begin != *write)
                *++write = *begin++;
            else
                begin++;
        }
 
        // past-the-end (write points to live element)
        return write + 1;
    }

Referenced by G4Region::GetParentRegion(), G4Region::GetWorldPhysical(), G4FastSimulationManager::ListModels(), and xpath_node_set_raw::remove_duplicates().

xpath_first()

PUGI__FN xpath_node xpath_first	(	const xpath_node *	begin,
		const xpath_node *	end,
		xpath_node_set::type_t	type )

Definition at line 9013 of file pugixml.cc.

    {
        if (begin == end) return xpath_node();
 
        switch (type)
        {
        case xpath_node_set::type_sorted:
            return *begin;
 
        case xpath_node_set::type_sorted_reverse:
            return *(end - 1);
 
        case xpath_node_set::type_unsorted:
            return *min_element(begin, end, document_order_comparator());
 
        default:
            assert(false && "Invalid node set type"); // unreachable
            return xpath_node();
        }
    }

Referenced by xpath_node_set_raw::first().

xpath_get_order()

PUGI__NS_END PUGI__NS_BEGIN PUGI__FN xpath_node_set::type_t xpath_get_order	(	const xpath_node *	begin,
		const xpath_node *	end )

Definition at line 8974 of file pugixml.cc.

    {
        if (end - begin < 2)
            return xpath_node_set::type_sorted;
 
        document_order_comparator cmp;
 
        bool first = cmp(begin[0], begin[1]);
 
        for (const xpath_node* it = begin + 1; it + 1 < end; ++it)
            if (cmp(it[0], it[1]) != first)
                return xpath_node_set::type_unsorted;
 
        return first ? xpath_node_set::type_sorted : xpath_node_set::type_sorted_reverse;
    }

Referenced by xpath_sort().

xpath_sort()

PUGI__FN xpath_node_set::type_t xpath_sort	(	xpath_node *	begin,
		xpath_node *	end,
		xpath_node_set::type_t	type,
		bool	rev )

Definition at line 8990 of file pugixml.cc.

    {
        xpath_node_set::type_t order = rev ? xpath_node_set::type_sorted_reverse : xpath_node_set::type_sorted;
 
        if (type == xpath_node_set::type_unsorted)
        {
            xpath_node_set::type_t sorted = xpath_get_order(begin, end);
 
            if (sorted == xpath_node_set::type_unsorted)
            {
                sort(begin, end, document_order_comparator());
 
                type = xpath_node_set::type_sorted;
            }
            else
                type = sorted;
        }
 
        if (type != order) reverse(begin, end);
 
        return order;
    }

Referenced by xpath_node_set_raw::sort_do().

zero_terminate_buffer()

PUGI__FN size_t zero_terminate_buffer	(	void *	buffer,
		size_t	size,
		xml_encoding	encoding )

Definition at line 4796 of file pugixml.cc.

    {
        // We only need to zero-terminate if encoding conversion does not do it for us
    #ifdef PUGIXML_WCHAR_MODE
        xml_encoding wchar_encoding = get_wchar_encoding();
 
        if (encoding == wchar_encoding || need_endian_swap_utf(encoding, wchar_encoding))
        {
            size_t length = size / sizeof(char_t);
 
            static_cast<char_t*>(buffer)[length] = 0;
            return (length + 1) * sizeof(char_t);
        }
    #else
        if (encoding == encoding_utf8)
        {
            static_cast<char*>(buffer)[size] = 0;
            return size + 1;
        }
    #endif
 
        return size;
    }

Referenced by load_file_impl(), and load_stream_impl().

Variable Documentation

axis_to_type< N >::axis

template<axis_t N>

const axis_t axis_to_type< N >::axis = N

Definition at line 9668 of file pugixml.cc.

Referenced by G4GMocrenFileSceneHandler::AddSolid(), xpath_parser::alloc_node(), G4AffineTransform::ApplyAxisTransform(), GIDI::Axes::Axes(), G4GDMLReadStructure::AxisRead(), CLHEP::Hep3Vector::azimAngle(), G4ClippablePolygon::BehindOf(), CLHEP::boostOf(), CLHEP::HepLorentzVector::boostOf, G4tgbVolume::BuildSolidForDivision(), G4PolyconeSide::CalculateExtent(), G4PolyhedraSide::CalculateExtent(), G4PolyPhiFace::CalculateExtent(), G4VCSGface::CalculateExtent(), G4VCSGfaceted::CalculateExtent(), G4VExternalPhysicalVolume::CheckOverlaps(), G4ClippablePolygon::ClipAlongOneAxis(), MCGIDI::Distributions::CoherentElasticTNSL::CoherentElasticTNSL(), G4ParameterisedNavigation::ComputeSafety(), G4ParameterisedNavigation::ComputeStep(), G4ReplicaNavigation::ComputeTransformation(), G4ReplicaNavigation::ComputeTransformation(), G4PVDivisionFactory::CreatePVDivision(), CLHEP::HepLorentzVector::delta2Euclidean(), G4Voxelizer::DisplayBoundaries(), G4Voxelizer::DisplayListNodes(), G4ReplicaNavigation::DistanceToOut(), G4ReplicaNavigation::DistanceToOut(), G4ReflectionFactory::Divide(), G4ReflectionFactory::Divide(), G4ReflectionFactory::Divide(), G4GDMLReadStructure::DivisionvolRead(), G4GDMLWriteStructure::DivisionvolWrite(), G4tgbGeometryDumper::DumpPVParameterised(), G4tgbGeometryDumper::DumpPVReplica(), G4ClippablePolygon::Empty(), G4PolyconeSide::Extent(), G4PolyhedraSide::Extent(), G4PolyPhiFace::Extent(), G4QuadrangularFacet::Extent(), G4TriangularFacet::Extent(), G4VCSGface::Extent(), G4VFacet::Extent(), G4ParameterisationBoxX::G4ParameterisationBoxX(), G4ParameterisationBoxY::G4ParameterisationBoxY(), G4ParameterisationBoxZ::G4ParameterisationBoxZ(), G4ParameterisationConsPhi::G4ParameterisationConsPhi(), G4ParameterisationConsRho::G4ParameterisationConsRho(), G4ParameterisationConsZ::G4ParameterisationConsZ(), G4ParameterisationParaX::G4ParameterisationParaX(), G4ParameterisationParaY::G4ParameterisationParaY(), G4ParameterisationParaZ::G4ParameterisationParaZ(), G4ParameterisationPolyconePhi::G4ParameterisationPolyconePhi(), G4ParameterisationPolyconeRho::G4ParameterisationPolyconeRho(), G4ParameterisationPolyconeZ::G4ParameterisationPolyconeZ(), G4ParameterisationPolyhedraPhi::G4ParameterisationPolyhedraPhi(), G4ParameterisationPolyhedraRho::G4ParameterisationPolyhedraRho(), G4ParameterisationPolyhedraZ::G4ParameterisationPolyhedraZ(), G4ParameterisationTrdX::G4ParameterisationTrdX(), G4ParameterisationTrdY::G4ParameterisationTrdY(), G4ParameterisationTrdZ::G4ParameterisationTrdZ(), G4ParameterisationTubsPhi::G4ParameterisationTubsPhi(), G4ParameterisationTubsRho::G4ParameterisationTubsRho(), G4ParameterisationTubsZ::G4ParameterisationTubsZ(), G4VDivisionParameterisation::G4VDivisionParameterisation(), G4VParameterisationBox::G4VParameterisationBox(), G4VParameterisationCons::G4VParameterisationCons(), G4VParameterisationPara::G4VParameterisationPara(), G4VParameterisationPolycone::G4VParameterisationPolycone(), G4VParameterisationPolyhedra::G4VParameterisationPolyhedra(), G4VParameterisationTrd::G4VParameterisationTrd(), G4VParameterisationTubs::G4VParameterisationTubs(), G4VTwistSurface::GetBoundaryAxis(), G4VTwistSurface::GetCorner(), G4ClippablePolygon::GetExtent(), G4VCSGfaceted::GetExtent(), G4HnInformation::GetIsLogAxis(), G4ClippablePolygon::GetMaxPoint(), G4ClippablePolygon::GetMinPoint(), GetRegularStructureId(), G4PVParameterised::GetReplicationData(), G4VPhysicalVolume::GetReplicationData(), GetReplicationData(), G4Voxelizer::GetTotalCandidates(), GIDI::Functions::Gridded1d::Gridded1d(), MCGIDI::Distributions::IncoherentElasticTNSL::IncoherentElasticTNSL(), G4ClippablePolygon::InFrontOf(), G4ReplicaNavigation::Inside(), G4AffineTransform::InverseTransformAxis(), G4OpenInventorQtExaminerViewer::loadViewPts(), G4OpenInventorXtExaminerViewer::loadViewPts(), G4ReflectionFactory::operator=(), GIDI::Axes::operator=(), xpath_parser::parse_step(), G4GDMLReadStructure::ReplicaRead(), G4ReflectionFactory::Replicate(), G4GDMLWriteStructure::ReplicavolWrite(), G4ASCIITreeSceneHandler::RequestPrimitives(), CLHEP::Hep3Vector::rotate(), CLHEP::HepLorentzRotation::rotate(), CLHEP::HepLorentzRotation::rotate(), G4INCL::ThreeVector::rotate(), G4INCL::Cluster::rotateMomentum(), G4INCL::Particle::rotateMomentum(), G4INCL::ParticleList::rotateMomentum(), G4INCL::Cluster::rotatePosition(), G4INCL::Particle::rotatePosition(), G4INCL::ParticleList::rotatePosition(), G4INCL::Particle::rotatePositionAndMomentum(), G4INCL::ParticleList::rotatePositionAndMomentum(), CLHEP::rotationOf(), G4OpenInventorQtExaminerViewer::saveViewPt(), G4tgrPlaceDivRep::SetAxis(), G4VTwistSurface::SetAxis(), G4tgbVolume::SetCutsInEnergy(), G4HnInformation::SetIsLogAxis(), G4ClippablePolygon::SetNormal(), G4OpenInventorQtExaminerViewer::sortViewPts(), G4AffineTransform::TransformAxis(), G4PhysicalVolumeModel::VisitGeometryAndGetVisReps(), xpath_ast_node::xpath_ast_node(), G4PVParameterised::~G4PVParameterised(), and G4QuadrangularFacet::~G4QuadrangularFacet().

xml_memory_management_function_storage< T >::allocate

template<typename T>

allocation_function xml_memory_management_function_storage< T >::allocate = default_allocate

Definition at line 205 of file pugixml.cc.

Referenced by G4VTHitsMap< T, Map_t >::add(), G4VTHitsMap< T, Map_t >::add(), xpath_allocator::reallocate(), G4VTHitsMap< T, Map_t >::set(), G4VTHitsMap< T, Map_t >::set(), and pugi::set_memory_management_functions().

xml_memory_management_function_storage< T >::deallocate

template<typename T>

deallocation_function xml_memory_management_function_storage< T >::deallocate = default_deallocate

Definition at line 206 of file pugixml.cc.

Referenced by pugi::set_memory_management_functions().