CBNA_PHPBB_Analysis

Code:

#include <iostream>

#include <string>

#include <boost/fusion/include/adapt_struct.hpp>
#include <boost/fusion/include/std_tuple.hpp>

#include <boost/spirit/include/qi.hpp>
#include <boost/spirit/include/qi_grammar.hpp>

#include <boost/spirit/include/phoenix.hpp>

#include <boost/variant.hpp>
#include <boost/optional.hpp>

#include <pre/json/to_json.hpp>


namespace cbna { namespace bbcode {

  enum class node_t {
    NONE,
    BOLD,
    ITALIC,
    UNDERLINE,
    STRIKE,

    LEFT,
    RIGHT,
    CENTER,

    HR,

    QUOTE,
    SPOILER,

    IMG,
    URL,

    LIST,
  };

  enum class list_t {
    BULLETS = 0,
    ORDERED = 1
  };

  /**
   * Represents a bbcode node which may contain further bbcode
   */
  struct bbcode;

  /**
   * Represents a bbcode node which may contain further bbcode
   * and has an attribute information, like quoted message author.
   */
  struct bbcode_with_attribute;

  /**
   * Represents a bbcode listing
   */
  struct list;

  /**
   * HR node
   */
  struct hr_node {};

  using dimension_t = std::tuple<size_t, size_t>;

  struct img_node {
    node_t type{node_t::IMG};
    boost::optional<dimension_t> dimension;
    std::string url;
  };

  struct url_node {
    std::string url;
  };

  using bbcode_node =  
    boost::variant<
        boost::recursive_wrapper<bbcode>
      , boost::recursive_wrapper<bbcode_with_attribute>
      , boost::recursive_wrapper<list>
      , std::string
      , hr_node
      , img_node
      , url_node
    >;

  struct bbcode {
    node_t type{};
    std::vector<bbcode_node> entries{};
  };

  struct bbcode_with_attribute : public bbcode {
    boost::optional<std::string> attribute{};
  };

  struct list : public bbcode {
    list_t list_style{};
  };


}}

BOOST_FUSION_ADAPT_STRUCT(cbna::bbcode::hr_node)

BOOST_FUSION_ADAPT_STRUCT(cbna::bbcode::img_node,
  type,
  dimension,
  url
)

BOOST_FUSION_ADAPT_STRUCT(cbna::bbcode::url_node,
  url
)

BOOST_FUSION_ADAPT_STRUCT(cbna::bbcode::bbcode,
  type,
  entries
);

BOOST_FUSION_ADAPT_STRUCT(cbna::bbcode::bbcode_with_attribute,
  type,
  attribute,
  entries
);

BOOST_FUSION_ADAPT_STRUCT(cbna::bbcode::list,
  type,
  list_style,
  entries
);

namespace cbna { namespace bbcode {

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

  template<class Iterator>
  struct bbcode_grammar : public qi::grammar<Iterator, bbcode()> {

    bbcode_grammar() : bbcode_grammar::base_type(bbcodes)  {
      using qi::lit;
      using qi::char_;
      using qi::int_;
      using qi::_val;
      using qi::_1;
      using qi::eps;
      using qi::as_string;
      using qi::attr;
      using qi::hold;

      bbcodes = attr(node_t::NONE) >> +(possible_bbcodes[phx::push_back(phx::at_c<1>(_val), _1)]);

      possible_bbcodes =
        (  
            bold
          | italic
          | underline
          | strike

          | left
          | right
          | center

          | hr

          | quote
          | spoiler

          | img
          | url

          | list_
        )
        ;


      entry = possible_bbcodes | non_formatted;

      non_formatted = attr(node_t::NONE)        >> as_string[+(char_ - '[')];

      bold =          attr(node_t::BOLD)        >> "[b]" >> *entry >> "[/b]";
      italic =        attr(node_t::ITALIC)      >> "[i]" >> *entry >> "[/i]";
      underline =     attr(node_t::UNDERLINE)   >> "[u]" >> *entry >> "[/u]";
      strike =        attr(node_t::STRIKE)      >> "[strike]" >> *entry >> "[/strike]";

      left =          attr(node_t::LEFT)        >> "[left]" >> *entry >> "[/left]";
      right =         attr(node_t::RIGHT)       >> "[right]" >> *entry >> "[/right]";
      center =        attr(node_t::CENTER)      >> "[center]" >> *entry >> "[/center]";

      hr =            lit("[hr]")[_val = phx::construct<hr_node>()];

      quote =         attr(node_t::QUOTE)       >> "[quote" >> -("=" >> quoted_text) >> "]" >> *entry >> "[/quote]";
      spoiler =       attr(node_t::SPOILER)     >> "[spoiler" >> -("=" >> quoted_text) >> "]" >> *entry >> "[/spoiler]";

      img =           attr(node_t::IMG)         >> "[img" >> -dimension >> "]" >> as_string[+(char_ - '[')] >> "[/img]";
      dimension = "(" >> int_ >> "px," >> int_ >> "px)";
      url =           attr(node_t::URL)         >> "[url="
            >> as_string[+(char_ - ']')][phx::bind(&url_node::url, _val) = _1] >> "][/url]";

      list_ =         attr(node_t::LIST)     >> "[list" >> list_style >> "]" >> +list_entry >> "[/list]";
      list_style =    ("=" >> int_(1)[_val = list_t::ORDERED] ) | eps[_val = list_t::BULLETS];
      list_entry =    "[*]" >> entry[_val = _1];

      quoted_text = '"' >> *(char_ - '"') >> '"';        
    }

