← Back to branch summary

~ubuntu-branches/ubuntu/warty/aqsis/warty

« back to all changes in this revision

Viewing changes to boost/libs/regex/src/wide_posix_api.cpp

  • Committer: Bazaar Package Importer
  • Author(s): LaMont Jones
  • Date: 2004-08-24 07:25:04 UTC
  • Revision ID: james.westby@ubuntu.com-20040824072504-zf993vnevvisdsvb
Tags: upstream-0.9.1
Import upstream version 0.9.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
boost/libs/regex/src/wide_posix_api.cpp
 
1
/*
 
2
 *
 
3
 * Copyright (c) 1998-2002
 
4
 * Dr John Maddock
 
5
 *
 
6
 * Permission to use, copy, modify, distribute and sell this software
 
7
 * and its documentation for any purpose is hereby granted without fee,
 
8
 * provided that the above copyright notice appear in all copies and
 
9
 * that both that copyright notice and this permission notice appear
 
10
 * in supporting documentation.  Dr John Maddock makes no representations
 
11
 * about the suitability of this software for any purpose.
 
12
 * It is provided "as is" without express or implied warranty.
 
13
 *
 
14
 */
 
15
 
 
16
 /*
 
17
  *   LOCATION:    see http://www.boost.org for most recent version.
 
18
  *   FILE:        wide_posix_api.cpp
 
19
  *   VERSION:     see <boost/version.hpp>
 
20
  *   DESCRIPTION: Implements the wide character POSIX API wrappers.
 
21
  */
 
22
 
 
23
#define BOOST_REGEX_SOURCE
 
24
 
 
25
#include <boost/regex/config.hpp>
 
26
 
 
27
#ifndef BOOST_NO_WREGEX
 
28
 
 
29
#include <boost/regex.hpp>
 
30
 
 
31
#include <cwchar>
 
32
#include <cstring>
 
33
#include <cstdio>
 
