c++ - resueltos - Forma multiplataforma para obtener el número de línea de un archivo INI donde se encontró la opción dada

guardar y leer datos en un archivo.txt en c

Question

Buscando alguna biblioteca C ++ (como boost :: program_options) que pueda devolver el número de línea de un archivo INI, donde se encontró la opción o sección dada.

Casos de uso:

1. Pido a esa biblioteca que encuentre el valor "vvv" en la sección "[SSS]". La biblioteca devuelve el número de línea donde se encuentra "vvv" en la sección "[SSS]", o -1. Me da la capacidad de decir "línea 55: vvv debe ser <256".

2. Repito el archivo INI para las secciones y valigo sus nombres. Cuando se encuentra alguna sección salvaje, le digo: "línea 55: sección [Hahaha] es desconocida".

actualización: sé que "INI es más antiguo que el mamut", pero actualmente tengo que portar proyectos de ventanas grandes a plataformas cruzadas y no puedo deshacerme pronto de los archivos .ini.

Answer 1

Una vez más, aprovechó la oportunidad para jugar con Boost Spirit. Esta vez tengo que jugar con line_pos_iterator .

Aquí está el fruto de mi trabajo: https://gist.github.com/1425972

• Cuando POSITIONINFO == 0
  • la entrada es la transmisión
  • la salida es cadenas sin procesar (bueno, map<string, map<string, string> > para las secciones)

• Cuando POSITIONINFO == 1

  • la entrada está almacenada

  • la salida es textnode_t :

    struct textnode_t {
        int sline, eline, scol, ecol;
        string_t text;
    };

    Esto significa que el map<textnode_t, map<textnode_t, textnode_t> > resultante map<textnode_t, map<textnode_t, textnode_t> > es capaz de informar exactamente qué puntos de inicio y fin (línea, col) marcan los nodos de texto individuales. Ver salida de prueba para una demostración

  • Comentarios ( # , /* ... */ estilo) han sido implementados

  • El espacio en blanco es ''tolerado''

    name = value # usa un comentario para forzar la inclusión del espacio en blanco al final alternative = escape / con slash /

  • De-escape de las slashes se deja como un ejercicio

  • Los errores también se informan con la información de posición completa si está habilitada

NOTA El soporte C ++ 11 NO es necesario, pero lo usé para volcar el resultado del análisis sintáctico. Soy demasiado vago para escribirlo con C ++ 03 estilo de iterador detallado. :)

Todo el código, makefile, example.ini se puede encontrar aquí: https://gist.github.com/1425972

Código

/* inireader.h */
#pragma once

#define POSITIONINFO 0

#include <map>
#include <string>
#include <iterator>
#include <boost/tuple/tuple_comparison.hpp>

template <typename S=std::string, typename Cmp=std::less<S> >
    class IniFile
{
    public:
    IniFile(Cmp cmp=Cmp()) : _cmp(cmp) 
        {}

    IniFile(const std::string& filename, Cmp cmp=Cmp()) : _cmp(cmp)
        { open(filename); }

    void open(const std::string& filename);

    typedef S string_t;
#if POSITIONINFO
    struct textnode_t
    {
        int sline, eline,
            scol, ecol;
        string_t text;

        operator const string_t&() const { return text; }
        friend std::ostream& operator<<(std::ostream& os, const textnode_t& t)
        { 
            os << "[L:" << t.sline << ",C" << t.scol << " .. L" << t.eline << ",C" << t.ecol << ":";
            for (typename string_t::const_iterator it=t.text.begin(); it!=t.text.end(); ++it)
            switch (*it)
            {
                case ''/r'' : os << "//r"; break;
                case ''/n'' : os << "//n"; break;
                case ''/t'' : os << "//t"; break;
                case ''/0'' : os << "//0"; break;
                default:    os << *it  ; break;
            }
            return os << "]"; 
        }

        bool operator<(const textnode_t& o) const 
            { return boost::tie(text/*, sline, eline, scol, ecol*/) <
                     boost::tie(o.text/*, o.sline, o.eline, o.scol, o.ecol*/); }

        textnode_t() : sline(0), eline(0), scol(0), ecol(0) { }
    };
#else
    typedef string_t textnode_t;
#endif

    typedef std::pair<textnode_t, textnode_t>   keyvalue_t;
    typedef std::map<textnode_t, textnode_t>    section_t;
    typedef std::map<textnode_t, section_t> sections_t;

