/Src/Dependencies/Boost/boost/spirit/home/classic/utility/chset_operators.hpp

http://hadesmem.googlecode.com/ · C++ Header · 402 lines · 193 code · 68 blank · 141 comment · 0 complexity · c2b2230a838a662f4c87e2d28a21d736 MD5 · raw file 

    

  1. /*=============================================================================
    2. 

  2.     Copyright (c) 2001-2003 Joel de Guzman
    3. 

  3.     Copyright (c) 2001-2003 Daniel Nuffer
    4. 

  4.     http://spirit.sourceforge.net/
    5. 

    6. 

  6.   Distributed under the Boost Software License, Version 1.0. (See accompanying
    7. 

  7.   file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
    8. 

  8. =============================================================================*/
    9. 

  9. #ifndef BOOST_SPIRIT_CHSET_OPERATORS_HPP
    10. 

  10. #define BOOST_SPIRIT_CHSET_OPERATORS_HPP
    11. 

  11. 

  12. ///////////////////////////////////////////////////////////////////////////////
    13. 

  13. #include <boost/spirit/home/classic/namespace.hpp>
    14. 

  14. #include <boost/spirit/home/classic/utility/chset.hpp>
    15. 

  15. 

  16. ///////////////////////////////////////////////////////////////////////////////
    17. 

  17. namespace boost { namespace spirit {
    18. 

  18. 

  19. BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
    20. 

  20. 

  21. ///////////////////////////////////////////////////////////////////////////////
    22. 

  22. //
    23. 

  23. //  chset free operators
    24. 

  24. //
    25. 

  25. //      Where a and b are both chsets, implements:
    26. 

  26. //
    27. 

  27. //          a | b, a & b, a - b, a ^ b
    28. 

  28. //
    29. 

  29. //      Where a is a chset, implements:
    30. 

  30. //
    31. 

  31. //          ~a
    32. 

  32. //
    33. 

  33. ///////////////////////////////////////////////////////////////////////////////
    34. 

  34. template <typename CharT>
    35. 

  35. chset<CharT>
    36. 

  36. operator~(chset<CharT> const& a);
    37. 

  37. 

  38. //////////////////////////////////
    39. 

  39. template <typename CharT>
    40. 

  40. chset<CharT>
    41. 

  41. operator|(chset<CharT> const& a, chset<CharT> const& b);
    42. 

  42. 

  43. //////////////////////////////////
    44. 

  44. template <typename CharT>
    45. 

  45. chset<CharT>
    46. 

  46. operator&(chset<CharT> const& a, chset<CharT> const& b);
    47. 

  47. 

  48. //////////////////////////////////
    49. 

  49. template <typename CharT>
    50. 

  50. chset<CharT>
    51. 

  51. operator-(chset<CharT> const& a, chset<CharT> const& b);
    52. 

  52. 

  53. //////////////////////////////////
    54. 

  54. template <typename CharT>
    55. 

  55. chset<CharT>
    56. 

  56. operator^(chset<CharT> const& a, chset<CharT> const& b);
    57. 

  57. 

  58. ///////////////////////////////////////////////////////////////////////////////
    59. 

  59. //
    60. 

  60. //  range <--> chset free operators
    61. 

  61. //
    62. 

  62. //      Where a is a chset and b is a range, and vice-versa, implements:
    63. 

  63. //
    64. 

  64. //          a | b, a & b, a - b, a ^ b
    65. 

  65. //
    66. 

  66. ///////////////////////////////////////////////////////////////////////////////
    67. 

  67. template <typename CharT>
    68. 

  68. chset<CharT>
    69. 

  69. operator|(chset<CharT> const& a, range<CharT> const& b);
    70. 

  70. 

  71. //////////////////////////////////
    72. 

  72. template <typename CharT>
    73. 

  73. chset<CharT>
    74. 

  74. operator&(chset<CharT> const& a, range<CharT> const& b);
    75. 

  75. 

  76. //////////////////////////////////
    77. 

  77. template <typename CharT>
    78. 

  78. chset<CharT>
    79. 

  79. operator-(chset<CharT> const& a, range<CharT> const& b);
    80. 

  80. 

  81. //////////////////////////////////
    82. 

  82. template <typename CharT>
    83. 

  83. chset<CharT>
    84. 

  84. operator^(chset<CharT> const& a, range<CharT> const& b);
    85. 

  85. 

  86. //////////////////////////////////
    87. 

  87. template <typename CharT>
    88. 

  88. chset<CharT>
    89. 

  89. operator|(range<CharT> const& a, chset<CharT> const& b);
    90. 

  90. 

  91. //////////////////////////////////
    92. 

  92. template <typename CharT>
    93. 

  93. chset<CharT>
    94. 

  94. operator&(range<CharT> const& a, chset<CharT> const& b);
    95. 

  95. 

  96. //////////////////////////////////
    97. 

  97. template <typename CharT>
    98. 

  98. chset<CharT>
    99. 

  99. operator-(range<CharT> const& a, chset<CharT> const& b);
    100. 

  100. 

  101. //////////////////////////////////
    102. 

  102. template <typename CharT>
    103. 

  103. chset<CharT>
    104. 

  104. operator^(range<CharT> const& a, chset<CharT> const& b);
    105. 

  105. 

  106. ///////////////////////////////////////////////////////////////////////////////
    107. 

  107. //
    108. 

  108. //  chlit <--> chset free operators
    109. 

  109. //
    110. 

  110. //      Where a is a chset and b is a chlit, and vice-versa, implements:
    111. 

  111. //
    112. 

  112. //          a | b, a & b, a - b, a ^ b
    113. 

  113. //
    114. 

  114. ///////////////////////////////////////////////////////////////////////////////
    115. 

  115. template <typename CharT>
    116. 

  116. chset<CharT>
    117. 

  117. operator|(chset<CharT> const& a, chlit<CharT> const& b);
    118. 

  118. 

  119. //////////////////////////////////
    120. 

  120. template <typename CharT>
    121. 

  121. chset<CharT>
    122. 

  122. operator&(chset<CharT> const& a, chlit<CharT> const& b);
    123. 

  123. 

  124. //////////////////////////////////
    125. 

  125. template <typename CharT>
    126. 

  126. chset<CharT>
    127. 

  127. operator-(chset<CharT> const& a, chlit<CharT> const& b);
    128. 

  128. 

  129. //////////////////////////////////
    130. 

  130. template <typename CharT>
    131. 

  131. chset<CharT>
    132. 

  132. operator^(chset<CharT> const& a, chlit<CharT> const& b);
    133. 

  133. 

  134. //////////////////////////////////
    135. 

  135. template <typename CharT>
    136. 

  136. chset<CharT>
    137. 

  137. operator|(chlit<CharT> const& a, chset<CharT> const& b);
    138. 

  138. 

  139. //////////////////////////////////
    140. 

  140. template <typename CharT>
    141. 

  141. chset<CharT>
    142. 

  142. operator&(chlit<CharT> const& a, chset<CharT> const& b);
    143. 

  143. 

  144. //////////////////////////////////
    145. 

  145. template <typename CharT>
    146. 

  146. chset<CharT>
    147. 

  147. operator-(chlit<CharT> const& a, chset<CharT> const& b);
    148. 

  148. 

  149. //////////////////////////////////
    150. 

  150. template <typename CharT>
    151. 

  151. chset<CharT>
    152. 

  152. operator^(chlit<CharT> const& a, chset<CharT> const& b);
    153. 

  153. 

  154. ///////////////////////////////////////////////////////////////////////////////
    155. 

  155. //
    156. 

  156. //  negated_char_parser<range> <--> chset free operators
    157. 

  157. //
    158. 

  158. //      Where a is a chset and b is a range, and vice-versa, implements:
    159. 

  159. //
    160. 

  160. //          a | b, a & b, a - b, a ^ b
    161. 

  161. //
    162. 

  162. ///////////////////////////////////////////////////////////////////////////////
    163. 

  163. template <typename CharT>
    164. 

  164. chset<CharT>
    165. 

  165. operator|(chset<CharT> const& a, negated_char_parser<range<CharT> > const& b);
    166. 

  166. 

  167. //////////////////////////////////
    168. 

  168. template <typename CharT>
    169. 

  169. chset<CharT>
    170. 

  170. operator&(chset<CharT> const& a, negated_char_parser<range<CharT> > const& b);
    171. 

  171. 

  172. //////////////////////////////////
    173. 

  173. template <typename CharT>
    174. 

  174. chset<CharT>
    175. 

  175. operator-(chset<CharT> const& a, negated_char_parser<range<CharT> > const& b);
    176. 

  176. 

  177. //////////////////////////////////
    178. 

  178. template <typename CharT>
    179. 

  179. chset<CharT>
    180. 

  180. operator^(chset<CharT> const& a, negated_char_parser<range<CharT> > const& b);
    181. 

  181. 

  182. //////////////////////////////////
    183. 

  183. template <typename CharT>
    184. 

  184. chset<CharT>
    185. 

  185. operator|(negated_char_parser<range<CharT> > const& a, chset<CharT> const& b);
    186. 

  186. 

  187. //////////////////////////////////
    188. 

  188. template <typename CharT>
    189. 

  189. chset<CharT>
    190. 

  190. operator&(negated_char_parser<range<CharT> > const& a, chset<CharT> const& b);
    191. 

  191. 

  192. //////////////////////////////////
    193. 

  193. template <typename CharT>
    194. 

  194. chset<CharT>
    195. 

  195. operator-(negated_char_parser<range<CharT> > const& a, chset<CharT> const& b);
    196. 

  196. 

  197. //////////////////////////////////
    198. 

  198. template <typename CharT>
    199. 

  199. chset<CharT>
    200. 

  200. operator^(negated_char_parser<range<CharT> > const& a, chset<CharT> const& b);
    201. 

  201. 

  202. ///////////////////////////////////////////////////////////////////////////////
    203. 

  203. //
    204. 

  204. //  negated_char_parser<chlit> <--> chset free operators
    205. 

  205. //
    206. 

  206. //      Where a is a chset and b is a chlit, and vice-versa, implements:
    207. 

  207. //
    208. 

  208. //          a | b, a & b, a - b, a ^ b
    209. 

  209. //
    210. 

  210. ///////////////////////////////////////////////////////////////////////////////
    211. 

  211. template <typename CharT>
    212. 

  212. chset<CharT>
    213. 

  213. operator|(chset<CharT> const& a, negated_char_parser<chlit<CharT> > const& b);
    214. 

  214. 

  215. //////////////////////////////////
    216. 

  216. template <typename CharT>
    217. 

  217. chset<CharT>
    218. 

  218. operator&(chset<CharT> const& a, negated_char_parser<chlit<CharT> > const& b);
    219. 

  219. 

  220. //////////////////////////////////
    221. 

  221. template <typename CharT>
    222. 

  222. chset<CharT>
    223. 

  223. operator-(chset<CharT> const& a, negated_char_parser<chlit<CharT> > const& b);
    224. 

  224. 

  225. //////////////////////////////////
    226. 

  226. template <typename CharT>
    227. 

  227. chset<CharT>
    228. 

  228. operator^(chset<CharT> const& a, negated_char_parser<chlit<CharT> > const& b);
    229. 

  229. 

  230. //////////////////////////////////
    231. 

  231. template <typename CharT>
    232. 

  232. chset<CharT>
    233. 

  233. operator|(negated_char_parser<chlit<CharT> > const& a, chset<CharT> const& b);
    234. 

  234. 

  235. //////////////////////////////////
    236. 

  236. template <typename CharT>
    237. 

  237. chset<CharT>
    238. 

  238. operator&(negated_char_parser<chlit<CharT> > const& a, chset<CharT> const& b);
    239. 

  239. 

  240. //////////////////////////////////
    241. 

  241. template <typename CharT>
    242. 

  242. chset<CharT>
    243. 

  243. operator-(negated_char_parser<chlit<CharT> > const& a, chset<CharT> const& b);
    244. 

  244. 

  245. //////////////////////////////////
    246. 

  246. template <typename CharT>
    247. 

  247. chset<CharT>
    248. 

  248. operator^(negated_char_parser<chlit<CharT> > const& a, chset<CharT> const& b);
    249. 

  249. 

  250. ///////////////////////////////////////////////////////////////////////////////
    251. 

  251. //
    252. 

  252. //  literal primitives <--> chset free operators
    253. 

  253. //
    254. 

  254. //      Where a is a chset and b is a literal primitive,
    255. 

  255. //      and vice-versa, implements:
    256. 

  256. //
    257. 

  257. //          a | b, a & b, a - b, a ^ b
    258. 

  258. //
    259. 

  259. ///////////////////////////////////////////////////////////////////////////////
    260. 

  260. template <typename CharT>
    261. 

  261. chset<CharT>
    262. 

  262. operator|(chset<CharT> const& a, CharT b);
    263. 

  263. 

  264. //////////////////////////////////
    265. 

  265. template <typename CharT>
    266. 

  266. chset<CharT>
    267. 

  267. operator&(chset<CharT> const& a, CharT b);
    268. 

  268. 

  269. //////////////////////////////////
    270. 

  270. template <typename CharT>
    271. 

  271. chset<CharT>
    272. 

  272. operator-(chset<CharT> const& a, CharT b);
    273. 

  273. 

  274. //////////////////////////////////
    275. 

  275. template <typename CharT>
    276. 

  276. chset<CharT>
    277. 

  277. operator^(chset<CharT> const& a, CharT b);
    278. 

  278. 

  279. //////////////////////////////////
    280. 

  280. template <typename CharT>
    281. 

  281. chset<CharT>
    282. 

  282. operator|(CharT a, chset<CharT> const& b);
    283. 

  283. 

  284. //////////////////////////////////
    285. 

  285. template <typename CharT>
    286. 

  286. chset<CharT>
    287. 

  287. operator&(CharT a, chset<CharT> const& b);
    288. 

  288. 

  289. //////////////////////////////////
    290. 

  290. template <typename CharT>
    291. 

  291. chset<CharT>
    292. 

  292. operator-(CharT a, chset<CharT> const& b);
    293. 

  293. 

  294. //////////////////////////////////
    295. 

  295. template <typename CharT>
    296. 

  296. chset<CharT>
    297. 

  297. operator^(CharT a, chset<CharT> const& b);
    298. 

  298. 

  299. ///////////////////////////////////////////////////////////////////////////////
    300. 

  300. //
    301. 

  301. //  anychar_parser <--> chset free operators
    302. 

  302. //
    303. 

  303. //      Where a is chset and b is a anychar_parser, and vice-versa, implements:
    304. 

  304. //
    305. 

  305. //          a | b, a & b, a - b, a ^ b
    306. 

  306. //
    307. 

  307. ///////////////////////////////////////////////////////////////////////////////
    308. 

  308. template <typename CharT>
    309. 

  309. chset<CharT>
    310. 

  310. operator|(chset<CharT> const& a, anychar_parser b);
    311. 

  311. 

  312. //////////////////////////////////
    313. 

  313. template <typename CharT>
    314. 

  314. chset<CharT>
    315. 

  315. operator&(chset<CharT> const& a, anychar_parser b);
    316. 

  316. 

  317. //////////////////////////////////
    318. 

  318. template <typename CharT>
    319. 

  319. chset<CharT>
    320. 

  320. operator-(chset<CharT> const& a, anychar_parser b);
    321. 

  321. 

  322. //////////////////////////////////
    323. 

  323. template <typename CharT>
    324. 

  324. chset<CharT>
    325. 

  325. operator^(chset<CharT> const& a, anychar_parser b);
    326. 

  326. 

  327. //////////////////////////////////
    328. 

  328. template <typename CharT>
    329. 

  329. chset<CharT>
    330. 

  330. operator|(anychar_parser a, chset<CharT> const& b);
    331. 

  331. 

  332. //////////////////////////////////
    333. 

  333. template <typename CharT>
    334. 

  334. chset<CharT>
    335. 

  335. operator&(anychar_parser a, chset<CharT> const& b);
    336. 

  336. 

  337. //////////////////////////////////
    338. 

  338. template <typename CharT>
    339. 

  339. chset<CharT>
    340. 

  340. operator-(anychar_parser a, chset<CharT> const& b);
    341. 

  341. 

  342. //////////////////////////////////
    343. 

  343. template <typename CharT>
    344. 

  344. chset<CharT>
    345. 

  345. operator^(anychar_parser a, chset<CharT> const& b);
    346. 

  346. 

  347. ///////////////////////////////////////////////////////////////////////////////
    348. 

  348. //
    349. 

  349. //  nothing_parser <--> chset free operators
    350. 

  350. //
    351. 

  351. //      Where a is chset and b is nothing_parser, and vice-versa, implements:
    352. 

  352. //
    353. 

  353. //          a | b, a & b, a - b, a ^ b
    354. 

  354. //
    355. 

  355. ///////////////////////////////////////////////////////////////////////////////
    356. 

  356. template <typename CharT>
    357. 

  357. chset<CharT>
    358. 

  358. operator|(chset<CharT> const& a, nothing_parser b);
    359. 

  359. 

  360. //////////////////////////////////
    361. 

  361. template <typename CharT>
    362. 

  362. chset<CharT>
    363. 

  363. operator&(chset<CharT> const& a, nothing_parser b);
    364. 

  364. 

  365. //////////////////////////////////
    366. 

  366. template <typename CharT>
    367. 

  367. chset<CharT>
    368. 

  368. operator-(chset<CharT> const& a, nothing_parser b);
    369. 

  369. 

  370. //////////////////////////////////
    371. 

  371. template <typename CharT>
    372. 

  372. chset<CharT>
    373. 

  373. operator^(chset<CharT> const& a, nothing_parser b);
    374. 

  374. 

  375. //////////////////////////////////
    376. 

  376. template <typename CharT>
    377. 

  377. chset<CharT>
    378. 

  378. operator|(nothing_parser a, chset<CharT> const& b);
    379. 

  379. 

  380. //////////////////////////////////
    381. 

  381. template <typename CharT>
    382. 

  382. chset<CharT>
    383. 

  383. operator&(nothing_parser a, chset<CharT> const& b);
    384. 

  384. 

  385. //////////////////////////////////
    386. 

  386. template <typename CharT>
    387. 

  387. chset<CharT>
    388. 

  388. operator-(nothing_parser a, chset<CharT> const& b);
    389. 

  389. 

  390. //////////////////////////////////
    391. 

  391. template <typename CharT>
    392. 

  392. chset<CharT>
    393. 

  393. operator^(nothing_parser a, chset<CharT> const& b);
    394. 

  394. 

  395. ///////////////////////////////////////////////////////////////////////////////
    396. 

  396. BOOST_SPIRIT_CLASSIC_NAMESPACE_END
    397. 

  397. 

  398. }} // namespace BOOST_SPIRIT_CLASSIC_NS
    399. 

  399. 

  400. #endif
    401. 

  401. 

  402. #include <boost/spirit/home/classic/utility/impl/chset_operators.ipp>
    403.