Extracting strings from a grammar with many options

[sckott]

Apologies for possibly naive question. Thanks a lot for the help

I am trying to write a grammar in which there are multiple options, any of which can be matched (only one per input string), but it's not clear to me how to do so and still capture the parts that I want to capture.

Here's some example code:

struct name
  : plus< alpha >
{};

struct epithet
  : plus< alpha > 
{};

// various possible combinations 
struct just_a_name
  : must< name >
{};
struct genus_epithet
  : must< name, space, epithet >
{};
struct genus_epithet_infra
  : must< name, space, epithet, space, name >
{};

struct grammar
  : star<
    sor<
      just_a_name,
      genus_epithet,
      genus_epithet_infra
    >,
    eof
> {};

template<>
struct action< name >
{
  template< typename Input >
  static void apply( const Input& in, std::string& v, const std::string& )
  {
    v = in.string();
  }
};

template<>
struct action< epithet >
{
  template< typename Input >
  static void apply( const Input& in, const std::string&, std::string& v )
  {
    v = in.string();
  }
};

In the actions, I want to grab the name (and epithet when matched) if any of the three patterns (just_a_name, genus_epithet, genus_epithet_infra) are matched. But it seems that I can't extract those two things if their names aren't in the grammar. Or is that incorrect? Maybe there's some way I can drill down to the string I want inside each action?

[d-frey]

The order within the sor is your problem in the above example: sor stands for "Sequenced OR", meaning that all alternatives are tried in the order that you provide them. The first one which matches will match for the whole sor, hence if you try just_a_name first, it will match and sor will be happy and no longer try to match any other alternative. Therefore it will never try to match genus_epithet or genus_epithet_infra.

If you try to match the longer expressions first by using sor<genus_epithet_infra, genus_epithet, just_a_name>, you'll run into the next problem: You are using must, therefore genus_epithet_infra will generate a global failure (i.e. an exception) instead of local failure. To really solve your problem, you'd need to drop the must, or turn your grammar into something like

seq< name, if_must< space, epithet >, if_must< space, name > >

Although even that won't work because name and epiphet match the same characters and the star<> in you grammar could not possibly match more than once.

This might be because your example is an artificial example? Your real grammar is probably different, in any case your problem is the way the grammar works.

[sckott]

Thanks! Okay, here's the real code: https://github.com/ropenscilabs/pegax/blob/master/src/sci_name.h#L16-L158

I have these different patterns https://github.com/ropenscilabs/pegax/blob/master/src/sci_name.h#L38-L62 and i'm going to add many more. In my grammar any of them can be a possible match depending on the input string - and I'm hoping to have a cleaner looking grammar statement rather than one huge grammar statement with all possible patterns. Is there a way to use a grammar like https://github.com/ropenscilabs/pegax/blob/master/src/sci_name.h#L64-L77 but still be able to pull out individual parts when a match is found, e.g., epithet if genus_epithet is matched

[d-frey]

You real grammar is even worse than the example grammar you posted earlier, sorry. It can not possibly work. Think about it: softSpace is star<space> which means the separator could be nothing. And name, epithet and infraname are all plus<alpha>, separated by softSpace. Looking at just_a_name, genus_epithet and genus_epithet_infra, there is no way to reasonably parse ABC as an input. Could be anything of those three.

Those (plus other) alternatives are inside of a star<sor<...>>. How would you imaging the input foobarbazblablubblaberhalloholagaga to match to those rules? It could be foobarbaz matches just_a_name three times, once with foo, once with bar and once with baz. Or is it meant to be genus_epithet_infra with foo being the name, bar being epithet and baz being infraname? Or is foobarbaz as a whole the name part of a larger genus_epithet_infra? Plus the rest and all possible combinations. Plus all the other combinations allowed by the additional alternatives. How would the grammar decide that? I'm afraid your understanding of how grammars (specifically PEGs) work is flawed and needs to be fixed first, this has nothing to do with the PEGTL.

Plus for the PEGTL any combination of sor< must<A>, must<B> > is always plain useless as must<A> either matches or generates a global error, so it will never even once try to match must<B>. This part is PEGTL-specific, so if you want to work on the general understanding of PEGs, I'd suggest to leave out all must-rules from your grammar for now and focus on the basics. Good luck!