140 lines
		
	
	
		
			6.2 KiB
		
	
	
	
		
			Plaintext
		
	
	
	
	
	
		
		
			
		
	
	
			140 lines
		
	
	
		
			6.2 KiB
		
	
	
	
		
			Plaintext
		
	
	
	
	
	
| 
								 | 
							
								/*
							 | 
						||
| 
								 | 
							
								 *
							 | 
						||
| 
								 | 
							
								 * Copyright (c) 1998-2002
							 | 
						||
| 
								 | 
							
								 * John Maddock
							 | 
						||
| 
								 | 
							
								 *
							 | 
						||
| 
								 | 
							
								 * Use, modification and distribution are subject to the 
							 | 
						||
| 
								 | 
							
								 * Boost Software License, Version 1.0. (See accompanying file 
							 | 
						||
| 
								 | 
							
								 * LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
							 | 
						||
| 
								 | 
							
								 *
							 | 
						||
| 
								 | 
							
								 */
							 | 
						||
| 
								 | 
							
								 
							 | 
						||
| 
								 | 
							
								 /*
							 | 
						||
| 
								 | 
							
								  *   LOCATION:    see http://www.boost.org for most recent version.
							 | 
						||
| 
								 | 
							
								  *   FILE         match_flags.hpp
							 | 
						||
| 
								 | 
							
								  *   VERSION      see <boost/version.hpp>
							 | 
						||
| 
								 | 
							
								  *   DESCRIPTION: Declares match_flags type.
							 | 
						||
| 
								 | 
							
								  */
							 | 
						||
| 
								 | 
							
								
							 | 
						||
| 
								 | 
							
								#ifndef BOOST_REGEX_V4_MATCH_FLAGS
							 | 
						||
| 
								 | 
							
								#define BOOST_REGEX_V4_MATCH_FLAGS
							 | 
						||
| 
								 | 
							
								
							 | 
						||
| 
								 | 
							
								#ifdef __cplusplus
							 | 
						||
| 
								 | 
							
								#  include <boost/cstdint.hpp>
							 | 
						||
| 
								 | 
							
								#endif
							 | 
						||
| 
								 | 
							
								#include <boost/detail/workaround.hpp>
							 | 
						||
| 
								 | 
							
								
							 | 
						||
| 
								 | 
							
								#ifdef __cplusplus
							 | 
						||
