"Hello, World!" example does not seem to work

[TadeasKucera]

Executing
./pegtl-example-hello_world 'h'
throws:
terminate called after throwing an instance of 'tao::pegtl::parse_error'
what(): parse error matching hello::prefix
Aborted (core dumped)

[ColinH]

The example parses the argument with a grammar that expects an input in a particular form, otherwise it will - correctly - produce a parse error.

Try ./pegtl-example-hello_world 'Hello, Tadeas!'.

[ColinH]

(Since the PEGTL is a parser library, the "Hello, World!" example is a kind of reverse-hello-world, it starts by parsing the arguments, rather than just printing something.)

[TadeasKucera]

My apology, the question was invalid. Thank you for your help!

[ColinH]

No harm done, we all have to start somewhere. Feel free to ask any further questions about understanding the example (or using the PEGTL in general) here...

[TadeasKucera]

Dear @ColinH , I am now very happily using PEGTL but there is one fragment in my grammar that somehow does not work. The fragment is the following grammar:

struct C;
struct W : seq< one< '|' >, opt< one< ' ' > >, C > {};
struct B : seq< one< '(' >, opt<one<' '>>, C, one< '|' >, opt< one< ' ' > >, C, one<')'>, opt<one< ' ' >>> {};
struct C' : seq< sor< W, C >, opt< C' > > {};
struct C : seq< sor< B, seq< A, one<' '> > >, opt< C' > > {};

where A is a simple grammar which works well:
A : seq< range< 'a', 'f' >, range<'a', 'f' > > {};

Should be the following more readable:
W -> | C
B -> ( C| C)
C' -> "W" or "C" concatenated with optional C'
C -> 'B' or "A " concatenated with optional C'

The thing that I do not understand is that trying to parse " ( ab | cd ) " goes terribly wrong unless I completely remove the W structure:
struct C;
struct B : seq< one< '(' >, opt<one<' '>>, C, one< '|' >, opt< one< ' ' > >, C, one<')'>, opt<one< ' ' >>> {};
struct C' : seq< C, opt< C' > > {};
struct C : seq< sor< B, seq< A, one<' '> > >, opt< C' > > {};

When W is removed, the input string is parsed flawlessly and the program finds the correct execution:

" C" -> " B" -> " ( C| C)" -> " ( A | A ) " -> " ( ab | cd ) "
Instead, when W is present, it somehow matches " C" with "ab | cd " and then fails.

The question is: Is there any issue with the grammar? What does a context free grammar without left recursion must fulfill to be good with PEGTL?

Thank you very much for your help and for making the PEGTL tool.

[d-frey]

The PEGTL can not be used with context-free grammars, instead you need to use parsing expression grammars (PEGs). The two are similar and might look identical, but there are differences with what language they expression.

I currently don't see the problem immediately, although I suspect that the greedy nature of PEGs plays a role here. You can, however, use the tracer to see how the grammar is working. You can find the tracer in the contrib-section, an example is available here: https://github.com/taocpp/PEGTL/blob/master/src/example/pegtl/uri_trace.cpp

[TadeasKucera]

Thank you for your tips - the tracer is very helpful. I am quite sure the following grammar is PEG but still there is some problem when parsing "(1|2)" by grammar C:

struct C;
struct B : seq< one< '(' >, C, one< '|' >, C, one< ')' > > {};
struct H : seq< one< '|' >, C > {};
struct C : seq< sor< plus< digit >, B >, star< H > > {};

The output of parse<C, action> of "(1|2)" would be:

Matched digit with '1'
Matched digit with '2'
Matched C with '2'
Matched H with '|2'
Matched C with '1|2'
PARSING FAILED

The grammar generates language containing "(1|2)" and it has no issues when tested by PEGTL analyze tool:

C -> B -> (C|C) -> (digit|digit) -> (1|2).

Could anyone explain this behavior?

[d-frey]

Analysis only catches infinite loops (aka (indirect) left recursion).

Can you give us the REAL code? The above excerpt doesn't references 'H' and 'star' is incomplete, so I can't really know what's going on. Please create a small but complete program that shows the problem. I used this program to confirm that a boiled-down version of your grammar works as expected:

#include <tao/pegtl.hpp>
#include <tao/pegtl/contrib/tracer.hpp>
using namespace tao::pegtl;

struct C;
struct B : seq< one< '(' >, C, one< '|' >, C, one<')'> > {};
struct C : sor< plus< digit >, B > {};

int main()
{
    memory_input in( "(1|2)", "" );
    return parse< C, nothing, tracer >( in );
}

[TadeasKucera]

Thank you for the boiled-down version. Unfortunately, I need the grammar to parse both "(1|2)" and "1|2" (or even "(1|((1|1)|2)|1|(2|2|2))"). I would love to parse logical expressions.

This is the smallest grammar I was able to think of that shows my problem:

#include <iostream>
#include <string>
#include <tao/pegtl.hpp>
#include <tao/pegtl/contrib/tracer.hpp>

namespace pegtl = TAO_PEGTL_NAMESPACE;

namespace gr
{
   using namespace pegtl;

   struct C;
   struct B : seq< one< '(' >, C, one< '|' >, C, one< ')' > > {};
   struct H : seq< one< '|' >, C > {};
   struct C : seq< sor< B, plus< range< '1','2' > > >, star< H > > {};

}  // namespace gr


int main()
{
   std::string content = "(1|2)";
   std::cout << "Parsing '" << content << "'" << std::endl;
   pegtl::string_input in( content, "from_content" );

   auto result = pegtl::parse< gr::C, pegtl::nothing, pegtl::tracer >( in );

   if(result)
      std::cout << "PARSING OK" << std::endl;
   else
      std::cout << "PARSING FAILED" << std::endl;
   return result;
}

Thank you very much for looking on it.

[d-frey]

Thanks for the complete program, now I see the problem. As I suspected earlier, it has to do with the greedy nature of PEGs. When you pass (1|2), what happens is that while parsing B, you need ( (OK), then C, then |. But C is then parsing 1 and C has a star<H>, which then parses |2. Once that has happened, the input consumed is now (1|2 and you still need | and another C before the ). One possible solution is to simplify B to seq<one<'('>,C,one<')'>> as C is intended to already match on 1|2.

[TadeasKucera]

Thank you so much, it is clear to me now.