  private:
    Cmp _cmp;
};

///////////////////////////////////////
// template implementation
//#define BOOST_SPIRIT_DEBUG

#include <boost/spirit/include/qi.hpp>
#include <boost/spirit/include/support_istream_iterator.hpp>
#include <boost/spirit/include/support_line_pos_iterator.hpp>
#include <boost/spirit/include/phoenix.hpp>
#include <boost/fusion/adapted/std_pair.hpp>
#include <fstream>

namespace qi = boost::spirit::qi;
namespace phx= boost::phoenix;

namespace inireader
{
    struct printer
    {
        printer(std::ostream& os) : _os(os) {}
        std::ostream& _os;

        typedef boost::spirit::utf8_string string;

        void element(string const& tag, string const& value, int depth) const
        {
            for (int i = 0; i < (depth*4); ++i) // indent to depth
                _os << '' '';

            _os << "tag: " << tag;
            if (value != "")
                _os << ", value: " << value;
            _os << std::endl;
        }
    };

    void print_info(std::ostream& os, boost::spirit::info const& what)
    {
        using boost::spirit::basic_info_walker;

        printer pr(os);
        basic_info_walker<printer> walker(pr, what.tag, 0);
        boost::apply_visitor(walker, what.value);
    }

    template <typename It, typename Skipper, typename Ini>
        struct Grammar : qi::grammar<It, typename Ini::sections_t(), Skipper>
    {
        typedef typename Ini::string_t string_t;
        typedef typename Ini::textnode_t textnode_t;

        struct textbuilder
        {
            template <typename> struct result { typedef textnode_t type; };

            textbuilder(It begin) : _begin(begin) { }

            textnode_t operator()(const boost::iterator_range<It>& iters) const
            {
#if !POSITIONINFO
                return textnode_t(std::begin(iters), std::end(iters));
#else
                using boost::spirit::get_line;
                using boost::spirit::get_line_start;
                using boost::spirit::get_column;

                textnode_t element;
                element.text  = string_t       (std::begin(iters)  , std::end(iters));
                element.sline = get_line       (std::begin(iters));
                element.eline = get_line       (std::end(iters));
                It sol        = get_line_start (_begin             , std::begin(iters));
                element.scol  = get_column     (sol                , std::begin(iters));
                element.ecol  = get_column     (sol                , std::end(iters));

                return element;
#endif
            }

          private: 
            const It _begin;
        } makenode;