34
 
 
35
namespace boost{
 
36
 
 
37
namespace {
 
38
 
 
39
unsigned int wmagic_value = 28631;
 
40
 
 
41
const wchar_t* wnames[] = {L"REG_NOERROR", L"REG_NOMATCH", L"REG_BADPAT", L"REG_ECOLLATE",
 
42
                        L"REG_ECTYPE", L"REG_EESCAPE", L"REG_ESUBREG", L"REG_EBRACK",
 
43
                        L"REG_EPAREN", L"REG_EBRACE", L"REG_BADBR", L"REG_ERANGE",
 
44
                        L"REG_ESPACE", L"REG_BADRPT", L"REG_EMPTY", L"REG_E_UNKNOWN"};
 
45
 
 
46
}
 
47
 
 
48
BOOST_REGEX_DECL int BOOST_REGEX_CCALL regcompW(regex_tW* expression, const wchar_t* ptr, int f)
 
49
{
 
50
   BOOST_RE_GUARD_STACK
 
51
   if(expression->re_magic != wmagic_value)
 
52
   {
 
53
      expression->guts = 0;
 
54
#ifndef BOOST_NO_EXCEPTIONS
 
55
      try{
 
56
#endif
 
57
      expression->guts = new wregex();
 
58
#ifndef BOOST_NO_EXCEPTIONS
 
59
      } catch(...)
 
60
      {
 
61
         return REG_ESPACE;
 
62
      }
 
63
#else
 
64
      if(0 == expression->guts)
 
65
         return REG_E_MEMORY;
 
66
#endif
 
67
   }
 
68
   // set default flags:
 
69
   boost::uint_fast32_t flags = (f & REG_EXTENDED) ? regbase::extended : regbase::basic;
 
70
   expression->eflags = (f & REG_NEWLINE) ? match_not_dot_newline : 0;
 
71
 
 
72
   // and translate those that are actually set:
 
73
   if(f & REG_NOCOLLATE)
 
74
      flags |= regbase::nocollate;
 
75
 
 
76
   if(f & REG_NOSUB)
 
77
      expression->eflags |= match_any;
 
78
 
 
79
   if(f & REG_NOSPEC)
 
80
      flags |= regbase::literal;
 
81
   if(f & REG_ICASE)
 
82
      flags |= regbase::icase;
 
83
   if(f & REG_ESCAPE_IN_LISTS)
 
84
      flags |= regbase::escape_in_lists;
 
85
   if(f & REG_NEWLINE_ALT)
 
86
      flags |= regbase::newline_alt;
 
87
 
 
88
   const wchar_t* p2;
 
89
   if(f & REG_PEND)
 
90
      p2 = expression->re_endp;
 
91
   else p2 = ptr + std::wcslen(ptr);
 
92
 
 
93
   int result;
 
94
 
 
95
#ifndef BOOST_NO_EXCEPTIONS
 
96
   try{
 
97
#endif
 
98
      expression->re_magic = wmagic_value;
 
99
      static_cast<wregex*>(expression->guts)->set_expression(ptr, p2, flags);
 
100
      expression->re_nsub = static_cast<wregex*>(expression->guts)->mark_count() - 1;
 
101
      result = static_cast<wregex*>(expression->guts)->error_code();
 
102
#ifndef BOOST_NO_EXCEPTIONS
 
103
   } catch(...)
 
104
   {
 
105
      result = REG_E_UNKNOWN;
 
106
   }
 
107
#endif
 
108
   if(result)
 
109
      regfreeW(expression);
 
110
   return result;
 
111
 
 
112
}
 
113
 
 
114
BOOST_REGEX_DECL regsize_t BOOST_REGEX_CCALL regerrorW(int code, const regex_tW* e, wchar_t* buf, regsize_t buf_size)
 
115
{
 
116
   BOOST_RE_GUARD_STACK
 
117
   std::size_t result = 0;
 
118
   if(code & REG_ITOA)
 
119
   {
 
120
      code &= ~REG_ITOA;
 
121
      if(code <= REG_E_UNKNOWN)
 
122
      {
 
123
         result = std::wcslen(wnames[code]) + 1;
 
124
         if(buf_size >= result)
 
125
            std::wcscpy(buf, wnames[code]);
 
126
         return result;
 
127
      }
 
128
      return result;
 
129
   }
 
130
#if !defined(BOOST_NO_SWPRINTF)
 
131
   if(code == REG_ATOI)
 
132
   {
 
133
      wchar_t localbuf[5];
 
134
      if(e == 0)
 
135
         return 0;
 
136
      for(int i = 0; i <= REG_E_UNKNOWN; ++i)
 
137
      {
 
138
         if(std::wcscmp(e->re_endp, wnames[i]) == 0)
 
139
         {
 
140
            std::swprintf(localbuf, 5, L"%d", i);
 
141
            if(std::wcslen(localbuf) < buf_size)
 
142
               std::wcscpy(buf, localbuf);
 
143
            return std::wcslen(localbuf) + 1;
 
144
         }
 
145
      }
 
146
      std::swprintf(localbuf, 5, L"%d", 0);
 
147
      if(std::wcslen(localbuf) < buf_size)
 
148
         std::wcscpy(buf, localbuf);
 
149
      return std::wcslen(localbuf) + 1;
 
150
   }
 
151
#endif
 
152
   if(code <= REG_E_UNKNOWN)
 
153
   {
 
154
      regex_traits<wchar_t> rt;
 
155
      const regex_traits<wchar_t>* pt = &rt;
 
156
      if(e && (e->re_magic == wmagic_value))
 
157
         pt = &static_cast<wregex*>(e->guts)->get_traits();
 
158
      (void)pt; // warning suppression
 
159
      std::string p = pt->error_string(code);
 
160
      std::size_t len = pt->strwiden(static_cast<wchar_t*>(0), 0, p.c_str());
 
161
      if(len < buf_size)
 
162
      {
 
163
         pt->strwiden(buf, buf_size, p.c_str());
 
164
      }
 
165
      return len + 1;
 
166
   }
 
167
   if(buf_size)
 
168
      *buf = 0;
 
169
   return 0;
 
170
}
 
171
 
 
172
BOOST_REGEX_DECL int BOOST_REGEX_CCALL regexecW(const regex_tW* expression, const wchar_t* buf, regsize_t n, regmatch_t* array, int eflags)
 
173
{
 
174
   BOOST_RE_GUARD_STACK
 
175
   bool result = false;
 
176
   boost::uint_fast32_t flags = match_default | expression->eflags;
 
177
   const wchar_t* end;
 
178
   const wchar_t* start;
 
179
   wcmatch m;
 
180
   
 
181
   if(eflags & REG_NOTBOL)
 
182
      flags |= match_not_bol;
 
183
   if(eflags & REG_NOTEOL)
 
184
      flags |= match_not_eol;
 
185
   if(eflags & REG_STARTEND)
 
186
   {
 
187
      start = buf + array[0].rm_so;
 
188
      end = buf + array[0].rm_eo;
 
189
   }
 
190
   else
 
191
   {
 
192
      start = buf;
 
193
      end = buf + std::wcslen(buf);
 
194
   }
 
195
 
 
196
#ifndef BOOST_NO_EXCEPTIONS
 
197
   try{
 
198
#endif
 
199
   if(expression->re_magic == wmagic_value)
 
200
   {
 
201
      result = regex_search(start, end, m, *static_cast<wregex*>(expression->guts), flags);
 
202
   }
 
203
   else
 
204
      return result;
 
205
#ifndef BOOST_NO_EXCEPTIONS
 
206
   } catch(...)
 
207
   {
 
208
      return REG_E_UNKNOWN;
 
209
   }
 
210
#endif
 
211
   if(result)
 
212
   {
 
213
      // extract what matched:
 
214
     unsigned int i;
 
215
      for(i = 0; (i < n) && (i < expression->re_nsub + 1); ++i)
 
216
      {
 
217
         array[i].rm_so = (m[i].matched == false) ? -1 : (m[i].first - buf);
 
218
         array[i].rm_eo = (m[i].matched == false) ? -1 : (m[i].second - buf);
 
219
      }
 
220
      // and set anything else to -1:
 
221
      for(i = expression->re_nsub + 1; i < n; ++i)
 
222
      {
 
223
         array[i].rm_so = -1;
 
224
         array[i].rm_eo = -1;
 
225
      }
 
226
      return 0;
 
227
   }
 
228
   return REG_NOMATCH;
 
229
}
 
230
 
 
231
BOOST_REGEX_DECL void BOOST_REGEX_CCALL regfreeW(regex_tW* expression)
 
232
{
 
233
   BOOST_RE_GUARD_STACK
 
234
   if(expression->re_magic == wmagic_value)
 
235
   {
 
236
      delete static_cast<wregex*>(expression->guts);
 
237
   }
 
238
   expression->re_magic = 0;
 
239
}
 
240
 
 
241
} // namespace boost;
 
242
 
 
243
#endif
 
244
 
 
245
 
 
246