Expression repetition with .. is too greedy when something optional comes after it

[dhhyi]

Hi everyone,

I want to parse a simple list of items that have a name made up of words and an optional weight appended to them. They are listed separated by comma:

item 345g,item without, long item name with weight 500g

I encountered some problems parsing the optional weight at the end, because I want to transform it to an integer if encountered.

I tried the following, but the optional Weight was never matched:

Items
  = @Item|.., _','_| !.

Item "item"
  = words:$Word|.., _ | _ weight:Weight? {
      return { words, weight }
    }
  
Word "word"
  = $[A-Za-z0-9]+

Weight "weight"
  = weight:$[0-9]+ "g" { return parseInt(weight); }

_ "whitespace"
  = [ \t\n\r]*

This completely ignores the Weight part and only matches Word, as a Weight is also a Word.

For the upper example input the following also "works", but I would have to concatenate the weight to the words if it is not an integer:

Item "item"
  = @words:$Word|5, _ | _ @weight:Weight?
  / @words:$Word|1, _ | _ @weight:(Weight/Word)?

After some more tinkering, my working solution is now this, but it's not really pretty:

Items
  = @Item|.., _','_| !.

Item "item"
  = words:$Word|{
      // end is the end of the last context
      const begin = input.substring(range().end);
      // calculate count to match the last word into weight
      const slice = begin.replaceAll(/,.*/gs, "").trim();
      return slice.split(/\s+/).length - 1;
    }, _ | _ weight:Weight {
      return { words, weight }
    }
  / $Word|.., _| { return { words: text() } }
  
Word "word"
  = $[A-Za-z0-9]+

Weight "weight"
  = weight:$[0-9]+ "g" { return parseInt(weight); }

_ "whitespace"
  = [ \t\n\r]*

Is there a better way to match an optional term like this?

[lorenmh]

What happens if you match Weight before you match Word? The matching is done in order, so I would think you would want to match Weight first because a Weight is also a valid Word.

[dhhyi]

Do you have an example Grammar for Item?

[lorenmh]

Items
  = items:Item|.., "," _?| { return { items } }

Item
  = item:ItemValue|.., _| { return { item } }
  
ItemValue
  = weight:Weight { return { weight } }
  / word:Word { return { word } }

Word
  = word:$[A-Za-z0-9]+

Weight
  = weight:$[0-9]+ "g" { return parseInt(weight)}

_
  = [ \t\n\r]+

Parsing item 345g,item without, long item name with weight 500g

Results in:

{
  items: [
    {
      item: [
        {
          word: 'item'
        },
        {
          weight: 345
        }
      ]
    },
    {
      item: [
        {
          word: 'item'
        },
        {
          word: 'without'
        }
      ]
    },
    {
      item: [
        {
          word: 'long'
        },
        {
          word: 'item'
        },
        {
          word: 'name'
        },
        {
          word: 'with'
        },
        {
          word: 'weight'
        },
        {
          weight: 500
        }
      ]
    }
  ]
}

note the / within ItemValue that tells peggy to attempt to parse weight before parsing word

[dhhyi]

Yes, I thought about something similar, but this will also match and convert weight-looking words that are not at the end.
For example 802 11g wireless card will be parsed as:

{
      item: [
        {
          word: '802'
        },
        {
          weight: 11
        },
        {
          word: 'wireless'
        },
        {
          word: 'card'
        }
      ]
}

It has to work just for optional weights at the end.

[hildjj]

You might need a look-ahead predicate to get this to work. This is the quickest fix:

Word "word"
  = !Weight @$[A-Za-z0-9]+

[hildjj]

That doesn't match '123ga' as a word. If you'd like it to, you can add some more complexity:

Word "word"
  = !(Weight (EOF / _ ",")) @$[A-Za-z0-9]+

EOF
  = !.

[dhhyi]

Yes, that looks exactly like what I want.

I am using it as part of the Item to not pollute the Word flexibility.

Item "item"
  = words:$(!(Weight (EOF / _ ",")) Word)|.., _ | _ weight:Weight {
      return { words, weight }
    }
  / $Word|.., _| { return { words: text() } }

thx

[hildjj]

That will parse all of the words twice if weight doesn't exist. I recommend:

Item "item"
  = words:$(!(Weight (EOF / _ ",")) Word)|.., _ | weight:(_ @Weight)? {
      return { words, weight }
    }