C:/nobackup/private/physical_svn/trunk/source/parser.cpp

Go to the documentation of this file.

/*=============================================================================
    physical quantities / units / constants
    Copyright (c) 2006, 2007 Martin Schulz
    http://physical.sourceforge.net
  
    This is private code by Martin Schulz.
  
    Use, modification and distribution is subject to the Boost Software
    License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
    http://www.boost.org/LICENSE_1_0.txt)
=============================================================================*/

#include "physical/parser.hpp"
#include "physical/dynamicphysical.hpp"
#include "physical/unitsymbol.hpp"

// boost spirit parser generator:
#include <boost/spirit.hpp>
#include <boost/spirit/phoenix/functions.hpp>

namespace physical {

        namespace parser {

      namespace detail {

                   namespace spirit=boost::spirit;

                   struct unit_closure: public spirit::closure<unit_closure, DynamicPhysical<SI> >
                   {
                           member1 val;
                   };

                   struct quantity_power_impl
                   {
                           template <typename Quantity, typename Exponent>
                           struct result
                           {
                                   typedef DynamicPhysical<SI> type;
                           };

                           template <typename Quantity, typename Exponent>
                           DynamicPhysical<SI> operator()(const Quantity& q, Exponent const e) const
                           {
                                   int n=e;
                                   DynamicPhysical<SI> r=1.;
                                   while(n>0) { --n; r = r * q;};
                                   while(n<0) { ++n; r = r / q;};
                                   return r;
                           }
                   };

                   phoenix::function<quantity_power_impl> const quantity_power = quantity_power_impl();

                   struct unit_parser : public spirit::grammar<unit_parser, unit_closure::context_t>
                           {
                                   template <typename ScannerT>
                                   struct definition
                                   {
                                           spirit::symbols<physical::DynamicPhysical<SI> > symbol; 
                                           spirit::symbols<physical::DynamicPhysical<SI> > prefix; 
                                           typedef      spirit::rule<ScannerT, unit_closure::context_t> rule_t;
                                           rule_t symbol_exp, unit, quantity, top;
                                        
                                           definition(unit_parser const& self)  { 
                                                   namespace unitsymbol=physical::unitsymbol_si_double;

                                                   symbol.add("m",              unitsymbol::m);
                                                   symbol.add("g",              unitsymbol::g);
                                                   symbol.add("s",              unitsymbol::s);
                                                   symbol.add("A",              unitsymbol::A);
                                                   symbol.add("K",              unitsymbol::K);
                                                   symbol.add("mol",       unitsymbol::mol);
                                                   symbol.add("cd",        unitsymbol::cd);
                                                   symbol.add("rad",       unitsymbol::rad);
                                                   symbol.add("sr",        unitsymbol::sr);
                                                   symbol.add("Hz",        unitsymbol::Hz);
                                                   symbol.add("N",              unitsymbol::N);
                                                   symbol.add("Pa",        unitsymbol::Pa);
                                                   symbol.add("J",              unitsymbol::J);
                                                   symbol.add("W",              unitsymbol::W);
                                                   symbol.add("C",              unitsymbol::C);
                                                   symbol.add("V",              unitsymbol::V);
                                                   symbol.add("Ohm",       unitsymbol::Omega); // special character?
                                                   symbol.add("S",              unitsymbol::S);
                                                   symbol.add("Wb",        unitsymbol::Wb);
                                                   symbol.add("T",              unitsymbol::T);
                                                   symbol.add("lm",        unitsymbol::lm);
                                                   symbol.add("lx",        unitsymbol::lx);
                                                   symbol.add("Bq",        unitsymbol::Bq);
                                                   symbol.add("Gy",        unitsymbol::Gy);
                                                   symbol.add("Sv",        unitsymbol::Sv);
                                                   symbol.add("kat",       unitsymbol::kat);
                                                   // Fixme what about celsius, Fahrenheit, reaumur ?
                                                   // Fixme what about day, hour, minute ?
                                                   // Fixme what about long unit names? (meter, second..)
                                                   prefix.add("Y",              1.e24);
                                                   prefix.add("Z",              1.e21);
                                                   prefix.add("E",              1.e18);
                                                   prefix.add("P",              1.e15);
                                                   prefix.add("T",              1.e12);
                                                   prefix.add("G",              1.e9);
                                                   prefix.add("M",              1.e6);
                                                   prefix.add("k",              1.e3);
                                                   prefix.add("h",              1.e2);
                                                   prefix.add("da",        1.e1);
                                                   prefix.add("d",              1.e-1);
                                                   prefix.add("c",              1.e-2);
                                                   prefix.add("m",              1.e-3);
                                                   prefix.add("u",              1.e-6); // use some special character for mu?
                                                   prefix.add("mu",        1.e-6);
                                                   prefix.add("n",              1.e-9);
                                                   prefix.add("p",              1.e-12);
                                                   prefix.add("f",              1.e-15);
                                                   prefix.add("a",              1.e-18);
                                                   prefix.add("z",              1.e-21);
                                                   prefix.add("y",              1.e-24);

                                                   symbol_exp = spirit::epsilon_p[symbol_exp.val = unit_si_double::unity] >>
                                                           (
                                                                   symbol[symbol_exp.val = phoenix::arg1] 
                                                           >> !('^' >> spirit::int_p[symbol_exp.val =  quantity_power(symbol_exp.val, phoenix::arg1)])
                                                           ) || (
                                                              prefix[symbol_exp.val  = phoenix::arg1] 
                                                           >> symbol[symbol_exp.val *= phoenix::arg1] 
                                                           >> !('^' >> spirit::int_p[symbol_exp.val =  quantity_power(symbol_exp.val, phoenix::arg1)])
                                                           );

                                                           unit = spirit::epsilon_p[unit.val = unit_si_double::unity] >>
                                                               ( 
                                                                           spirit::str_p("[]") || spirit::str_p("[1]")
                                                                   ) || (
                                                                           "[" >>        symbol_exp[unit.val = unit.val * phoenix::arg1] 
                                                                           >> *( ("*" >> symbol_exp[unit.val = unit.val * phoenix::arg1] ) 
                                                                                   || ("/" >> symbol_exp[unit.val = unit.val / phoenix::arg1] ) 
                                                                                   ) >> "]"
                                                                   );

                                                   quantity = spirit::real_p[quantity.val = phoenix::arg1] 
                                                                    >> !(unit[quantity.val = quantity.val * phoenix::arg1]);

                                                           top = quantity[self.val = phoenix::arg1];
                                           };

                                           rule_t const& start() const { return top; }
                                   };
                           };

         }; // namespace detail



      parser_exception::parser_exception(const std::string& s, std::size_t n)
         : string_to_parse(s)
         , sucessfully_parsed_up_to(n)
         , std::runtime_error("physical parser error")
      { };


      DynamicPhysical<SI> Parser::parse(std::string formula) {

#ifdef BOOST_HAS_THREADS
         // FIXME: if you move the parser object into the class, define some scoped lock here 
         // (additional mutex in class) to protect grammar (closure!) from concurrent access.
#endif
         physical::parser::detail::unit_parser g;
                        physical::DynamicPhysical<SI> q;

                        boost::spirit::parse_info<> info = boost::spirit::parse(formula.c_str(), g[phoenix::var(q) = phoenix::arg1], boost::spirit::space_p);

                        if (info.full) 
            return q;
                        else
                                throw parser_exception(formula, info.length);
                };

        }; // namespace parser

}; // namespace physical

---

hosted on