python - 类似于 json python 的文件的自定义解析器

Question

我正在尝试创建一个解析器来将“自定义”文件转换为 JSON，以便我可以更轻松地操作其内容(为了便于讨论，将“自定义”格式称为 .qwerty)。

我已经创建了一个词法分析器，它将文件分解为单独的词素(标记)，其结构为 [token_type, token_value]。现在我正在努力将词素解析到它们正确的词典中，因为很难将数据插入到子词典中，因为键不是常量。以及将数据插入存储在字典中的数组。

应该注意的是，我试图按顺序将标记解析为实际的 python json 对象，然后转储 json 对象。

可以在下面看到该文件的示例，以及最终结果的相似之处。

文件:ABC.querty

Dict_abc_1{

    Dict_abc_2{
        HeaderGUID="";
        Version_TPI="999";
        EncryptionType="0";
    }

    Dict_abc_3{
        FamilyName="John Doe";
    }

    Dict_abc_4{
        Array_abc{
            {TimeStamp="2018-11-07 01:00:00"; otherinfo="";}
            {TimeStamp="2018-11-07 01:00:00"; otherinfo="";}
            {TimeStamp="2018-11-07 01:00:00"; otherinfo="";}
            {TimeStamp="2018-11-07 02:53:57"; otherinfo="";}
            {TimeStamp="2018-11-07 02:53:57"; otherinfo="";}
        }

        Dict_abc_5{
            LastContact="2018-11-08 01:00:00";
            BatteryStatus=99;
            BUStatus=PowerOn;
            LastCallTime="2018-11-08 01:12:46";
            LastSuccessPoll="2018-11-08 01:12:46";
            CallResult=Successful;
        }
    }
}
Code=999999;

文件:ABC.json

{  
    "Dict_abc_1":{
        "Dict_abc_2":{
            "HeaderGUID":"",
            "Version_TPI":"999",
            "EncryptionType":"0"
        },

        "Dict_abc_3":{
            "FamilyName":"John Doe"
        },

        "Dict_abc_4":{
            "Array_abc":[
                {"TimeStamp":"2018-11-07 01:00:00", "otherinfo":""},
                {"TimeStamp":"2018-11-07 01:00:00", "otherinfo":""},
                {"TimeStamp":"2018-11-07 01:00:00", "otherinfo":""},
                {"TimeStamp":"2018-11-07 02:53:57", "otherinfo":""},
                {"TimeStamp":"2018-11-07 02:53:57", "otherinfo":""}
            ],

            "Dict_abc_5":{
                "LastContact":"2018-11-08 01:00:00",
                "BatteryStatus":99,
                "BUStatus":"PowerOn",
                "LastCallTime":"2018-11-08 01:12:46",
                "LastSuccessPoll":"2018-11-08 01:12:46",
                "CallResult":"Successful"
            }
        }
    },
    "Code":999999
}

额外的代币信息， token 类型可以是(具有可能的值)

• IDENTIFIER包含变量标识符的名称
• VARIABLE 包含属于父 IDENTIFIER 的实际数据
• OPERATOR 等于“=”
• OPEN_BRACKET 等于“{”
• CLOSE_BRACKET等于“}”

ABC.querty 的词素示例可见HERE

ma​​in.py 的基本逻辑摘录

def main():
    content = open_file(file_name) ## read file

    lexer = Lexer(content) ## create lexer class
    tokens = lexer.tokenize() ## create lexems as seen in pastebin

    parser = Parser(tokens).parse() ## create parser class given tokens 

    print(json.dumps(parser, sort_keys=True,indent=4, separators=(',', ': ')))

解析器.py

import re

class Parser(object):
    def __init__(self, tokens):
        self.tokens = tokens
        self.token_index = 0
        self.json_object = {}
        self.current_object = {}
        self.path = [self.json_object]

    def parse(self):
        while self.token_index < len(self.tokens):

            token = self.getToken()
            token_type = token[0]
            token_value = token[1]

            print("%s \t %s" % (token_type, token_value))

            if token_type in "IDENTIFIER":
                self.increment()
                identifier_type = self.getToken()
                if identifier_type[0] in "OPEN_BRACKET":
                    identifier_two_type = self.getToken(1)
                    if identifier_two_type[0] in ["OPERATOR","IDENTIFIER"]:
                        ## make dict in current dict 
                        pass

                    elif identifier_two_type[0] in "OPEN_BRACKET":
                        ## make array in current dict 
                        pass

                elif identifier_type[0] in "OPERATOR":
                    ## insert data into current dict
                    pass


            if token_type in "CLOSE_BRACKET":
                identifier_type = self.getToken()
                if "OPEN_BRACKET" in identifier_type[0]:
                    #still in array of current dict
                    pass
                elif "IDENTIFIER" in identifier_type[0]:
                    self.changeDirectory()

                else:
                    #end script
                    pass

            self.increment()
        print(self.path)
        return self.json_object


    def changeDirectory(self):
        if len(self.path) > 0:
            self.path = self.path.pop()
            self.current_object = -1

    def increment(self):
        if self.token_index < len(self.tokens):
            self.token_index+=1

    def getToken(self, x=0):
        return self.tokens[self.token_index+x]

额外的解析信息，目前，我正在尝试将当前字典存储在路径数组中，以允许我插入字典和字典中的数组。

非常感谢任何建议或解决方案，

谢谢。

Answer 1

上次解决这个问题时，我发现有限状态机非常有用。我想推荐你有 token 后的方式，但我不知道它的英文怎么称呼。原理是:你遍历 token 并在堆栈上一个一个地添加。添加到堆栈后，您正在检查堆栈的一些规则。就像您将原始标记组合成可能是更复杂表达式的一部分的表达式。

例如 "FamilyName":"John Doe"。 token 是 "FamilyName"、: 和 "John Doe"。

您将第一个 token 添加到堆栈中。堆栈 = ["FamilyName"]。规则 1:str_obj -> E。因此，您创建了 Expression(type='str', value="FamilyName") 并且堆栈现在是 stack = [Expression]。

然后添加下一个标记。stack = [表达式，':']。 ':' 没有规则。下一步。

stack = [Expression, ':', "FamilyName"]。我们再次遇到规则 1。因此堆栈变为 stack = [Expression, ':', Expression]。然后我们看到另一个规则。规则 2:E:E -> E。像 Expression(type='kv_pair, value=(Expression, Expression)) 一样使用它。堆栈变为 stack=[Expression]。

如果您描述了所有规则，它就会像那样工作。希望对您有所帮助。