Vaucanson: regexp.hxx Source File

00001 // regexp.hxx: this file is part of the Vaucanson project.
00002 //
00003 // Vaucanson, a generic library for finite state machines.
00004 //
00005 // Copyright (C) 2007, 2008 The Vaucanson Group.
00006 //
00007 // This program is free software; you can redistribute it and/or
00008 // modify it under the terms of the GNU General Public License
00009 // as published by the Free Software Foundation; either version 2
00010 // of the License, or (at your option) any later version.
00011 //
00012 // The complete GNU General Public Licence Notice can be found as the
00013 // `COPYING' file in the root directory.
00014 //
00015 // The Vaucanson Group consists of people listed in the `AUTHORS' file.
00016 //
00017 
00018 #ifndef VCSN_XML_REGEXP_HXX
00019 # define VCSN_XML_REGEXP_HXX
00020 
00021 # include <set>
00022 
00023 # include <xercesc/util/XMLString.hpp>
00024 
00025 # include <vaucanson/algebra/concept/monoid_base.hh>
00026 # include <vaucanson/algebra/concept/freemonoid_base.hh>
00027 
00028 # include <vaucanson/xml/tools.hh>
00029 
00030 namespace vcsn
00031 {
00032   namespace xml
00033   {
00034     /*
00035      * RegexpHandler
00036      */
00037     template <typename T>
00038     RegexpHandler<T>::RegexpHandler (xercesc::SAX2XMLReader* parser,
00039                                Handler& root,
00040                                T param)
00041       : Handler(parser, root),
00042         end_(eq_.typedRegExp),
00043         param_(param),
00044         lefth_(0)
00045     {
00046     }
00047 
00048     template <typename T>
00049     RegexpHandler<T>::RegexpHandler (xercesc::SAX2XMLReader* parser,
00050                                Handler& root,
00051                                T param,
00052                                XMLCh* end)
00053       : Handler(parser, root),
00054         end_(end),
00055         param_(param),
00056         lefth_(0)
00057     {
00058     }
00059 
00060     template <typename T>
00061     RegexpHandler<T>::~RegexpHandler()
00062     {
00063       delete lefth_;
00064     }
00065 
00066     template <typename T>
00067     void
00068     RegexpHandler<T>::start (const XMLCh* const,
00069                                  const XMLCh* const localname,
00070                                  const XMLCh* const,
00071                                  const xercesc::Attributes&)
00072     {
00073       if (!(lefth_ = create(localname)))
00074         error::token(localname);
00075       else
00076         parser_->setContentHandler(lefth_);
00077     }
00078 
00079     template <typename T>
00080     void
00081     RegexpHandler<T>::end (const XMLCh* const,
00082                                const XMLCh* const localname,
00083                                const XMLCh* const)
00084     {
00085       using namespace xercesc;
00086       if (XMLString::equals(end_, localname))
00087       {
00088         param_ = lefth_->series();
00089         parser_->setContentHandler(&root_);
00090       }
00091       else
00092         error::token(localname);
00093     }
00094 
00095     template <typename T>
00096     T&
00097     RegexpHandler<T>::series()
00098     {
00099       return param_;
00100     }
00101 
00102     template <typename T>
00103     T&
00104     RegexpHandler<T>::series(T& param)
00105     {
00106       param_ = param;
00107       return param_;
00108     }
00109 
00110     /*
00111      * StarHandler
00112      */
00113     template <typename T>
00114     StarHandler<T>::StarHandler (xercesc::SAX2XMLReader* parser,
00115                                Handler& root,
00116                                T param)
00117       : RegexpHandler<T>(parser, root, param),
00118         in_(0)
00119     {
00120       end_ = eq_.star;
00121     }
00122 
00123     template <typename T>
00124     void
00125     StarHandler<T>::start (const XMLCh* const,
00126                                  const XMLCh* const localname,
00127                                  const XMLCh* const,
00128                                  const xercesc::Attributes&)
00129     {
00130       using namespace xercesc;
00131       in_++;
00132       if (in_ == 1 && (lefth_ = create(localname)))
00133         parser_->setContentHandler(lefth_);
00134       else
00135         error::token(localname);
00136     }
00137 
00138     template <typename T>
00139     void
00140     StarHandler<T>::end (const XMLCh* const,
00141                                const XMLCh* const localname,
00142                                const XMLCh* const)
00143     {
00144       using namespace xercesc;
00145       if (XMLString::equals(end_, localname))
00146       {
00147         param_ = lefth_->series().star();
00148         parser_->setContentHandler(&root_);
00149       }
00150       else
00151         error::token(localname);
00152     }
00153 
00154     /*
00155      * AtomHandler
00156      */
00157     template <typename T>
00158     AtomHandler<T>::AtomHandler (xercesc::SAX2XMLReader* parser,
00159                                Handler& root,
00160                                T param,
00161                                XMLCh* end)
00162       : RegexpHandler<T>(parser, root, param, end)
00163     {
00164     }
00165 
00166     template <typename T>
00167     void
00168     AtomHandler<T>::start (const XMLCh* const,
00169                                  const XMLCh* const localname,
00170                                  const XMLCh* const,
00171                                  const xercesc::Attributes&)
00172     {
00173       error::token(localname);
00174     }
00175 
00176     template <typename T>
00177     void
00178     AtomHandler<T>::end (const XMLCh* const,
00179                                const XMLCh* const localname,
00180                                const XMLCh* const)
00181     {
00182       using namespace xercesc;
00183       if (XMLString::equals(end_, localname))
00184         parser_->setContentHandler(&root_);
00185       else
00186         error::token(localname);
00187     }
00188 
00189     /*
00190      * WeightHandler
00191      */
00192     template <typename T>
00193     WeightHandler<T>::WeightHandler (xercesc::SAX2XMLReader* parser,
00194                                Handler& root,
00195                                T param)
00196       : RegexpHandler<T>(parser, root, param)
00197     {
00198       end_ = eq_.weight;
00199     }
00200 
00201     template <typename T>
00202     void
00203     WeightHandler<T>::start (const XMLCh* const,
00204                                  const XMLCh* const localname,
00205                                  const XMLCh* const,
00206                                  const xercesc::Attributes&)
00207     {
00208       error::token(localname);
00209     }
00210 
00211     template <typename T>
00212     void
00213     WeightHandler<T>::end (const XMLCh* const,
00214                                const XMLCh* const localname,
00215                                const XMLCh* const)
00216     {
00217       using namespace xercesc;
00218       if (XMLString::equals(end_, localname))
00219         parser_->setContentHandler(&root_);
00220       else
00221         error::token(localname);
00222     }
00223 
00224     /*
00225      * ExtMulHandler
00226      */
00227     template <typename T>
00228     ExtMulHandler<T>::ExtMulHandler (xercesc::SAX2XMLReader* parser,
00229                                Handler& root,
00230                                T param,
00231                                bool left)
00232       : RegexpHandler<T>(parser, root, param),
00233         left_(left),
00234         righth_(0)
00235     {
00236       if (left)
00237         end_ = eq_.leftExtMul;
00238       else
00239         end_ = eq_.rightExtMul;
00240     }
00241 
00242     template <typename T>
00243     ExtMulHandler<T>::~ExtMulHandler ()
00244     {
00245       delete righth_;
00246     }
00247 
00248     template <typename T>
00249     void
00250     ExtMulHandler<T>::start (const XMLCh* const,
00251                                  const XMLCh* const localname,
00252                                  const XMLCh* const,
00253                                  const xercesc::Attributes& attrs)
00254     {
00255       using namespace xercesc;
00256       if (XMLString::equals(eq_.weight, localname) &&
00257           (lefth_ = create_weight(attrs)))
00258         parser_->setContentHandler(lefth_);
00259       else if ((righth_ = create(localname)))
00260         parser_->setContentHandler(righth_);
00261       else
00262         error::token(localname);
00263     }
00264 
00265     template <typename T>
00266     void
00267     ExtMulHandler<T>::end (const XMLCh* const,
00268                                const XMLCh* const localname,
00269                                const XMLCh* const)
00270     {
00271       using namespace xercesc;
00272       if (XMLString::equals(end_, localname))
00273       {
00274         if (left_)
00275           param_ = lefth_->series() * righth_->series();
00276         else
00277           param_ = righth_->series() * lefth_->series();
00278         parser_->setContentHandler(&root_);
00279       }
00280       else
00281         error::token(localname);
00282     }
00283 
00284     /*
00285      * ProductHandler
00286      */
00287     // FIXME: should factorize
00288     template <typename T>
00289     ProductHandler<T>::ProductHandler (xercesc::SAX2XMLReader* parser,
00290                                Handler& root,
00291                                T param)
00292       : RegexpHandler<T>(parser, root, param),
00293         in_(1),
00294         righth_(0)
00295     {
00296       end_ = eq_.product;
00297     }
00298 
00299     template <typename T>
00300     ProductHandler<T>::~ProductHandler()
00301     {
00302       delete righth_;
00303     }
00304 
00305     template <typename T>
00306     void
00307     ProductHandler<T>::start (const XMLCh* const,
00308                                  const XMLCh* const localname,
00309                                  const XMLCh* const,
00310                                  const xercesc::Attributes&)
00311     {
00312       using namespace xercesc;
00313       if (in_ == 1 && (lefth_ = create(localname)))
00314         parser_->setContentHandler(lefth_);
00315       else if (in_ == 2 && (righth_ = create(localname)))
00316         parser_->setContentHandler(righth_);
00317       else
00318         error::token(localname);
00319       in_++;
00320     }
00321 
00322     template <typename T>
00323     void
00324     ProductHandler<T>::end (const XMLCh* const,
00325                                const XMLCh* const localname,
00326                                const XMLCh* const)
00327     {
00328       using namespace xercesc;
00329       if (XMLString::equals(end_, localname))
00330       {
00331         param_ = lefth_->series() * righth_->series();
00332         parser_->setContentHandler(&root_);
00333       }
00334       else if (!XMLString::equals(eq_.monGen, localname))
00335         error::token(localname);
00336     }
00337     /*
00338      * SumHandler
00339      */
00340     template <typename T>
00341     SumHandler<T>::SumHandler (xercesc::SAX2XMLReader* parser,
00342                                Handler& root,
00343                                T param)
00344       : RegexpHandler<T>(parser, root, param),
00345         in_(1),
00346         righth_(0)
00347     {
00348       end_ = eq_.sum;
00349     }
00350 
00351     template <typename T>
00352     SumHandler<T>::~SumHandler ()
00353     {
00354       delete righth_;
00355     }
00356 
00357     template <typename T>
00358     void
00359     SumHandler<T>::start (const XMLCh* const,
00360                                  const XMLCh* const localname,
00361                                  const XMLCh* const,
00362                                  const xercesc::Attributes&)
00363     {
00364       using namespace xercesc;
00365 
00366       if (in_ == 1 && (lefth_ = create(localname)))
00367         parser_->setContentHandler(lefth_);
00368       else if (in_ == 2 && (righth_ = create(localname)))
00369         parser_->setContentHandler(righth_);
00370       else
00371         error::token(localname);
00372 
00373       in_++;
00374     }
00375 
00376     template <typename T>
00377     void
00378     SumHandler<T>::end (const XMLCh* const,
00379                                const XMLCh* const localname,
00380                                const XMLCh* const)
00381     {
00382       using namespace xercesc;
00383 
00384       if (XMLString::equals(end_, localname))
00385       {
00386         param_ = lefth_->series() + righth_->series();
00387         parser_->setContentHandler(&root_);
00388       }
00389       else if (!XMLString::equals(eq_.monGen, localname))
00390         error::token(localname);
00391     }
00392 
00393     /*
00394      * MonElmtHandler
00395      */
00396     template <typename T>
00397     MonElmtHandler<T>::MonElmtHandler (xercesc::SAX2XMLReader* parser,
00398                                Handler& root,
00399                                T param)
00400       : RegexpHandler<T>(parser, root, param),
00401         mongenh_(0)
00402     {
00403       end_ = eq_.monElmt;
00404     }
00405 
00406     template <typename T>
00407     void
00408     MonElmtHandler<T>::start (const XMLCh* const,
00409                                  const XMLCh* const localname,
00410                                  const XMLCh* const,
00411                                  const xercesc::Attributes& attrs)
00412     {
00413       // FIXME: This code is very similar to the one used by
00414       // FreeMonoidHandler::start. Ultimately we should provide a way to
00415       // parse "sequences of" (to promote reusability, and ease transcription
00416       // from the XSD to parser code).
00417       using namespace xercesc;
00418 
00419       if (XMLString::equals(eq_.monGen, localname))
00420       {
00421         typedef typename T::set_t::monoid_t monoid_t;
00422         typedef T actee_t;
00423 
00424         // When we have a monGen, we will concatenate param_ with it.
00425         monGenAction<actee_t> action(param_);
00426 
00427         // Delete the old handler.
00428         delete mongenh_;
00429 
00430         // Choose statically the kind of generator.
00431         if (algebra::letter_traits<typename monoid_t::alphabet_t::letter_t>::kind() == "simple")
00432         {
00433           const XMLCh* value = tools::get_attribute(attrs, "value");
00434           mongenh_ = new monGenHandler<monoid_t, actee_t>(parser_, *this, action, value);
00435         }
00436         else
00437           mongenh_ = new monGenTupleHandler<monoid_t, actee_t>(parser_, *this, action);
00438 
00439         // Setup the new handler.
00440         parser_->setContentHandler(mongenh_);
00441       }
00442       else
00443         error::token(localname);
00444     }
00445 
00446     template <typename T>
00447     void
00448     MonElmtHandler<T>::end (const XMLCh* const,
00449                                const XMLCh* const localname,
00450                                const XMLCh* const)
00451     {
00452       using namespace xercesc;
00453 
00454       if (XMLString::equals(end_, localname))
00455       {
00456         // We are done with the "parent", so delete remaining data.
00457         delete mongenh_;
00458 
00459         // Go up one level.
00460         parser_->setContentHandler(&root_);
00461       }
00462       else if (!XMLString::equals(eq_.monGen, localname))
00463         error::token(localname);
00464     }
00465 
00466   } // !xml
00467 } // !vcsn
00468 
00469 #endif // !VCSN_XML_REGEXP_HXX