        Grammar(It begin) : Grammar::base_type(inifile), makenode(begin)
        {
            using namespace qi;
            txt_ch = (lit(''//') > char_) | (char_ - (eol | ''#'' | "/*"));

            key     = raw [ lexeme [ +(txt_ch - char_("=")) ] ] [ _val = phx::bind(makenode, _1) ];
            value   = raw [ lexeme [ +txt_ch ] ]                [ _val = phx::bind(makenode, _1) ];
            pair   %= key > ''='' > value;

            heading  = (''['' > raw [ +~char_('']'') ] > '']'') [ _val = phx::bind(makenode, _1) ];
            section %= heading >> +eol >> -((pair-heading) % +eol);
            inifile %= -(section % +eol) >> *eol > eoi;

            comment = 
                  (''#'' >> *(char_ - eol))
                | ("/*" > *(char_ - "*/") > "*/");

            //BOOST_SPIRIT_DEBUG_NODE(comment);
            //BOOST_SPIRIT_DEBUG_NODE(txt_ch);
            BOOST_SPIRIT_DEBUG_NODE(heading);
            BOOST_SPIRIT_DEBUG_NODE(section);
            BOOST_SPIRIT_DEBUG_NODE(key);
            BOOST_SPIRIT_DEBUG_NODE(value);
            BOOST_SPIRIT_DEBUG_NODE(pair);
            BOOST_SPIRIT_DEBUG_NODE(inifile);
        }

        typedef typename Ini::keyvalue_t keyvalue_t;
        typedef typename Ini::section_t  section_t;
        typedef typename Ini::sections_t sections_t;
        typedef typename string_t::value_type Char;
        qi::rule<It>                        comment;
        qi::rule<It, Char()>                txt_ch;
        qi::rule<It, textnode_t(), Skipper> key, value, heading;
        qi::rule<It, keyvalue_t(), Skipper> pair;
        qi::rule<It, std::pair<textnode_t, section_t>(), Skipper> section;
        qi::rule<It, sections_t(), Skipper> inifile;
    };

    template <typename It, typename Builder>
        typename Builder::template result<void>::type
            fragment(const It& first, const It& last, const Builder& builder)
            {
                size_t len = std::distance(first, last);
                It frag_end = first;
                std::advance(frag_end, std::min(10ul, len));
                return builder(boost::iterator_range<It>(first, frag_end));
            }
}

template <typename S, typename Cmp>
void IniFile<S, Cmp>::open(const std::string& filename)
{
    using namespace qi;

    std::ifstream ifs(filename.c_str());
    ifs.unsetf(std::ios::skipws);

#if POSITIONINFO
    typedef std::string::const_iterator RawIt;
    typedef boost::spirit::line_pos_iterator<RawIt> It;

    typedef rule<It> Skipper;

    std::string buffer(std::istreambuf_iterator<char>(ifs), (std::istreambuf_iterator<char>()));
    It f(buffer.begin()), l(buffer.end());
#else
    typedef boost::spirit::istream_iterator It;
    typedef rule<It> Skipper;

    It f(ifs), l;
#endif

    inireader::Grammar<It, Skipper, IniFile<S, Cmp> > grammar(f);
    Skipper skip = char_(" /t") | grammar.comment;

    try
    {
        sections_t data;
        bool ok = phrase_parse(f, l, grammar, skip, data);
        if (ok)
        {
            std::cout << "Parse success!" << std::endl;

///////// C++11 specific features for quick display //////////
            for (auto& section : data)
            {
                std::cout << "[" << section.first << "]" << std::endl;
                for (auto& pair : section.second)
                    std::cout << pair.first << " = " << pair.second << std::endl;
///////// End C++11 specific /////////////////////////////////
            }
        } else
        {
            std::cerr << "Parse failed" << std::endl;
        }
    } catch (const qi::expectation_failure<It>& e)
    {
        std::cerr << "Exception: " << e.what() << 
              " " << inireader::fragment(e.first, e.last, grammar.makenode) << "... ";
        inireader::print_info(std::cerr, e.what_);
    }
    if (f!=l)
    {
        std::cerr << "Stopped at: ''" << inireader::fragment(f, l, grammar.makenode) << "''" << std::endl;
    }
}

Entrada de demostración

[Cat1]
name1=100 #skipped

name2=200 /#not //skipped
name3=   dhfj dhjgfd/* skipped

*/

[Cat_2]
UsagePage=9
Usage=19
Offset=0x1204

/*
[Cat_2_bak]
UsagePage=9
Usage=19
Offset=0x1204
*/

[Cat_3]
UsagePage=12
Usage=39
#Usage4=39
Offset=0x12304

Salida de demostración (POSITIONINFO == 0)

Parse success!
[Cat1]
name1 = 100 
name2 = 200 /#not //skipped
name3 = dhfj dhjgfd
[Cat_2]
Offset = 0x1204
Usage = 19
UsagePage = 9
[Cat_3]
Offset = 0x12304
Usage = 39
UsagePage = 12

Salida de demostración (POSITIONINFO == 1)

Parse success!
[[L:1,C2 .. L1,C6:Cat1]]
[L:2,C2 .. L2,C7:name1] = [L:2,C8 .. L2,C12:100 ]
[L:6,C2 .. L6,C7:name2] = [L:6,C8 .. L6,C27:200 /#not //skipped]
[L:7,C2 .. L7,C7:name3] = [L:7,C11 .. L7,C22:dhfj dhjgfd]
[[L:13,C3 .. L13,C8:Cat_2]]
[L:16,C2 .. L16,C8:Offset] = [L:16,C9 .. L16,C15:0x1204]
[L:15,C2 .. L15,C7:Usage] = [L:15,C8 .. L15,C10:19]
[L:14,C2 .. L14,C11:UsagePage] = [L:14,C12 .. L14,C13:9]
[[L:25,C3 .. L25,C8:Cat_3]]
[L:29,C2 .. L29,C8:Offset] = [L:29,C9 .. L29,C16:0x12304]
[L:27,C2 .. L27,C7:Usage] = [L:27,C8 .. L27,C10:39]
[L:26,C2 .. L26,C11:UsagePage] = [L:26,C12 .. L26,C14:12]