examples/variant.yy

   1 /*
   2   Copyright (C) 2008-2013 Free Software Foundation, Inc.
   3
   4   This program is free software: you can redistribute it and/or modify
   5   it under the terms of the GNU General Public License as published by
   6   the Free Software Foundation, either version 3 of the License, or
   7   (at your option) any later version.
   8
   9   This program is distributed in the hope that it will be useful,
  10   but WITHOUT ANY WARRANTY; without even the implied warranty of
  11   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12   GNU General Public License for more details.
  13
  14   You should have received a copy of the GNU General Public License
  15   along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16 */
  17
  18 %debug
  19 %language "c++"
  20 %defines
  21 %define api.token.constructor
  22 %define api.value.type variant
  23 %define parse.assert
  24 %locations
  25
  26 %code requires // *.hh
  27 {
  28 #include <list>
  29 #include <string>
  30 typedef std::list<std::string> strings_type;
  31 }
  32
  33 %code // *.cc
  34 {
  35 #include <algorithm>
  36 #include <iostream>
  37 #include <iterator>
  38 #include <sstream>
  39
  40   // Prototype of the yylex function providing subsequent tokens.
  41   namespace yy
  42   {
  43     static parser::symbol_type yylex ();
  44   }
  45
  46   // Printing a list of strings.
  47   // Koening look up will look into std, since that's an std::list.
  48   namespace std
  49   {
  50     std::ostream&
  51     operator<< (std::ostream& o, const strings_type& ss)
  52     {
  53       o << "(" << &ss << ") {";
  54       const char *sep = "";
  55       for (strings_type::const_iterator i = ss.begin(), end = ss.end();
  56            i != end; ++i)
  57         {
  58           o << sep << *i;
  59           sep = ", ";
  60         }
  61       return o << "}";
  62     }
  63   }
  64
  65   // Conversion to string.
  66   template <typename T>
  67     inline
  68     std::string
  69     string_cast (const T& t)
  70   {
  71     std::ostringstream o;
  72     o << t;
  73     return o.str ();
  74   }
  75 }
  76
  77 %token <::std::string> TEXT;
  78 %token <int> NUMBER;
  79 %printer { yyoutput << $$; } <*>;
  80 %token END_OF_FILE 0;
  81
  82 %type <::std::string> item;
  83 %type <::std::list<std::string>> list;
  84
  85 %%
  86
  87 result:
  88   list  { std::cout << $1 << std::endl; }
  89 ;
  90
  91 list:
  92   /* nothing */ { /* Generates an empty string list */ }
  93 | list item     { std::swap ($$, $1); $$.push_back ($2); }
  94 ;
  95
  96 item:
  97   TEXT          { std::swap ($$, $1); }
  98 | NUMBER        { $$ = string_cast ($1); }
  99 ;
 100 %%
 101
 102 namespace yy
 103 {
 104   // The yylex function providing subsequent tokens:
 105   // TEXT         "I have three numbers for you."
 106   // NUMBER       1
 107   // NUMBER       2
 108   // NUMBER       3
 109   // TEXT         "And that's all!"
 110   // END_OF_FILE
 111
 112   static
 113   parser::symbol_type
 114   yylex ()
 115   {
 116     static int stage = -1;
 117     ++stage;
 118     parser::location_type loc(0, stage + 1, stage + 1);
 119     switch (stage)
 120       {
 121       case 0:
 122         return parser::make_TEXT ("I have three numbers for you.", loc);
 123       case 1:
 124       case 2:
 125       case 3:
 126         return parser::make_NUMBER (stage, loc);
 127       case 4:
 128         return parser::make_TEXT ("And that's all!", loc);
 129       default:
 130         return parser::make_END_OF_FILE (loc);
 131       }
 132   }
 133
 134   // Mandatory error function
 135   void
 136   parser::error (const parser::location_type& loc, const std::string& msg)
 137   {
 138     std::cerr << loc << ": " << msg << std::endl;
 139   }
 140 }
 141
 142 int
 143 main ()
 144 {
 145   yy::parser p;
 146   p.set_debug_level (!!getenv ("YYDEBUG"));
 147   return p.parse ();
 148 }
 149
 150 // Local Variables:
 151 // mode: C++
 152 // End: