1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
|
/*
*
* Copyright (c) 1998-2004
* 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: regex.cpp
* VERSION: see <boost/version.hpp>
* DESCRIPTION: Misc boost::regbase member funnctions.
*/
#define BOOST_REGEX_SOURCE
#include <boost/regex/config.hpp>
#ifdef BOOST_REGEX_HAS_MS_STACK_GUARD
#include <malloc.h>
#ifndef WIN32_LEAN_AND_MEAN
# define WIN32_LEAN_AND_MEAN
#endif
#ifndef NOMINMAX
# define NOMINMAX
#endif
#define NOGDI
#define NOUSER
#include <windows.h>
#include <stdexcept>
#include <boost/regex/pattern_except.hpp>
#include <boost/regex/v4/protected_call.hpp>
namespace boost {
namespace BOOST_REGEX_DETAIL_NS {
static void execute_eror()
{
// we only get here after a stack overflow,
// this has to be a separate proceedure because we
// can't mix __try{}__except block with local objects
// that have destructors:
reset_stack_guard_page();
std::runtime_error err("Out of stack space, while attempting to match a regular expression.");
raise_runtime_error(err);
}
bool BOOST_REGEX_CALL abstract_protected_call::execute()const
{
__try{
return this->call();
}__except(EXCEPTION_STACK_OVERFLOW == GetExceptionCode())
{
execute_eror();
}
// We never really get here at all:
return false;
}
BOOST_REGEX_DECL void BOOST_REGEX_CALL reset_stack_guard_page()
{
#if defined(BOOST_REGEX_HAS_MS_STACK_GUARD) && defined(_MSC_VER) && (_MSC_VER >= 1300)
_resetstkoflw();
#else
//
// We need to locate the current page being used by the stack,
// move to the page below it and then deallocate and protect
// that page. Note that ideally we would protect only the lowest
// stack page that has been allocated: in practice there
// seems to be no easy way to locate this page, in any case as
// long as the next page is protected, then Windows will figure
// the rest out for us...
//
SYSTEM_INFO si;
GetSystemInfo(&si);
MEMORY_BASIC_INFORMATION mi;
DWORD previous_protection_status;
//
// this is an address in our stack space:
//
LPBYTE page = (LPBYTE)&page;
//
// Get the current memory page in use:
//
VirtualQuery(page, &mi, sizeof(mi));
//
// Go to the page one below this:
//
page = (LPBYTE)(mi.BaseAddress)-si.dwPageSize;
//
// Free and protect everything from the start of the
// allocation range, to the end of the page below the
// one in use:
//
if (!VirtualFree(mi.AllocationBase, (LPBYTE)page - (LPBYTE)mi.AllocationBase, MEM_DECOMMIT)
|| !VirtualProtect(page, si.dwPageSize, PAGE_GUARD | PAGE_READWRITE, &previous_protection_status))
{
throw std::bad_exception();
}
#endif
}
}
} // namspaces
#endif
#if defined(BOOST_RE_USE_VCL) && defined(BOOST_REGEX_DYN_LINK)
int WINAPI DllEntryPoint(HINSTANCE , unsigned long , void*)
{
return 1;
}
#endif
|
