трюк с вложенными структурами в pyparsing

Есть две проблемы:

1. В вашей грамматике вы пометили texture литерал как требуемый в блоке texture_unit, но во втором примере нет texture.
2. Во втором примере pass_props_ совпадает с texture_unit optionalName. После него pp.Literal('}') ожидает }, а выдает {. Это причина ошибки.

Мы можем проверить это, изменив правило pass_ следующим образом:

pass_ << pp.Literal('pass').suppress() + pp.Optional(pp.Word(pp.alphanums+'_'+'.')).suppress() + \
             pp.Literal('{').suppress() + pass_props_

print pass_.parseString(s2)

Это дает нам следующий вывод:

[['prop_name', ['prop_val', 'prop_name', 'prop_val', 'texture_unit', 'optionalName']]]

Мы видим, что pass_props_ совпадает с texture_unit optionalName.
Итак, что мы хотим сделать: prop_ может содержать alphanums, _ и ., но не может совпадать с литералом texture_unit. Мы можем сделать это с помощью regex и отрицательного прогноза:

prop_ = pp.Group(  pp.Regex(r'(?!texture_unit)[a-z0-9_]+')+ pp.Group(pp.OneOrMore(pp.Regex(r'(?!texture_unit)[a-z0-9_.]+'))) )

Наконец, рабочий пример будет выглядеть так:

import pyparsing as pp

s1 = '''texture_unit optionalName
    {
    texture required_val
    prop_name prop_val
    prop_name prop_val
}'''

prop_ = pp.Group(  pp.Regex(r'(?!texture_unit)[a-z0-9_]+')+ pp.Group(pp.OneOrMore(pp.Regex(r'(?!texture_unit)[a-z0-9_.]+'))) )
texture_props_ = pp.Group(pp.Literal('texture') + pp.Word(pp.alphanums+'_'+'.')) + pp.ZeroOrMore(prop_)
texture_ = pp.Forward()
texture_ = pp.Literal('texture_unit').suppress() + pp.Word(pp.alphanums+'_').suppress() +\
           pp.Literal('{').suppress() + pp.Optional(texture_props_) + pp.Literal('}').suppress()

print texture_.parseString(s1)

s2 = '''pass optionalName
{
    prop_name1 prop_val1.name
    texture_unit optionalName1
    {
        texture required_val1
        prop_name2 prop_val12
        prop_name3 prop_val13
    }
    texture_unit optionalName2
    {
        texture required_va2l
        prop_name2 prop_val22
        prop_name3 prop_val23
    }
}'''

pass_props_ = pp.ZeroOrMore(prop_  )
pass_ = pp.Forward()

pass_ = pp.Literal('pass').suppress() + pp.Optional(pp.Word(pp.alphanums+'_'+'.')).suppress() +\
        pp.Literal('{').suppress() + pass_props_ + pp.ZeroOrMore(texture_ ) + pp.Literal('}').suppress()

print pass_.parseString(s2)

Выход:

[['texture', 'required_val'], ['prop_name', ['prop_val', 'prop_name', 'prop_val']]]
[['prop_name1', ['prop_val1.name']], ['texture', 'required_val1'], ['prop_name2', ['prop_val12', 'prop_name3', 'prop_val13']], ['texture', 'required_va2l'], ['prop_name2', ['prop_val22', 'prop_name3', 'prop_val23']]]

Ответ, который я искал, связан с использованием парсера Forward, показанного в примере Cstruct (связанном в OP).

Трудная часть определения грамматики для вложенной структуры состоит в том, чтобы определить все возможные типы элементов структуры, которые должны включать в себя саму структуру, которая еще не определена.

«Хитрость» в определении грамматики pyparsing для вложенной структуры заключается в том, чтобы отложить определение структуры, но включить «предварительно объявленную» версию структуры при определении элементов структуры, чтобы члены также могли включать структуру. . Затем завершите грамматику структуры в виде списка членов.

struct = Forward()
member = blah | blah2 | struct
struct << ZeroOrMore( Group(member) )

Это также обсуждается здесь: Pyparsing: анализ Вложенные данные открытого текста JSON в список

OP (мой) описывал тестовые данные и грамматику, которые не были достаточно конкретными и совпадали, когда они должны были дать сбой. @NorthCat правильно обнаружил нежелательные совпадения в грамматике. Однако предложение определить множество «отрицательных прогнозов вперед» казалось неуправляемым.

Вместо того, чтобы определять, что не должно совпадать, мое решение вместо этого явно перечисляло возможные совпадения. Совпадения были ключевыми словами-членами, используя 'oneOf('список слов, разделенных пробелом'). Как только я указал все возможные совпадения, я понял, что моя структура была не вложенной структурой, а структурой с конечной глубиной и разными грамматиками, описывающими каждую глубину. Таким образом, мое определение члена не требовало трюка с предварительным объявлением.

Терминатор моих определений элементов был другим, чем в примере с Cstruct. Вместо завершения с помощью ';' (точка с запятой), как и в C++, мои определения членов должны заканчиваться в конце строки. В pyparsing вы можете указать конец строки с помощью парсера LineEnd. Итак, я определил свои элементы как список значений, НЕ включая «LineEnd», например, обратите внимание на использование оператора «Not» (~) в последнем определении:

EOL = LineEnd().suppress()
ident = Word( alphas+"_", alphanums+"_$@#." )
integer = Word(nums)
real = Combine(Optional(oneOf('+ -')) + Word(nums) + '.' + Optional(Word(nums)))
propVal = real | integer | ident
propList = Group(OneOrMore(~EOL + propVal))