Console/Parse.cc

   1 // $Id$
   2 //
   3 // Copyright (C) 2008
   4 // Fraunhofer Institute for Open Communication Systems (FOKUS)
   5 // Competence Center NETwork research (NET), St. Augustin, GERMANY
   6 //     Stefan Bund <g0dil@berlios.de>
   7 //
   8 // This program is free software; you can redistribute it and/or modify
   9 // it under the terms of the GNU General Public License as published by
  10 // the Free Software Foundation; either version 2 of the License, or
  11 // (at your option) any later version.
  12 //
  13 // This program is distributed in the hope that it will be useful,
  14 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 // GNU General Public License for more details.
  17 //
  18 // You should have received a copy of the GNU General Public License
  19 // along with this program; if not, write to the
  20 // Free Software Foundation, Inc.,
  21 // 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  22
  23 /** \file
  24     \brief Parse non-inline non-template implementation */
  25
  26 #include "Parse.hh"
  27 #include "Parse.ih"
  28
  29 // Custom includes
  30 #include <cerrno>
  31 #include <boost/iterator/transform_iterator.hpp>
  32 #include <boost/spirit/iterator/file_iterator.hpp>
  33 #include "../Utils/String.hh"
  34 #include "../Utils/Exception.hh"
  35
  36 //#include "Parse.mpp"
  37 #define prefix_
  38 ///////////////////////////////cc.p////////////////////////////////////////
  39
  40 namespace senf {
  41 namespace console {
  42 namespace detail {
  43
  44     struct ParserAccess
  45     {
  46         static void init(ParseCommandInfo & info)
  47             { info.init(); }
  48
  49         static void setBuiltin(ParseCommandInfo & info, ParseCommandInfo::BuiltinCommand builtin)
  50             { info.setBuiltin(builtin); }
  51
  52         static void setCommand(ParseCommandInfo & info, std::vector<std::string> & commandPath)
  53             { info.setCommand(commandPath); }
  54
  55         static void startArgument(ParseCommandInfo & info)
  56             { info.startArgument(); }
  57
  58         static void endArgument(ParseCommandInfo & info)
  59             { info.endArgument(); }
  60
  61         static void addToken(ParseCommandInfo & info, ArgumentToken const & token)
  62             { info.addToken(token); }
  63
  64         static void finalize(ParseCommandInfo & info)
  65             { info.finalize(); }
  66
  67         static ArgumentToken makeToken(std::string const & token)
  68             { return ArgumentToken(token); }
  69     };
  70
  71     struct ParseDispatcher
  72     {
  73         ParseCommandInfo info_;
  74         CommandParser::Callback cb_;
  75
  76         struct BindInfo {
  77             BindInfo( ParseDispatcher & d, CommandParser::Callback cb)
  78                 : dispatcher (d) { dispatcher.cb_ = cb; }
  79             ~BindInfo() { dispatcher.cb_  = 0; }
  80
  81             ParseDispatcher & dispatcher;
  82         };
  83
  84         void beginCommand(std::vector<std::string> & command)
  85             { ParserAccess::init(info_);
  86               ParserAccess::setCommand(info_, command); }
  87
  88         void endCommand()
  89             { ParserAccess::finalize(info_); cb_(info_); }
  90
  91         void pushArgument(std::string const & argument)
  92             { ParserAccess::startArgument(info_);
  93               ParserAccess::addToken(info_, ParserAccess::makeToken(argument));
  94               ParserAccess::endArgument(info_); }
  95
  96         void openGroup()
  97             { ParserAccess::startArgument(info_); }
  98
  99         void closeGroup()
 100             { ParserAccess::endArgument(info_); }
 101
 102         void pushPunctuation(std::string const & token)
 103             { ParserAccess::addToken(info_, ParserAccess::makeToken(token)); }
 104
 105         void pushWord(std::string const & token)
 106             { ParserAccess::addToken(info_, ParserAccess::makeToken(token)); }
 107
 108         void builtin_cd(std::vector<std::string> & path)
 109             { ParserAccess::init(info_);
 110               ParserAccess::setBuiltin(info_, ParseCommandInfo::BuiltinCD);
 111               setBuiltinPathArg(path);
 112               ParserAccess::finalize(info_); cb_(info_); }
 113
 114         void builtin_ls(std::vector<std::string> & path)
 115             { ParserAccess::init(info_);
 116               ParserAccess::setBuiltin(info_, ParseCommandInfo::BuiltinLS);
 117               setBuiltinPathArg(path);
 118               ParserAccess::finalize(info_); cb_(info_); }
 119
 120         void pushDirectory(std::vector<std::string> & path)
 121             { ParserAccess::init(info_);
 122               ParserAccess::setBuiltin(info_, ParseCommandInfo::BuiltinPUSHD);
 123               setBuiltinPathArg(path);
 124               ParserAccess::finalize(info_); cb_(info_); }
 125
 126         void popDirectory()
 127             { ParserAccess::init(info_);
 128               ParserAccess::setBuiltin(info_, ParseCommandInfo::BuiltinPOPD);
 129               ParserAccess::finalize(info_); cb_(info_); }
 130
 131         void builtin_exit()
 132             { ParserAccess::init(info_);
 133               ParserAccess::setBuiltin(info_, ParseCommandInfo::BuiltinEXIT);
 134               ParserAccess::finalize(info_); cb_(info_); }
 135
 136         void setBuiltinPathArg(std::vector<std::string> & path)
 137             {
 138                 ParserAccess::startArgument(info_);
 139                 for (std::vector<std::string>::const_iterator i (path.begin());
 140                      i != path.end(); ++i)
 141                     ParserAccess::addToken(info_, ParserAccess::makeToken(*i));
 142                 ParserAccess::endArgument(info_);
 143             }
 144     };
 145
 146 }}}
 147
 148 ///////////////////////////////////////////////////////////////////////////
 149 // senf::console::ParseCommandInfo
 150
 151 struct senf::console::ParseCommandInfo::MakeRange
 152 {
 153     typedef ParseCommandInfo::argument_value_type result_type;
 154
 155     MakeRange() {}
 156     MakeRange(ParseCommandInfo::token_iterator b) : b_ (b) {}
 157
 158     senf::console::ParseCommandInfo::token_iterator b_;
 159
 160     result_type operator()(TempArguments::iterator::value_type const & v) const {
 161         return result_type( b_ + v.first, b_ + v.second );
 162     }
 163 };
 164
 165 prefix_ void senf::console::ParseCommandInfo::finalize()
 166 {
 167     arguments_.resize( tempArguments_.size() );
 168
 169     std::copy( boost::make_transform_iterator( tempArguments_.begin(),
 170                                                MakeRange(tokens_.begin()) ),
 171                boost::make_transform_iterator( tempArguments_.end(),
 172                                                MakeRange() ),
 173                arguments_.begin() );
 174
 175     tempArguments_.clear();
 176 }
 177
 178 prefix_ std::ostream & senf::console::operator<<(std::ostream & stream,
 179                                                  ParseCommandInfo const & info)
 180 {
 181     if (info.builtin() == ParseCommandInfo::NoBuiltin)
 182         stream << senf::stringJoin(info.commandPath(), "/");
 183     else {
 184         char const * builtins[] = { "", "cd", "ls", "pushd", "popd", "exit" };
 185         stream << "builtin-" << builtins[info.builtin()];
 186     }
 187
 188     ParseCommandInfo::ArgumentsRange args (info.arguments());
 189     for (ParseCommandInfo::argument_iterator i (args.begin()); i != args.end(); ++i) {
 190         ParseCommandInfo::token_iterator j (i->begin());
 191         stream << " [";
 192         if ( j != i->end() ) {
 193             for (;;) {
 194                 stream << "'" << j->value() << "'";
 195                 if ( ++j != i->end() ) stream << ' ';
 196                 else                   break;
 197             }
 198         }
 199         stream << "]";
 200     }
 201
 202     return stream;
 203 }
 204
 205 ///////////////////////////////////////////////////////////////////////////
 206 // senf::console::CommandParser
 207
 208 struct senf::console::CommandParser::Impl
 209 {
 210     typedef detail::CommandGrammar<detail::ParseDispatcher> Grammar;
 211
 212     detail::ParseDispatcher dispatcher;
 213     Grammar::Context context;
 214     Grammar grammar;
 215
 216     Impl() : dispatcher(), context(), grammar(dispatcher, context) {}
 217 };
 218
 219 prefix_ senf::console::CommandParser::CommandParser()
 220     : impl_ (new Impl())
 221 {}
 222
 223 prefix_ senf::console::CommandParser::~CommandParser()
 224 {}
 225
 226 prefix_ bool senf::console::CommandParser::parse(std::string command, Callback cb)
 227 {
 228     detail::ParseDispatcher::BindInfo bind (impl().dispatcher, cb);
 229     return boost::spirit::parse( command.begin(), command.end(),
 230                                  impl().grammar.use_parser<Impl::Grammar::CommandParser>(),
 231                                  impl().grammar.use_parser<Impl::Grammar::SkipParser>()
 232         ).full;
 233 }
 234
 235 prefix_ bool senf::console::CommandParser::parseFile(std::string filename, Callback cb)
 236 {
 237     detail::ParseDispatcher::BindInfo bind (impl().dispatcher, cb);
 238     boost::spirit::file_iterator<> i (filename);
 239     if (!i) throw SystemException(ENOENT SENF_EXC_DEBUGINFO);
 240     boost::spirit::file_iterator<> const i_end (i.make_end());
 241
 242     return boost::spirit::parse( i, i_end,
 243                                  impl().grammar.use_parser<Impl::Grammar::CommandParser>(),
 244                                  impl().grammar.use_parser<Impl::Grammar::SkipParser>()
 245         ).full;
 246 }
 247
 248 ///////////////////////////////cc.e////////////////////////////////////////
 249 #undef prefix_
 250 //#include "Parse.mpp"
 251
 252 \f
 253 // Local Variables:
 254 // mode: c++
 255 // fill-column: 100
 256 // comment-column: 40
 257 // c-file-style: "senf"
 258 // indent-tabs-mode: nil
 259 // ispell-local-dictionary: "american"
 260 // compile-command: "scons -u test"
 261 // End: