parser.cpp

2009 ROBOCUP 仿真2DSERVER 源码

// -*-c++-*-

/***************************************************************************
                                parser.cpp
                          Parser for config options
                             -------------------
    begin                : 15-MAY-2003
    copyright            : (C) 2003 by The RoboCup Soccer Server
                           Maintenance Group.
    email                : [e-mail]
***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU LGPL as published by the Free Software  *
 *   Foundation; either version 2 of the License, or (at your option) any  *
 *   later version.                                                        *
 *                                                                         *
 ***************************************************************************/

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include "parser.hpp"

#include "builder.hpp"

#ifdef HAVE_SSTREAM
#include <sstream>
#else
#include <strstream>
#endif

#include <iterator>

#include <cerrno>
#include <climits>

#include <boost/filesystem/operations.hpp>
#include <boost/filesystem/fstream.hpp>
#include <boost/filesystem/exception.hpp>
// #define BOOST_SPIRIT_DEBUG

#include <boost/spirit.hpp>
#include <boost/function.hpp>
#include <boost/bind.hpp>

namespace {

bool
isQuated( const std::string & str )
{
    return ( str.length() >= 2
             && ( ( *str.begin() == '\"' && *str.rbegin() == '\"' )
                  || ( *str.begin() == '\'' && *str.rbegin() == '\'' )
                  )
             );
}

std::string
cleanString( std::string str )
{
    if ( str.empty() )
    {
        return str;
    }

    if ( *str.begin() == '\'' )
    {
        if ( *str.rbegin() == '\''  )
        {
            str = str.substr( 1, str.length() - 2 );
        }
        else
        {
            return str;
        }

        for ( std::string::size_type esc = str.find( "\\'" );
              esc != std::string::npos;
              esc = str.find( "\\'" ) )
        {
            str.replace( esc, 2, "'" );
        }
    }
    else if ( *str.begin() == '"' )
    {
        if ( *str.rbegin() == '"'  )
        {
            str = str.substr( 1, str.length() - 2 );
        }
        else
        {
            return str;
        }

        for ( std::string::size_type esc = str.find( "\\\"" );
              esc != std::string::npos;
              esc = str.find( "\\\"" ) )
        {
            str.replace( esc, 2, "\"" );
        }
    }
    return str;
}

std::string
cleanString( const char * begin,
             const char * end )
{
    return cleanString( std::string( begin, end ) );
}

}


namespace rcss {
namespace conf {

const char * Parser::ErrorStrs[] = { "None",
                                     "'=' expected",
                                     "'::' expected",
                                     "value expected",
                                     "string expected" };



class ParseErrorHandler {
public:
    static
    boost::spirit::error_status<> parseError( const Parser * parser,
                                              const boost::spirit::rule<>::scanner_t & scanner,
                                              const boost::spirit::parser_error< Parser::Errors > & error )
      {
          std::string what;
          if ( error.where + 10 > scanner.last )
          {
              what = std::string( error.where, scanner.last );
          }
          else
          {
              what = std::string( error.where,
                                  error.where + 10 );
          }

          std::string::iterator newline = std::find( what.begin(),
                                                     what.end(),
                                                     '\n' );
          if ( newline != what.end() )
          {
              what = std::string( what.begin(), newline );
          }

          parser->m_builder.parseError( what,
                                        Parser::ErrorStrs[ error.descriptor ],
                                        parser->m_stack.front().m_name,
                                        parser->m_stack.front().m_lineno );
          return boost::spirit::error_status<>( boost::spirit::error_status<>::fail );
      }
};


Parser::Parser( Builder & builder )
    : m_builder( builder )
{
    m_builder.addedToParser( *this );
}

Parser::~Parser()
{
    m_builder.removedFromParser();
}


bool
Parser::parse( int argc,
               const char * const * argv )
{
#ifdef HAVE_SSTREAM
    std::stringstream strm;
#else
    std::strstream strm;
#endif
    if ( argc > 1 )
    {
        std::string arg( argv[1] );
        if ( arg.find_first_of( " \t" ) != std::string::npos
             && ! isQuated( arg ) )
        {
            strm << "\'" << arg << "\'";
        }
        else
        {
            strm << arg;
        }
    }

    for ( int i = 2; i < argc; ++i )
    {
        std::string arg( argv[i] );
        if ( arg.find_first_of( " \t" ) != std::string::npos
             && ! isQuated( arg ) )
        {
            strm << ' ' << '\'' << arg << '\'';
        }
        else
        {
            strm << ' ' << arg;
        }
    }
#ifndef HAVE_SSTREAM
    strm << std::ends;
#else
    strm << std::flush;
#endif
    bool res = rcss::Parser::parse( strm, "cmd line args" );
#ifndef HAVE_SSTREAM
    strm.freeze( false );
#endif
    return res;
}

bool
Parser::parse( std::istream & strm )
{
    return rcss::Parser::parse( strm );
}

bool
Parser::parse( std::istream & strm,
               const std::string & name )
{
    return rcss::Parser::parse( strm, name );
}

bool
Parser::parse( const boost::filesystem::path & file )
{
    return rcss::Parser::parse( file );
}

bool
Parser::parseCreateConf( const boost::filesystem::path & conf_name,
                         const std::string & module_name )
{
    std::string native_path = conf_name.native_file_string();
    boost::filesystem::ifstream conf( conf_name );
    if ( ! conf.is_open() )
    {
        m_builder.creatingConfFile( native_path );
        boost::filesystem::ofstream new_conf( conf_name );
        if ( new_conf.is_open() )
        {
            m_builder.createConfFile( new_conf, module_name );
            new_conf.close();
            m_builder.createdConfFile( native_path );
            return true;
        }
        else
        {
            std::cerr << "is not opened. Parser::parseCreateConf " << native_path << std::endl;
            m_builder.confCreationFailed( native_path, errno );
            return false;
        }
    }
    else
    {
        bool rval = parse( conf, native_path );
        conf.close();
        return rval;
    }
}

bool
Parser::doParse( std::istream & strm )
{
    m_builder.reset();
    m_stack.push_front( StreamState( strm,  getStreamName(), 1 ) );
    bool rval = boostParse();
    m_stack.pop_front();
    rval = rval && m_builder.success();
    return rval;
}

void
Parser::countNewLines( const char * begin,
                       const char * end )
{
    int count = 0;
    for ( const char * i = begin; i != end; ++i )
    {
        if ( '\n' == *i )
        {
            ++count;
        }
    }

    if ( ! m_stack.empty() )
    {
        m_stack.front().m_lineno += count;
    }
}

bool
Parser::include( const char * begin,
                 const char * end )
{
    std::string incname = cleanString( begin, end );
    boost::filesystem::path path;
    try
    {
        path = boost::filesystem::path( incname,
                                        &boost::filesystem::native );
    }
    catch(...)
    {
        try
        {
            path = boost::filesystem::path( incname );
        }
        catch ( const std::exception & e )
        {
            m_builder.includeFailed( incname,
                                     e.what(),
                                     m_stack.front().m_name,
                                     m_stack.front().m_lineno );
            return false;
        }
    }

    boost::filesystem::path full_name;
    if ( path.has_root_directory() )
    {
        full_name = path;
    }
    else
    {
        const std::string & curr_path = m_stack.front().m_name;
        if ( curr_path.empty()
             || curr_path == "cmd line args"
             || curr_path == "anonymous stream" )
        {
            full_name = complete( path );
        }
        else
        {
            boost::filesystem::path branch( curr_path,
                                            boost::filesystem::native );
            branch = branch.branch_path();
            full_name = branch / path;
        }
    }