matching the contents of a delimited string that can contain the delimiters

[rowlesmr]

I'm having some trouble parsing strings of the following type:

;text entry goes here
lines here can't start with a ;
Some have "quotes", and stuff
others; well, they have 'semicolons'.
text end with "eol ';'"
;

The string definition (in the manual I'm following) is given as (definitions below)

<eol>';' {<AnyPrintChar>* <eol>{{<TextLeadChar> <AnyPrintChar>*}? <eol>}*} ';'

I can match the entire string easily, but am unable to figure out how to match everything inside the leading semicolon, and trailing eol & semicolon.

//the types of chars I'm interested in
struct nonblankchar : pegtl::range<'!', '~'> {}; 
struct textleadchar : pegtl::ranges<' ', ':', '<', '~', '\t'> {}; //all chars except ';'

struct sep : pegtl::seq<pegtl::bol, pegtl::one<';'>> {}; //the delimiter that begins/ends a string
struct end_sep : pegtl::seq<pegtl::eol, field_sep> {}; //the delimiter that can be used to end a string
struct firstline : pegtl::star<anyprintchar> {}; //the first line is of this type
struct otherline : pegtl::seq<textleadchar, pegtl::star<anyprintchar>> {};  //all subsequent lines are of this type

I have interpreted the text inside the ';'s as:

struct text : pegtl::seq<firstline, pegtl::star<pegtl::seq<pegtl::eol, pegtl::opt<otherline>>>> {}; //the text as a whole can be described as this

I can match the entire string with

struct textstring : pegtl::if_must<sep, pegtl::until<end_sep>> {};  //or
struct textstring : pegtl::if_must<sep, pegtl::until<sep, text >> {};

The first leaves the leading and trailing ';' in the textstring match. The second uses the text rule to drop the semicolons, but leaves the trailing eol.

Doing

struct textstring : pegtl::if_must<sep, pegtl::until<end_sep, text >> {};

results in an infinite loop.

I would like to be able to match the string inside the semicolons, and without the trailing eol.

I think there is some subtlety of a negative lookahead that I am missing. I've tried various incarnations of not_at, not_at<end_sep>, and others, and am starting to go around in circles.

What am I not seeing?

Thanks

Matthew

[d-frey]

You might try something like:

struct textcontent : pegtl::until<at<end_sep>> {};
struct textstring : pegtl::if_must<sep, textcontent, end_sep> {};

Add the action to textcontent and it will not contain the surrounding separators.

[rowlesmr]

That looks like it works. I was concentrating on specifying the characters to match while I didn't match end_sep, while your solution just gobbles up everything until you would match end_sep, and then the next rule actually does match end_sep. I wouldn't have thought to use until<> as it's own rule in that context.

Ta a lot!

[rowlesmr]

I'm now pretty certain that it works. Especially now that I've altered other parts of the grammar that used the previous version with the semicolons.

[rowlesmr]

Now that I've gotten back to doing some more work on this, it doesn't 100% work. The trailing eol ';' is gone (as desired), but the leading ';' it still there.

Still mucking around with it.