使用 pyparsing 解析多行中的单词转义分割

Question

我正在尝试使用 pyparsing.这是我所做的：

from pyparsing import *

continued_ending = Literal('\\') + lineEnd
word = Word(alphas)
split_word = word + Suppress(continued_ending)
multi_line_word = Forward()
multi_line_word << (word | (split_word + multi_line_word))

print multi_line_word.parseString(
'''super\\
cali\\
fragi\\
listic''')

我得到的输出是 ['super']，而预期输出是 ['super', 'cali', fragi', 'listic'].更好的是，将它们全部连接为一个单词（我认为我可以使用 multi_line_word.parseAction(lambda t: ''.join(t)) 来完成。

我尝试在pyparsing helper，但它给了我一个错误，超出了最大递归深度

编辑 2009-11-15： 后来我意识到 pyparsing 在空白方面有点慷慨，这导致了一些糟糕的假设，即我认为我正在解析的内容要宽松得多。也就是说，我们希望单词、转义符和 EOL 字符之间没有空格。

我意识到上面的小示例字符串不足以作为测试用例，因此我编写了以下内容。通过这些测试的代码应该能够匹配我直观地认为的转义拆分词，并且仅它们不会匹配不是的基本单词。逃逸分裂。我们可以——而且我相信应该——为此使用不同的语法结构。这使得两者分开，一切都保持整洁。

import unittest
import pyparsing

# Assumes you named your module 'multiline.py'
import multiline

class MultiLineTests(unittest.TestCase):

    def test_continued_ending(self):

        case = '\\\n'
        expected = ['\\', '\n']
        result = multiline.continued_ending.parseString(case).asList()
        self.assertEqual(result, expected)


    def test_continued_ending_space_between_parse_error(self):

        case = '\\ \n'
        self.assertRaises(
            pyparsing.ParseException,
            multiline.continued_ending.parseString,
            case
        )


    def test_split_word(self):

        cases = ('shiny\\', 'shiny\\\n', ' shiny\\')
        expected = ['shiny']
        for case in cases:
            result = multiline.split_word.parseString(case).asList()
            self.assertEqual(result, expected)


    def test_split_word_no_escape_parse_error(self):

        case = 'shiny'
        self.assertRaises(
            pyparsing.ParseException,
            multiline.split_word.parseString,
            case
        )


    def test_split_word_space_parse_error(self):

        cases = ('shiny \\', 'shiny\r\\', 'shiny\t\\', 'shiny\\ ')
        for case in cases:
            self.assertRaises(
                pyparsing.ParseException,
                multiline.split_word.parseString,
                case
            )


    def test_multi_line_word(self):

        cases = (
                'shiny\\',
                'shi\\\nny',
                'sh\\\ni\\\nny\\\n',
                ' shi\\\nny\\',
                'shi\\\nny '
                'shi\\\nny captain'
        )
        expected = ['shiny']
        for case in cases:
            result = multiline.multi_line_word.parseString(case).asList()
            self.assertEqual(result, expected)


    def test_multi_line_word_spaces_parse_error(self):

        cases = (
                'shi \\\nny',
                'shi\\ \nny',
                'sh\\\n iny',
                'shi\\\n\tny',
        )
        for case in cases:
            self.assertRaises(
                pyparsing.ParseException,
                multiline.multi_line_word.parseString,
                case
            )


if __name__ == '__main__':
    unittest.main()

Answer 1

经过一番探索后，我发现了 这个帮助线程这是值得注意的一点吗

我经常看到低效的语法
有人实现了 pyparsing 语法
直接来自 BNF 定义。 BNF
没有“一个或
更多”或“零个或多个”或
“可选”...

有了这个，我想到将这两行更改

multi_line_word = Forward()
multi_line_word << (word | (split_word + multi_line_word))

为

multi_line_word = ZeroOrMore(split_word) + word

这让它输出我正在寻找的内容： ['super', 'cali', fragi', 'listic']< /代码>。

接下来，我添加了一个解析操作，将这些标记连接在一起：

multi_line_word.setParseAction(lambda t: ''.join(t))

这给出了 ['supercalifragilistic'] 的最终输出。

我学到的重要信息是，一个人并不是简单地走进魔多 。

只是在开玩笑。

最重要的是，我们不能简单地使用 pyparsing 实现 BNF 的一对一转换。应该使用一些使用迭代类型的技巧。

编辑 2009-11-25： 为了补偿更繁重的测试用例，我将代码修改为以下内容：

no_space = NotAny(White(' \t\r'))
# make sure that the EOL immediately follows the escape backslash
continued_ending = Literal('\\') + no_space + lineEnd
word = Word(alphas)
# make sure that the escape backslash immediately follows the word
split_word = word + NotAny(White()) + Suppress(continued_ending)
multi_line_word = OneOrMore(split_word + NotAny(White())) + Optional(word)
multi_line_word.setParseAction(lambda t: ''.join(t))

这样做的好处是确保任何元素之间没有空格（使用转义反斜杠后的换行符除外）。

Answer 2

你的代码非常接近。这些 mod 中的任何一个都可以工作：

# '|' means MatchFirst, so you had a left-recursive expression
# reversing the order of the alternatives makes this work
multi_line_word << ((split_word + multi_line_word) | word)

# '^' means Or/MatchLongest, but beware using this inside a Forward
multi_line_word << (word ^ (split_word + multi_line_word))

# an unusual use of delimitedList, but it works
multi_line_word = delimitedList(word, continued_ending)

# in place of your parse action, you can wrap in a Combine
multi_line_word = Combine(delimitedList(word, continued_ending))

正如您在 pyparsing 谷歌搜索中发现的那样，BNF->pyparsing 翻译应该以特殊的视角来完成，以使用 pyparsing 功能来代替 BNF，嗯，缺点。实际上，我正在撰写一个较长的答案，讨论更多的 BNF 翻译问题，但您已经找到了此材料（我猜是在 wiki 上）。