    qi::rule<Iterator, bbcode()> bbcodes;
      qi::rule<Iterator, bbcode_node()> possible_bbcodes;
      qi::rule<Iterator, bbcode_node()> entry;

    qi::rule<Iterator, bbcode()> non_formatted;

    qi::rule<Iterator, bbcode()> bold;
    qi::rule<Iterator, bbcode()> italic;
    qi::rule<Iterator, bbcode()> underline;
    qi::rule<Iterator, bbcode()> strike;

    qi::rule<Iterator, bbcode()> left;
    qi::rule<Iterator, bbcode()> right;
    qi::rule<Iterator, bbcode()> center;

    qi::rule<Iterator, hr_node()> hr;


    qi::rule<Iterator, bbcode_with_attribute()> quote;
    qi::rule<Iterator, bbcode_with_attribute()> spoiler;

    qi::rule<Iterator, img_node()> img;
    qi::rule<Iterator, dimension_t()> dimension;

    qi::rule<Iterator, url_node()> url;

    qi::rule<Iterator, list()> list_;
      qi::rule<Iterator, list_t()> list_style;
      qi::rule<Iterator, bbcode_node()> list_entry;


    qi::rule<Iterator, std::string()> quoted_text;
  };

}}

int main(int argc, char** argv) {

  std::string storage = argv[1];

  typedef cbna::bbcode::bbcode_grammar<std::string::const_iterator> grammar;
  grammar g; // Our grammar
  cbna::bbcode::bbcode ast; // Our tree

  using boost::spirit::ascii::space;
  std::string::const_iterator iter = storage.begin();
  std::string::const_iterator end = storage.end();
  bool r = phrase_parse(iter, end, g, space, ast);

  if (r && iter == end) {
      std::cout << "-------------------------\n";
      std::cout << "Parsing succeeded\n";
      std::cout << "-------------------------\n";

      
      std::cout << pre::json::to_json(ast).dump(4) << std::endl;

      return 0;
  } else {
      std::string::const_iterator some = iter+30;
      std::string context(iter, (some>end)?end:some);
      std::cout << "-------------------------\n";
      std::cout << "Parsing failed\n";
      std::cout << "stopped at: ": " << context << "..."\n";
      std::cout << "-------------------------\n";
      return 1;
  }

  return 0;
}

Code:

struct Car {
    BOOST_HANA_DEFINE_STRUCT(Car,
        (std::string, brand),
        (std::string, model)
    );
};

Citation :

Je vois que tu possède ton diplôme de magie noire! Excellent.
En tous cas, ça vaut le coup d’œil.

J'avais jamais vu un exemple d'utilisation de Boost::Spirit. C'est fou.

Citation :

J'ai quelques doutes sur le faits de télécharger chaque messages en BBCode individuellement plutôt que de télécharger les pages du forum et transformer l'HTML. Mais bon, maintenant que tu as fais l'outil, on va voir ce que ça donne

Citation :

Je me demandais, j'ai vu que pour de prochaines versions de C++, ils planchent sur comment donner la capacité au langage de faire de la "static réflection". Peut-être qu'on pourra utiliser la fonction to_json() sans avoir à déclarer les attributs avec BOOST_FUSION_ADAPT_STRUCT.

Code:

struct Car {
    BOOST_HANA_DEFINE_STRUCT(Car,
        (std::string, brand),
        (std::string, model)
    );
};

Code:

    BOOST_FUSION_DEFINE_STRUCT(Car,
        (std::string, brand)
        (std::string, model)
    );

onilink_ a écrit:

Yep par contre malheureusement la réflexion est pas pour c++17.
Mais en attendant y a boost::hana (c++14 je crois) qui est assez badass (to/from_json est sûrement écrit avec hana d'ailleurs).

onilink_ a écrit:

Et joli templates @daminetreg
J'ai jamais pu tâter de boost.spirit, étant donné qu'un code de base met 10 sec a compiler chez moi ._.
Un jour j'aurais un vrai pc.

daminetreg a écrit:

Oui j'ai eu accès au drafts assez tôt vu que je suis maintainer de BOOST_FUSION_ADAPT_STRUCT

onilink_ a écrit:

D'ailleurs y en a qui ont déjà utilisé la libclang pour analyser/bidouiller du C++? Ça a l'air vachement ouf ce truc!

onilink_ a écrit:

Ouai y a plein de projets très intéressants a base de libclang, j'ai aussi vu des trucs super cool avec llvm et clang pour faire du C++ jited comme metashell.
Vivement des IDE qui gèrent le hot reload sans avoir a faire mille bidouilles Very Happy
J'avais vu un truc sympa mais c'était close source et avec une licence chelou... Du coup wait & see.

onilink_ a écrit:

Sinon pour centauri sur smartphone, peut être jamais, peut être un jour. Tout dépendra de l'argent qu'on gagne.
Le soucis du portage étant pas spécialement technique au niveau du moteur, mais plus lié au gamedesign et gameplay qui est difficile a passer sur du tactile (déjà pour que ce soit jouable a la manette on va bien galérer).

• list_1
  
• list_2
  
• list_3
  

1. list_1
   
2. list_2
   
3. list_3
   

auteur a écrit:

citation

Code:

code

spoiler:

H2

H3

H4