所以，我正在重构一个项目，我正在分离出一堆解析代码。我关心的代码是pyparsing。
即使花了很多时间阅读官方文档，我对pyparsing的理解也很差。我遇到了麻烦，因为（1）pyparsing采用（故意）非正统的方法进行解析，（2）我正在编写我没写的代码，评论很差，以及现有语法的非基本集合。
（我也无法与原作者取得联系。）
我正在使用PyVows来测试我的代码。我的一个测试如下（我认为即使你不熟悉PyVows也很清楚;如果不是，请告诉我）：
def test_multiline_command_ends(self, topic):
output = parsed_input('multiline command ends\n\n',topic)
expect(output).to_equal(
r'''['multiline', 'command ends', '\n', '\n']
- args: command ends
- multiline_command: multiline
- statement: ['multiline', 'command ends', '\n', '\n']
- args: command ends
- multiline_command: multiline
- terminator: ['\n', '\n']
- terminator: ['\n', '\n']''')
但是当我运行测试时，我在终端中得到以下信息：
Expected topic("['multiline', 'command ends']\n- args: command ends\n- command: multiline\n- statement: ['multiline', 'command ends']\n - args: command ends\n - command: multiline")
to equal "['multiline', 'command ends', '\\n', '\\n']\n- args: command ends\n- multiline_command: multiline\n- statement: ['multiline', 'command ends', '\\n', '\\n']\n - args: command ends\n - multiline_command: multiline\n - terminator: ['\\n', '\\n']\n- terminator: ['\\n', '\\n']"
注意：
由于输出是终端，预期输出（第二个）有额外的反斜杠。这个是正常的。在重构开始之前，测试没有问题。
第一行输出应与第二行匹配，但事实并非如此。具体来说，它不包括第一个列表对象中的两个换行符。
所以我得到了这个：
"['multiline', 'command ends']\n- args: command ends\n- command: multiline\n- statement: ['multiline', 'command ends']\n - args: command ends\n - command: multiline"
当应该得到这个时：
"['multiline', 'command ends', '\\n', '\\n']\n- args: command ends\n- multiline_command: multiline\n- statement: ['multiline', 'command ends', '\\n', '\\n']\n - args: command ends\n - multiline_command: multiline\n - terminator: ['\\n', '\\n']\n- terminator: ['\\n', '\\n']"
在代码的前面，还有这样的陈述：
pyparsing.ParserElement.setDefaultWhitespaceChars(' \t')
...我认为应该防止这种错误。但我不确定。
即使无法确定问题，只需缩小问题的位置将是一个巨大的帮助。
请让我知道如何解决这个问题。
编辑：所以，呃，我应该为此发布解析器代码，不应该吗？ （感谢小费，@ andrew cooke！）
这是我的解析器对象的__init__。
我知道这是一场噩梦。这就是我重构项目的原因。 ☺
def __init__(self, Cmd_object=None, *args, **kwargs):
# @NOTE
# This is one of the biggest pain points of the existing code.
# To aid in readability, I CAPITALIZED all variables that are
# not set on `self`.
#
# That means that CAPITALIZED variables aren't
# used outside of this method.
#
# Doing this has allowed me to more easily read what
# variables become a part of other variables during the
# building-up of the various parsers.
#
# I realize the capitalized variables is unorthodox
# and potentially anti-convention. But after reaching out
# to the project's creator several times over roughly 5
# months, I'm still working on this project alone...
# And without help, this is the only way I can move forward.
#
# I have a very poor understanding of the parser's
# control flow when the user types a command and hits ENTER,
# and until the author (or another pyparsing expert)
# explains what's happening to me, I have to do silly
# things like this. :-|
#
# Of course, if the impossible happens and this code
# gets cleaned up, then the variables will be restored to
# proper capitalization.
#
# —Zearin
# http://github.com/zearin/
# 2012 Mar 26
if Cmd_object is not None:
self.Cmd_object = Cmd_object
else:
raise Exception('Cmd_object be provided to Parser.__init__().')
# @FIXME
# Refactor methods into this class later
preparse = self.Cmd_object.preparse
postparse = self.Cmd_object.postparse
self._allow_blank_lines = False
self.abbrev = True # Recognize abbreviated commands
self.case_insensitive = True # Commands recognized regardless of case
# make sure your terminators are not in legal_chars!
self.legal_chars = u'!#$%.:?@_' + PYP.alphanums + PYP.alphas8bit
self.multiln_commands = [] if 'multiline_commands' not in kwargs else kwargs['multiln_commands']
self.no_special_parse = {'ed','edit','exit','set'}
self.redirector = '>' # for sending output to file
self.reserved_words = []
self.shortcuts = { '?' : 'help' ,
'!' : 'shell',
'@' : 'load' ,
'@@': '_relative_load'
}
# self._init_grammars()
#
# def _init_grammars(self):
# @FIXME
# Add Docstring
# ----------------------------
# Tell PYP how to parse
# file input from '< filename'
# ----------------------------
FILENAME = PYP.Word(self.legal_chars + '/\\')
INPUT_MARK = PYP.Literal('<')
INPUT_MARK.setParseAction(lambda x: '')
INPUT_FROM = FILENAME('INPUT_FROM')
INPUT_FROM.setParseAction( self.Cmd_object.replace_with_file_contents )
# ----------------------------
#OUTPUT_PARSER = (PYP.Literal('>>') | (PYP.WordStart() + '>') | PYP.Regex('[^=]>'))('output')
OUTPUT_PARSER = (PYP.Literal( 2 * self.redirector) | \
(PYP.WordStart() + self.redirector) | \
PYP.Regex('[^=]' + self.redirector))('output')
PIPE = PYP.Keyword('|', identChars='|')
STRING_END = PYP.stringEnd ^ '\nEOF'
TERMINATORS = [';']
TERMINATOR_PARSER = PYP.Or([
(hasattr(t, 'parseString') and t)
or
PYP.Literal(t) for t in TERMINATORS
])('terminator')
self.comment_grammars = PYP.Or([ PYP.pythonStyleComment,
PYP.cStyleComment ])
self.comment_grammars.ignore(PYP.quotedString)
self.comment_grammars.setParseAction(lambda x: '')
self.comment_grammars.addParseAction(lambda x: '')
self.comment_in_progress = '/*' + PYP.SkipTo(PYP.stringEnd ^ '*/')
# QuickRef: Pyparsing Operators
# ----------------------------
# ~ creates NotAny using the expression after the operator
#
# + creates And using the expressions before and after the operator
#
# | creates MatchFirst (first left-to-right match) using the
# expressions before and after the operator
#
# ^ creates Or (longest match) using the expressions before and
# after the operator
#
# & creates Each using the expressions before and after the operator
#
# * creates And by multiplying the expression by the integer operand;
# if expression is multiplied by a 2-tuple, creates an And of
# (min,max) expressions (similar to "{min,max}" form in
# regular expressions); if min is None, intepret as (0,max);
# if max is None, interpret as expr*min + ZeroOrMore(expr)
#
# - like + but with no backup and retry of alternatives
#
# * repetition of expression
#
# == matching expression to string; returns True if the string
# matches the given expression
#
# << inserts the expression following the operator as the body of the
# Forward expression before the operator
# ----------------------------
DO_NOT_PARSE = self.comment_grammars | \
self.comment_in_progress | \
PYP.quotedString
# moved here from class-level variable
self.URLRE = re.compile('(https?://[-\\w\\./]+)')
self.keywords = self.reserved_words + [fname[3:] for fname in dir( self.Cmd_object ) if fname.startswith('do_')]
# not to be confused with `multiln_parser` (below)
self.multiln_command = PYP.Or([
PYP.Keyword(c, caseless=self.case_insensitive)
for c in self.multiln_commands
])('multiline_command')
ONELN_COMMAND = ( ~self.multiln_command +
PYP.Word(self.legal_chars)
)('command')
#self.multiln_command.setDebug(True)
# Configure according to `allow_blank_lines` setting
if self._allow_blank_lines:
self.blankln_termination_parser = PYP.NoMatch
else:
BLANKLN_TERMINATOR = (2 * PYP.lineEnd)('terminator')
#BLANKLN_TERMINATOR('terminator')
self.blankln_termination_parser = (
(self.multiln_command ^ ONELN_COMMAND)
+ PYP.SkipTo(
BLANKLN_TERMINATOR,
ignore=DO_NOT_PARSE
).setParseAction(lambda x: x[0].strip())('args')
+ BLANKLN_TERMINATOR
)('statement')
# CASE SENSITIVITY for
# ONELN_COMMAND and self.multiln_command
if self.case_insensitive:
# Set parsers to account for case insensitivity (if appropriate)
self.multiln_command.setParseAction(lambda x: x[0].lower())
ONELN_COMMAND.setParseAction(lambda x: x[0].lower())
self.save_parser = ( PYP.Optional(PYP.Word(PYP.nums)^'*')('idx')
+ PYP.Optional(PYP.Word(self.legal_chars + '/\\'))('fname')
+ PYP.stringEnd)
AFTER_ELEMENTS = PYP.Optional(PIPE +
PYP.SkipTo(
OUTPUT_PARSER ^ STRING_END,
ignore=DO_NOT_PARSE
)('pipeTo')
) + \
PYP.Optional(OUTPUT_PARSER +
PYP.SkipTo(
STRING_END,
ignore=DO_NOT_PARSE
).setParseAction(lambda x: x[0].strip())('outputTo')
)
self.multiln_parser = (((self.multiln_command ^ ONELN_COMMAND)
+ PYP.SkipTo(
TERMINATOR_PARSER,
ignore=DO_NOT_PARSE
).setParseAction(lambda x: x[0].strip())('args')
+ TERMINATOR_PARSER)('statement')
+ PYP.SkipTo(
OUTPUT_PARSER ^ PIPE ^ STRING_END,
ignore=DO_NOT_PARSE
).setParseAction(lambda x: x[0].strip())('suffix')
+ AFTER_ELEMENTS
)
#self.multiln_parser.setDebug(True)
self.multiln_parser.ignore(self.comment_in_progress)
self.singleln_parser = (
( ONELN_COMMAND + PYP.SkipTo(
TERMINATOR_PARSER
^ STRING_END
^ PIPE
^ OUTPUT_PARSER,
ignore=DO_NOT_PARSE
).setParseAction(lambda x:x[0].strip())('args'))('statement')
+ PYP.Optional(TERMINATOR_PARSER)
+ AFTER_ELEMENTS)
#self.multiln_parser = self.multiln_parser('multiln_parser')
#self.singleln_parser = self.singleln_parser('singleln_parser')
self.prefix_parser = PYP.Empty()
self.parser = self.prefix_parser + (STRING_END |
self.multiln_parser |
self.singleln_parser |
self.blankln_termination_parser |
self.multiln_command +
PYP.SkipTo(
STRING_END,
ignore=DO_NOT_PARSE)
)
self.parser.ignore(self.comment_grammars)
# a not-entirely-satisfactory way of distinguishing
# '<' as in "import from" from
# '<' as in "lesser than"
self.input_parser = INPUT_MARK + \
PYP.Optional(INPUT_FROM) + \
PYP.Optional('>') + \
PYP.Optional(FILENAME) + \
(PYP.stringEnd | '|')
self.input_parser.ignore(self.comment_in_progress)
答案 0 :(得分：5)
我怀疑问题是pyparsing的内置空白跳过，默认会跳过换行符。尽管setDefaultWhitespaceChars用于告诉pyparsing新行很重要，但此设置仅影响在调用setDefaultWhitespaceChars之后创建的所有表达式。问题在于，pyparsing尝试通过在导入时定义一些便利表达来帮助，例如empty的{{1}}，Empty()的{{1}}等等。但由于这些都是在导入时创建的，因此它们是使用原始默认空白字符定义的，其中包括lineEnd。
我应该在LineEnd()中执行此操作，但您也可以自行清理。在调用'\n'之后，在pyparsing中重新定义这些模块级表达式：
setDefaultWhitespaceChars我认为这有助于恢复嵌入式换行的重要性。
解析器代码上的其他一些内容：
setDefaultWhitespaceChars应该是
PYP.ParserElement.setDefaultWhitespaceChars(' \t')
# redefine module-level constants to use new default whitespace chars
PYP.empty = PYP.Empty()
PYP.lineEnd = PYP.LineEnd()
PYP.stringEnd = PYP.StringEnd()
您的原作者可能过于积极地使用'^'而不是'|'。只有当你真的解析了一个较长的表达式后面的一个表达式时，才会使用'^'，而后者会在备选列表中稍后解析。例如，在：
self.blankln_termination_parser = PYP.NoMatch
数字Word或单独 self.blankln_termination_parser = PYP.NoMatch()
之间不会混淆。 self.save_parser = ( PYP.Optional(PYP.Word(PYP.nums)^'*')('idx')
（或'*'运算符）告诉pyparsing尝试评估所有备选项，然后选择最长匹配项 - 如果出现平局，请在列表中选择最左侧的备用项。如果您解析Or，则无需查看是否也可以匹配更长的整数，或者如果解析整数，则无需查看它是否也可以作为单独的'^'传递。所以改成这个：
'*'使用解析操作将字符串替换为''更简单地使用'*'包装器编写，或者如果您愿意，请调用返回 self.save_parser = ( PYP.Optional(PYP.Word(PYP.nums)|'*')('idx')
的{{1}}。加上对'|'的偏好在'^'，这个：
PYP.Suppressbecomse：
expr.suppress()关键字具有自动避免歧义的内置逻辑，因此或完全不需要它们：
Suppress(expr)应该是：
self.comment_grammars = PYP.Or([ PYP.pythonStyleComment,
PYP.cStyleComment ])
self.comment_grammars.ignore(PYP.quotedString)
self.comment_grammars.setParseAction(lambda x: '')
（在下一个版本中，我将放松那些初始值设定项以接受生成器表达式，这样就不需要[]了。）
这就是我现在能看到的一切。希望这会有所帮助。
答案 1 :(得分：3)
Pyparsing没有错！
我是。 ☹通过将解析代码分离到不同的对象，我创建了问题。最初，用于基于第二属性的内容“更新自身”的属性。由于这一切都曾经被包含在一个“神级”中，所以它运作良好。
只需将代码分成另一个对象，第一个属性就是在实例化时设置的，但如果它所依赖的第二个属性发生了变化，则不再“更新自身”。
属性multiln_command（不要与multiln_commands混淆 - aargh，令人困惑的命名！）是一个pyparsing语法定义。如果multiln_command发生了变化，multiln_commands属性应该更新其语法。
虽然我知道这两个属性的名称相似，但目的却截然不同，但这种相似性肯定使得追踪问题变得更加困难。我没有将multiln_command重命名为multiln_grammar。
我很感谢@Paul McGuire的精彩回答，我希望它能在未来拯救我（和其他人）一些悲伤。虽然我觉得有点愚蠢，但是我把它误认为是一个pyparsing问题，但我很高兴（以Paul的建议的形式）来问这个问题。
快乐的解析，每个人。 ：）