| 
								 | 
							
								namespace boost{
							 | 
						||
| 
								 | 
							
								   namespace regex_constants{
							 | 
						||
| 
								 | 
							
								#endif
							 | 
						||
| 
								 | 
							
								
							 | 
						||
| 
								 | 
							
								typedef enum _match_flags
							 | 
						||
| 
								 | 
							
								{
							 | 
						||
| 
								 | 
							
								   match_default = 0,
							 | 
						||
| 
								 | 
							
								   match_not_bol = 1,                                /* first is not start of line */
							 | 
						||
| 
								 | 
							
								   match_not_eol = match_not_bol << 1,               /* last is not end of line */
							 | 
						||
| 
								 | 
							
								   match_not_bob = match_not_eol << 1,               /* first is not start of buffer */
							 | 
						||
| 
								 | 
							
								   match_not_eob = match_not_bob << 1,               /* last is not end of buffer */
							 | 
						||
| 
								 | 
							
								   match_not_bow = match_not_eob << 1,               /* first is not start of word */
							 | 
						||
| 
								 | 
							
								   match_not_eow = match_not_bow << 1,               /* last is not end of word */
							 | 
						||
| 
								 | 
							
								   match_not_dot_newline = match_not_eow << 1,       /* \n is not matched by '.' */
							 | 
						||
| 
								 | 
							
								   match_not_dot_null = match_not_dot_newline << 1,  /* '\0' is not matched by '.' */
							 | 
						||
| 
								 | 
							
								   match_prev_avail = match_not_dot_null << 1,       /* *--first is a valid expression */
							 | 
						||
| 
								 | 
							
								   match_init = match_prev_avail << 1,               /* internal use */
							 | 
						||
| 
								 | 
							
								   match_any = match_init << 1,                      /* don't care what we match */
							 | 
						||
| 
								 | 
							
								   match_not_null = match_any << 1,                  /* string can't be null */
							 | 
						||
| 
								 | 
							
								   match_continuous = match_not_null << 1,           /* each grep match must continue from */
							 | 
						||
| 
								 | 
							
								                                                     /* uninterupted from the previous one */
							 | 
						||
| 
								 | 
							
								   match_partial = match_continuous << 1,            /* find partial matches */
							 | 
						||
| 
								 | 
							
								   
							 | 
						||
| 
								 | 
							
								   match_stop = match_partial << 1,                  /* stop after first match (grep) V3 only */
							 | 
						||
| 
								 | 
							
								   match_not_initial_null = match_stop,              /* don't match initial null, V4 only */
							 | 
						||
| 
								 | 
							
								   match_all = match_stop << 1,                      /* must find the whole of input even if match_any is set */
							 | 
						||
| 
								 | 
							
								   match_perl = match_all << 1,                      /* Use perl matching rules */
							 | 
						||
| 
								 | 
							
								   match_posix = match_perl << 1,                    /* Use POSIX matching rules */
							 | 
						||
| 
								 | 
							
								   match_nosubs = match_posix << 1,                  /* don't trap marked subs */
							 | 
						||
| 
								 | 
							
								   match_extra = match_nosubs << 1,                  /* include full capture information for repeated captures */
							 | 
						||
| 
								 | 
							
								   match_single_line = match_extra << 1,             /* treat text as single line and ignor any \n's when matching ^ and $. */
							 | 
						||
| 
								 | 
							
								   match_unused1 = match_single_line << 1,           /* unused */
							 | 
						||
| 
								 | 
							
								   match_unused2 = match_unused1 << 1,               /* unused */
							 | 
						||
| 
								 | 
							
								   match_unused3 = match_unused2 << 1,               /* unused */
							 | 
						||
| 
								 | 
							
								   match_max = match_unused3,
							 | 
						||
| 
								 | 
							
								
							 | 
						||
| 
								 | 
							
								   format_perl = 0,                                  /* perl style replacement */
							 | 
						||
| 
								 | 
							
								   format_default = 0,                               /* ditto. */
							 | 
						||
| 
								 | 
							
								   format_sed = match_max << 1,                      /* sed style replacement. */
							 | 
						||
| 
								 | 
							
								   format_all = format_sed << 1,                     /* enable all extentions to sytax. */
							 | 
						||
| 
								 | 
							
								   format_no_copy = format_all << 1,                 /* don't copy non-matching segments. */
							 | 
						||
| 
								 | 
							
								   format_first_only = format_no_copy << 1,          /* Only replace first occurance. */
							 | 
						||
| 
								 | 
							
								   format_is_if = format_first_only << 1,            /* internal use only. */
							 | 
						||
| 
								 | 
							
								   format_literal = format_is_if << 1                /* treat string as a literal */
							 | 
						||
| 
								 | 
							
								
							 | 
						||
| 
								 | 
							
								} match_flags;
							 | 
						||
| 
								 | 
							
								
							 | 
						||
| 
								 | 
							
								#if defined(__BORLANDC__) || BOOST_WORKAROUND(BOOST_MSVC, <= 1310)
							 | 
						||
| 
								 | 
							
								typedef unsigned long match_flag_type;
							 | 
						||
| 
								 | 
							
								#else
							 | 
						||
| 
								 | 
							
								typedef match_flags match_flag_type;
							 | 
						||
| 
								 | 
							
								
							 | 
						||
| 
								 | 
							
								
							 | 
						||
| 
								 | 
							
								#ifdef __cplusplus
							 | 
						||
| 
								 | 
							
								inline match_flags operator&(match_flags m1, match_flags m2)
							 | 
						||
| 
								 | 
							
								{ return static_cast<match_flags>(static_cast<boost::int32_t>(m1) & static_cast<boost::int32_t>(m2)); }
							 | 
						||
| 
								 | 
							
								inline match_flags operator|(match_flags m1, match_flags m2)
							 | 
						||
| 
								 | 
							
								{ return static_cast<match_flags>(static_cast<boost::int32_t>(m1) | static_cast<boost::int32_t>(m2)); }
							 | 
						||
| 
								 | 
							
								inline match_flags operator^(match_flags m1, match_flags m2)
							 | 
						||
| 
								 | 
							
								{ return static_cast<match_flags>(static_cast<boost::int32_t>(m1) ^ static_cast<boost::int32_t>(m2)); }
							 | 
						||
| 
								 | 
							
								inline match_flags operator~(match_flags m1)
							 | 
						||
| 
								 | 
							
								{ return static_cast<match_flags>(~static_cast<boost::int32_t>(m1)); }
							 | 
						||
| 
								 | 
							
								inline match_flags& operator&=(match_flags& m1, match_flags m2)
							 | 
						||
| 
								 | 
							
								{ m1 = m1&m2; return m1; }
							 | 
						||
| 
								 | 
							
								inline match_flags& operator|=(match_flags& m1, match_flags m2)
							 | 
						||
| 
								 | 
							
								{ m1 = m1|m2; return m1; }
							 | 
						||
| 
								 | 
							
								inline match_flags& operator^=(match_flags& m1, match_flags m2)
							 | 
						||
| 
								 | 
							
								{ m1 = m1^m2; return m1; }
							 | 
						||
| 
								 | 
							
								#endif
							 | 
						||
| 
								 | 
							
								#endif
							 | 
						||
| 
								 | 
							
								
							 | 
						||
| 
								 | 
							
								#ifdef __cplusplus
							 | 
						||
| 
								 | 
							
								} /* namespace regex_constants */
							 | 
						||
| 
								 | 
							
								/*
							 | 
						||
| 
								 | 
							
								 * import names into boost for backwards compatiblity:
							 | 
						||
| 
								 | 
							
								 */
							 | 
						||
| 
								 | 
							
								using regex_constants::match_flag_type;
							 | 
						||
| 
								 | 
							
								using regex_constants::match_default;
							 | 
						||
| 
								 | 
							
								using regex_constants::match_not_bol;
							 | 
						||
| 
								 | 
							
								using regex_constants::match_not_eol;
							 | 
						||
| 
								 | 
							
								using regex_constants::match_not_bob;
							 | 
						||
| 
								 | 
							
								using regex_constants::match_not_eob;
							 | 
						||
| 
								 | 
							
								using regex_constants::match_not_bow;
							 | 
						||
| 
								 | 
							
								using regex_constants::match_not_eow;
							 | 
						||
| 
								 | 
							
								using regex_constants::match_not_dot_newline;
							 | 
						||
| 
								 | 
							
								using regex_constants::match_not_dot_null;
							 | 
						||
| 
								 | 
							
								using regex_constants::match_prev_avail;
							 | 
						||
| 
								 | 
							
								/* using regex_constants::match_init; */
							 | 
						||
| 
								 | 
							
								using regex_constants::match_any;
							 | 
						||
| 
								 | 
							
								using regex_constants::match_not_null;
							 | 
						||
| 
								 | 
							
								using regex_constants::match_continuous;
							 | 
						||
| 
								 | 
							
								using regex_constants::match_partial;
							 | 
						||
| 
								 | 
							
								/*using regex_constants::match_stop; */
							 | 
						||
| 
								 | 
							
								using regex_constants::match_all;
							 | 
						||
| 
								 | 
							
								using regex_constants::match_perl;
							 | 
						||
| 
								 | 
							
								using regex_constants::match_posix;
							 | 
						||
| 
								 | 
							
								using regex_constants::match_nosubs;
							 | 
						||
| 
								 | 
							
								using regex_constants::match_extra;
							 | 
						||
| 
								 | 
							
								using regex_constants::match_single_line;
							 | 
						||
| 
								 | 
							
								/*using regex_constants::match_max; */
							 | 
						||
| 
								 | 
							
								using regex_constants::format_all;
							 | 
						||
| 
								 | 
							
								using regex_constants::format_sed;
							 | 
						||
| 
								 | 
							
								using regex_constants::format_perl;
							 | 
						||
| 
								 | 
							
								using regex_constants::format_default;
							 | 
						||
| 
								 | 
							
								using regex_constants::format_no_copy;
							 | 
						||
| 
								 | 
							
								using regex_constants::format_first_only;
							 | 
						||
| 
								 | 
							
								/*using regex_constants::format_is_if;*/
							 | 
						||
| 
								 | 
							
								
							 | 
						||
| 
								 | 
							
								} /* namespace boost */
							 | 
						||
| 
								 | 
							
								#endif /* __cplusplus */
							 | 
						||
| 
								 | 
							
								#endif /* include guard */
							 | 
						||
| 
								 | 
							
								
							 |