examples/variant.yy

   1 /*
   2   Copyright (C) 2008-2012 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 %skeleton "lalr1.cc"
  20 %defines
  21 %define api.token.constructor
  22 %define parse.assert
  23 %define variant
  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& s)
  52     {
  53       std::copy (s.begin (), s.end (),
  54                  std::ostream_iterator<strings_type::value_type> (o, "\n"));
  55       return o;
  56     }
  57   }
  58
  59   // Conversion to string.
  60   template <typename T>
  61     inline
  62     std::string
  63     string_cast (const T& t)
  64   {
  65     std::ostringstream o;
  66     o << t;
  67     return o.str ();
  68   }
  69 }
  70
  71 %token <::std::string> TEXT;
  72 %token <int> NUMBER;
  73 %printer { debug_stream () << $$; }
  74    <int> <::std::string> <::std::list<std::string>>;
  75 %token END_OF_FILE 0;
  76
  77 %type <::std::string> item;
  78 %type <::std::list<std::string>> list;
  79
  80 %%
  81
  82 result:
  83   list  { std::cout << $1 << std::endl; }
  84 ;
  85
  86 list:
  87   /* nothing */ { /* Generates an empty string list */ }
  88 | list item     { std::swap ($$, $1); $$.push_back ($2); }
  89 ;
  90
  91 item:
  92   TEXT          { std::swap ($$, $1); }
  93 | NUMBER        { $$ = string_cast ($1); }
  94 ;
  95 %%
  96
  97 namespace yy
  98 {
  99   // The yylex function providing subsequent tokens:
 100   // TEXT         "I have three numbers for you."
 101   // NUMBER       1
 102   // NUMBER       2
 103   // NUMBER       3
 104   // TEXT         "And that's all!"
 105   // END_OF_FILE
 106
 107   static
 108   parser::symbol_type
 109   yylex ()
 110   {
 111     static int stage = -1;
 112     ++stage;
 113     parser::location_type loc(0, stage + 1, stage + 1);
 114     switch (stage)
 115       {
 116       case 0:
 117         return parser::make_TEXT ("I have three numbers for you.", loc);
 118       case 1:
 119       case 2:
 120       case 3:
 121         return parser::make_NUMBER (stage, loc);
 122       case 4:
 123         return parser::make_TEXT ("And that's all!", loc);
 124       default:
 125         return parser::make_END_OF_FILE (loc);
 126       }
 127   }
 128
 129   // Mandatory error function
 130   void
 131   parser::error (const parser::location_type& loc, const std::string& msg)
 132   {
 133     std::cerr << loc << ": " << msg << std::endl;
 134   }
 135 }
 136
 137 int
 138 main ()
 139 {
 140   yy::parser p;
 141   p.set_debug_level (!!getenv ("YYDEBUG"));
 142   return p.parse ();
 143 }
 144
 145 // Local Variables:
 146 // mode: C++
 147 // End: