Boost_1_39_0/tools/quickbook/phrase.hpp

   1 /*=============================================================================
   2     Copyright (c) 2002 2004 2006 Joel de Guzman
   3     Copyright (c) 2004 Eric Niebler
   4     http://spirit.sourceforge.net/
   5
   6     Use, modification and distribution is subject to the Boost Software
   7     License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
   8     http://www.boost.org/LICENSE_1_0.txt)
   9 =============================================================================*/
  10 #if !defined(BOOST_SPIRIT_QUICKBOOK_PHRASE_HPP)
  11 #define BOOST_SPIRIT_QUICKBOOK_PHRASE_HPP
  12
  13 #include "detail/utils.hpp"
  14 #include <boost/spirit/include/classic_core.hpp>
  15 #include <boost/spirit/include/classic_confix.hpp>
  16 #include <boost/spirit/include/classic_chset.hpp>
  17 #include <boost/spirit/include/classic_assign_actor.hpp>
  18 #include <boost/spirit/include/classic_if.hpp>
  19
  20 namespace quickbook
  21 {
  22     using namespace boost::spirit::classic;
  23
  24     template <typename Rule, typename Action>
  25     inline void
  26     simple_markup(
  27         Rule& simple
  28       , char mark
  29       , Action const& action
  30       , Rule const& close
  31     )
  32     {
  33         simple =
  34             mark >>
  35             (
  36                 (
  37                     graph_p                     // A single char. e.g. *c*
  38                     >> eps_p(mark
  39                         >> (space_p | punct_p | end_p))
  40                                                 // space_p, punct_p or end_p
  41                 )                               // must follow mark
  42             |
  43                 (   graph_p >>                  // graph_p must follow mark
  44                     *(anychar_p -
  45                         (   (graph_p >> mark)   // Make sure that we don't go
  46                         |   close               // past a single block
  47                         )
  48                     ) >> graph_p                // graph_p must precede mark
  49                     >> eps_p(mark
  50                         >> (space_p | punct_p | end_p))
  51                                                 // space_p, punct_p or end_p
  52                 )                               // must follow mark
  53             )                                   [action]
  54             >> mark
  55             ;
  56     }
  57
  58     template <typename Actions>
  59     struct phrase_grammar : grammar<phrase_grammar<Actions> >
  60     {
  61         phrase_grammar(Actions& actions, bool& no_eols)
  62             : no_eols(no_eols), actions(actions) {}
  63
  64         template <typename Scanner>
  65         struct definition
  66         {
  67             definition(phrase_grammar const& self)
  68             {
  69                 using detail::var;
  70                 Actions& actions = self.actions;
  71
  72                 space =
  73                     *(space_p | comment)
  74                     ;
  75
  76                 blank =
  77                     *(blank_p | comment)
  78                     ;
  79
  80                 eol = blank >> eol_p
  81                     ;
  82
  83                 phrase_end =
  84                     ']' |
  85                     if_p(var(self.no_eols))
  86                     [
  87                         eol >> eol                      // Make sure that we don't go
  88                     ]                                   // past a single block, except
  89                     ;                                   // when preformatted.
  90
  91                 hard_space =
  92                     (eps_p - (alnum_p | '_')) >> space  // must not be preceded by
  93                     ;                                   // alpha-numeric or underscore
  94
  95                 comment =
  96                     "[/" >> *(dummy_block | (anychar_p - ']')) >> ']'
  97                     ;
  98
  99                 dummy_block =
 100                     '[' >> *(dummy_block | (anychar_p - ']')) >> ']'
 101                     ;
 102
 103                 common =
 104                         macro
 105                     |   phrase_markup
 106                     |   code_block
 107                     |   inline_code
 108                     |   simple_format
 109                     |   escape
 110                     |   comment
 111                     ;
 112
 113                 macro =
 114                     eps_p(actions.macro                 // must not be followed by
 115                         >> (eps_p - (alpha_p | '_')))   // alpha or underscore
 116                     >> actions.macro                    [actions.do_macro]
 117                     ;
 118
 119                 template_args =
 120                     template_arg                        [push_back_a(actions.template_info)]
 121                     >> *(
 122                             ".." >> template_arg        [push_back_a(actions.template_info)]
 123                         )
 124                     ;
 125
 126                 static const bool true_ = true;
 127                 static const bool false_ = false;
 128
 129                 template_ =
 130                     (
 131                         ch_p('`')                       [assign_a(actions.template_escape,true_)]
 132                         |
 133                         eps_p                           [assign_a(actions.template_escape,false_)]
 134                     )
 135                     >>
 136                     ( (
 137                         (eps_p(punct_p)
 138                             >> actions.templates.scope
 139                         )                               [push_back_a(actions.template_info)]
 140                         >> !template_args
 141                     ) | (
 142                         (actions.templates.scope
 143                             >> eps_p
 144                         )                               [push_back_a(actions.template_info)]
 145                         >> !(hard_space
 146                             >> template_args)
 147                     ) )
 148                     ;
 149
 150                 brackets =
 151                     '[' >> +template_arg >> ']'
 152                     ;
 153
 154                 template_arg =
 155                     +(brackets | (anychar_p - (str_p("..") | ']')))
 156                     ;
 157
 158                 inline_code =
 159                     '`' >>
 160                     (
 161                        *(anychar_p -
 162                             (   '`'
 163                             |   (eol >> eol)            // Make sure that we don't go
 164                             )                           // past a single block
 165                         ) >> eps_p('`')
 166                     )                                   [actions.inline_code]
 167                     >>  '`'
 168                     ;
 169
 170                 code_block =
 171                         (
 172                             "```" >>
 173                             (
 174                                *(anychar_p - "```")
 175                                     >> eps_p("```")
 176                             )                           [actions.code_block]
 177                             >>  "```"
 178                         )
 179                     |   (
 180                             "``" >>
 181                             (
 182                                *(anychar_p - "``")
 183                                     >> eps_p("``")
 184                             )                           [actions.code_block]
 185                             >>  "``"
 186                         )
 187                     ;
 188
 189                 simple_format =
 190                         simple_bold
 191                     |   simple_italic
 192                     |   simple_underline
 193                     |   simple_teletype
 194                     ;
 195
 196                 simple_markup(simple_bold,
 197                     '*', actions.simple_bold, phrase_end);
 198                 simple_markup(simple_italic,
 199                     '/', actions.simple_italic, phrase_end);
 200                 simple_markup(simple_underline,
 201                     '_', actions.simple_underline, phrase_end);
 202                 simple_markup(simple_teletype,
 203                     '=', actions.simple_teletype, phrase_end);
 204
 205                 phrase =
 206                    *(   common
 207                     |   comment
 208                     |   (anychar_p - phrase_end)        [actions.plain_char]
 209                     )
 210                     ;
 211
 212                 phrase_markup =
 213                         '['
 214                     >>  (   cond_phrase
 215                         |   image
 216                         |   url
 217                         |   link
 218                         |   anchor
 219                         |   source_mode
 220                         |   funcref
 221                         |   classref
 222                         |   memberref
 223                         |   enumref
 224                         |   macroref
 225                         |   headerref
 226                         |   conceptref
 227                         |   globalref
 228                         |   bold
 229                         |   italic
 230                         |   underline
 231                         |   teletype
 232                         |   strikethrough
 233                         |   quote
 234                         |   replaceable
 235                         |   footnote
 236                         |   template_                   [actions.do_template]
 237                         |   str_p("br")                 [actions.break_]
 238                         )
 239                     >>  ']'
 240                     ;
 241
 242                 escape =
 243                         str_p("\\n")                    [actions.break_]
 244                     |   "\\ "                           // ignore an escaped char
 245                     |   '\\' >> punct_p                 [actions.raw_char]
 246                     |   (
 247                             ("'''" >> !eol)             [actions.escape_pre]
 248                         >>  *(anychar_p - "'''")        [actions.raw_char]
 249                         >>  str_p("'''")                [actions.escape_post]
 250                         )
 251                     ;
 252
 253                 macro_identifier =
 254                     +(anychar_p - (space_p | ']'))
 255                     ;
 256
 257                 cond_phrase =
 258                         '?' >> blank
 259                     >>  macro_identifier                [actions.cond_phrase_pre]
 260                     >>  (!phrase)                       [actions.cond_phrase_post]
 261                     ;
 262
 263                 image =
 264                         '$' >> blank
 265                     >> (*(anychar_p -
 266                             phrase_end))                [actions.image]
 267                     ;
 268
 269                 url =
 270                         '@'
 271                     >>  (*(anychar_p -
 272                             (']' | hard_space)))        [actions.url_pre]
 273                     >>  (   eps_p(']')
 274                         |   (hard_space >> phrase)
 275                         )                               [actions.url_post]
 276                     ;
 277
 278                 link =
 279                         "link" >> hard_space
 280                     >>  (*(anychar_p -
 281                             (']' | hard_space)))        [actions.link_pre]
 282                     >>  (   eps_p(']')
 283                         |   (hard_space >> phrase)
 284                         )                               [actions.link_post]
 285                     ;
 286
 287                 anchor =
 288                         '#'
 289                     >>  blank
 290                     >>  (   *(anychar_p -
 291                                 phrase_end)
 292                         )                               [actions.anchor]
 293                     ;
 294
 295                 funcref =
 296                     "funcref" >> hard_space
 297                     >>  (*(anychar_p -
 298                             (']' | hard_space)))        [actions.funcref_pre]
 299                     >>  (   eps_p(']')
 300                         |   (hard_space >> phrase)
 301                         )                               [actions.funcref_post]
 302                     ;
 303
 304                 classref =
 305                     "classref" >> hard_space
 306                     >>  (*(anychar_p -
 307                             (']' | hard_space)))        [actions.classref_pre]
 308                     >>  (   eps_p(']')
 309                         |   (hard_space >> phrase)
 310                         )                               [actions.classref_post]
 311                     ;
 312
 313                 memberref =
 314                     "memberref" >> hard_space
 315                     >>  (*(anychar_p -
 316                             (']' | hard_space)))        [actions.memberref_pre]
 317                     >>  (   eps_p(']')
 318                         |   (hard_space >> phrase)
 319                         )                               [actions.memberref_post]
 320                     ;
 321
 322                 enumref =
 323                     "enumref" >> hard_space
 324                     >>  (*(anychar_p -
 325                             (']' | hard_space)))        [actions.enumref_pre]
 326                     >>  (   eps_p(']')
 327                         |   (hard_space >> phrase)
 328                         )                               [actions.enumref_post]
 329                     ;
 330
 331                 macroref =
 332                     "macroref" >> hard_space
 333                     >>  (*(anychar_p -
 334                             (']' | hard_space)))        [actions.macroref_pre]
 335                     >>  (   eps_p(']')
 336                         |   (hard_space >> phrase)
 337                         )                               [actions.macroref_post]
 338                     ;
 339
 340                 headerref =
 341                     "headerref" >> hard_space
 342                     >>  (*(anychar_p -
 343                             (']' | hard_space)))        [actions.headerref_pre]
 344                     >>  (   eps_p(']')
 345                         |   (hard_space >> phrase)
 346                         )                               [actions.headerref_post]
 347                     ;
 348
 349                 conceptref =
 350                     "conceptref" >> hard_space
 351                     >>  (*(anychar_p -
 352                             (']' | hard_space)))        [actions.conceptref_pre]
 353                     >>  (   eps_p(']')
 354                         |   (hard_space >> phrase)
 355                         )                               [actions.conceptref_post]
 356                     ;
 357
 358                 globalref =
 359                     "globalref" >> hard_space
 360                     >>  (*(anychar_p -
 361                             (']' | hard_space)))        [actions.globalref_pre]
 362                     >>  (   eps_p(']')
 363                         |   (hard_space >> phrase)
 364                         )                               [actions.globalref_post]
 365                     ;
 366
 367                 bold =
 368                         ch_p('*')                       [actions.bold_pre]
 369                     >>  blank >> phrase                 [actions.bold_post]
 370                     ;
 371
 372                 italic =
 373                         ch_p('\'')                      [actions.italic_pre]
 374                     >>  blank >> phrase                 [actions.italic_post]
 375                     ;
 376
 377                 underline =
 378                         ch_p('_')                       [actions.underline_pre]
 379                     >>  blank >> phrase                 [actions.underline_post]
 380                     ;
 381
 382                 teletype =
 383                         ch_p('^')                       [actions.teletype_pre]
 384                     >>  blank >> phrase                 [actions.teletype_post]
 385                     ;
 386
 387                 strikethrough =
 388                         ch_p('-')                       [actions.strikethrough_pre]
 389                     >>  blank >> phrase                 [actions.strikethrough_post]
 390                     ;
 391
 392                 quote =
 393                         ch_p('"')                       [actions.quote_pre]
 394                     >>  blank >> phrase                 [actions.quote_post]
 395                     ;
 396
 397                 replaceable =
 398                         ch_p('~')                       [actions.replaceable_pre]
 399                     >>  blank >> phrase                 [actions.replaceable_post]
 400                     ;
 401
 402                 source_mode =
 403                     (
 404                         str_p("c++")
 405                     |   "python"
 406                     )                                   [assign_a(actions.source_mode)]
 407                     ;
 408
 409                 footnote =
 410                         str_p("footnote")               [actions.footnote_pre]
 411                     >>  blank >> phrase                 [actions.footnote_post]
 412                     ;
 413             }
 414
 415             rule<Scanner>   space, blank, comment, phrase, phrase_markup, image,
 416                             phrase_end, bold, italic, underline, teletype,
 417                             strikethrough, escape, url, common, funcref, classref,
 418                             memberref, enumref, macroref, headerref, conceptref, globalref,
 419                             anchor, link, hard_space, eol, inline_code, simple_format,
 420                             simple_bold, simple_italic, simple_underline,
 421                             simple_teletype, source_mode, template_, template_arg,
 422                             quote, code_block, footnote, replaceable, macro,
 423                             brackets, template_args, dummy_block, cond_phrase,
 424                             macro_identifier
 425                             ;
 426
 427             rule<Scanner> const&
 428             start() const { return common; }
 429         };
 430
 431         bool& no_eols;
 432         Actions& actions;
 433     };
 434
 435     template <typename Actions>
 436     struct simple_phrase_grammar
 437     : public grammar<simple_phrase_grammar<Actions> >
 438     {
 439         simple_phrase_grammar(Actions& actions)
 440             : actions(actions) {}
 441
 442         template <typename Scanner>
 443         struct definition
 444         {
 445             definition(simple_phrase_grammar const& self)
 446                 : unused(false), common(self.actions, unused)
 447             {
 448                 Actions& actions = self.actions;
 449
 450                 phrase =
 451                    *(   common
 452                     |   comment
 453                     |   (anychar_p - ']')           [actions.plain_char]
 454                     )
 455                     ;
 456
 457                 comment =
 458                     "[/" >> *(dummy_block | (anychar_p - ']')) >> ']'
 459                     ;
 460
 461                 dummy_block =
 462                     '[' >> *(dummy_block | (anychar_p - ']')) >> ']'
 463                     ;
 464             }
 465
 466             bool unused;
 467             rule<Scanner> phrase, comment, dummy_block;
 468             phrase_grammar<Actions> common;
 469
 470             rule<Scanner> const&
 471             start() const { return phrase; }
 472         };
 473
 474         Actions& actions;
 475     };
 476 }
 477
 478 #endif // BOOST_SPIRIT_QUICKBOOK_PHRASE_HPP
 479