使用Python解析macro.ini

#使用Python解析macro.ini

# -*- coding: utf-8 -*-
import os
import re

class MML:
    def __init__(self, FilePath):
        print FilePath
        if os.path.exists(FilePath) == False:
            self.create = False
        else:
            self.create = True
            self.fp = open(FilePath)

        #用于保存MOC对象的命令和属性，MOCdir = { 'MOCname':{'CMD':{attr:[obj,obj.attr]}}}
        self.MOCdir = {}
        self.Level = 4
        #当前读取的MOC对象名称
        self.CurrentMOC = ''
        #当前读取操作是:ADD/MOD/RMV
        self.CurrentOperator = ''
        #当前读取的属性
        self.CurrentAttr = ''
        #当前读取的是否为命令内容
        self.ContentFlag = False
        #读取MML文件
        self.ReadMML()
        #for key in self.MOCdir.keys():
            #self.PrintMOC(key)



    def isCreate(self):
        return self.create
    #读取MML文件
    def ReadMML(self):
        while True:
            line = self.fp.readline()
            if line:
                self.ReadLine(line)
            else:
                break
        self.fp.close()

    #读取一行MML文件内容
    def ReadLine(self, content):
        #获取MOC及命令
        if self.GetCMD(content) == True:
            return 0                
        if self.ContentFlag == False:
            return 0
        #跳过空行
        if len(content) < 3:
            return 0       
        #获取属性名称
        if self.GetCMDAttr(content) == False:
            return
        #获取属性联想对象
        self.GetAttrAssociation()


    #获取MOC及命令
    def GetCMD(self, content):
        if re.search('\[.*\]',content):
            ContentFlag = False
            #获取MOC名称
            #'\[ *(?P<opName>[^ ]*) (?P<MOCName>[^ ]*) *\]'去除可能存在的多余空格
            match = re.search('\[ *(?P<opName>[^ ]*) +(?P<MOCName>[^ ]*) *\]', content)
            if match:
                MOCName = match.group('MOCName')
                opName = match.group('opName')
                #增加MOC对象和命令
                if MOCName in self.MOCdir.keys():
                    self.MOCdir[MOCName][opName] = {}
                else:
                    self.MOCdir[MOCName] = {opName:{}}
                
                #当前读取的MOC和命令
                self.CurrentMOC = MOCName
                self.CurrentOperator = opName
                #标识下一行是数据
                self.ContentFlag = True
                return True
            return False

    #匹配属性名称       
    def GetCMDAttr(self, content):
        match =  re.search(' *[0-9]+ *=(?P<attrName>.*)', content)
        if match :
            result = match.group('attrName')
            result = result.replace(' ', '')
            #增加MOC对象命令的属性
            self.CurrentAttr = result
            self.MOCdir[self.CurrentMOC][self.CurrentOperator][self.CurrentAttr] = []
            return True
        else:
            print 'no match attrName'
            return False

    #读取属性联想的对象和属性
    def GetAttrAssociation(self):
        for i in range(2):
            line = self.fp.readline()
            #名字只包含字符数字，下划线和减号
            match = re.search('.*= *(?P<moc>[\w,_, -]*)', line)
            if match:
                self.MOCdir[self.CurrentMOC][self.CurrentOperator][self.CurrentAttr].append(match.group('moc'))

    #比较新旧MML文件,DiffDict 格式：{'ADD/MOD/RMV':{'MOCname':{'ADD/MOD/RMV':{'CMD': {'ADD/MOD/RMV':{atr:[obj,obj.attr]}}}}}}
    def CompareMML(self, oldMOC):
        #用于保存新旧文件比较结果
        DiffDict = {}
        #新旧对比
        self.iteCompareMML(self.MOCdir, oldMOC.MOCdir, 4, DiffDict)
        #由DiffDict中删除没有改变的项
        self.DelNoModify(DiffDict,4)
        #输出比较结果
        self.WriteDiffToFile(DiffDict)


    #递归比较MOC差异
    def iteCompareMML(self, new1, old, Level, DiffDict):
        if Level <= 0:
            return
        if Level == 1:
            #保存新旧联想对象和属性
            DiffDict['old'] = old
            DiffDict['new'] = new1
            return 0
        
        DiffDict['ADD'] = {}
        DiffDict['RMV'] = {}
        DiffDict['MOD'] = {}
        #判断新增或修改
        for key in new1.keys():
            if key in old.keys():
                #可能修改的
                DiffDict['MOD'][key] = {}
            else:
                DiffDict['ADD'][key] = new1[key]
        #判断为删除项
        for key in old.keys():
            if key not in new1.keys():            
                DiffDict['RMV'][key] = old[key]
        #继续判断是否有修改
        for key in DiffDict['MOD'].keys():
            self.iteCompareMML(new1[key], old[key], Level - 1, DiffDict['MOD'][key])
        


    def PrintMOC(self,MOCName):
        if MOCName in self.MOCdir.keys():
            print 'MOC Name: %s'%MOCName
            for cmd in self.MOCdir[MOCName]:
                print '%s %s'%(cmd, MOCName)
                for attr in self.MOCdir[MOCName][cmd]:
                    print 'attr: %s'%attr
                    print 'associate MOC: %s\nassociate attr: %s'%(self.MOCdir[MOCName][cmd][attr][0], self.MOCdir[MOCName][cmd][attr][1])

    #删除没有修改的项
    def DelNoModify(self, DiffDict, Level):
        if Level < 2:
            return

        for cmd in DiffDict.keys():
            #删除没有增加，或修改的命令
            if len(DiffDict[cmd]) == 0 and Level > 1:
                del DiffDict[cmd]
            #递归查找下一级    
            elif len(DiffDict[cmd]) != 0 and Level > 2 and cmd == 'MOD':
                for key in DiffDict[cmd].keys():
                    self.DelNoModify(DiffDict[cmd][key], Level - 1)
            #判断属性的联想是否修改        
            elif len(DiffDict[cmd]) != 0 and Level == 2 and cmd == 'MOD':
                for attr in DiffDict[cmd].keys():
                    AttrDict = DiffDict[cmd][attr]
                    if AttrDict['old'][0] == AttrDict['new'][0] and AttrDict['old'][1] == AttrDict['new'][1]:
                        del AttrDict
                                    
    #输出比较结果到result.txt   
    def WriteDiffToFile(self, DiffDict):
        fp = open('result.txt','w')
        
        if 'ADD' in DiffDict.keys() and len(DiffDict['ADD']) > 0:
            fp.write('================================================================\n')
            fp.write('新增MML命令联想\n')
            self.WriteNeworRmvToFile(DiffDict, 'ADD', fp)
            fp.write('================================================================\n')
            fp.write('\n\n')
            
        if 'RMV' in DiffDict.keys() and len(DiffDict['RMV']) > 0:
            fp.write('================================================================\n')
            fp.write('删除MML命令联想\n')
            self.WriteNeworRmvToFile(DiffDict, 'RMV', fp)
            fp.write('\n\n')
            fp.write('================================================================\n')

        if 'MOD' in DiffDict.keys() and len(DiffDict['MOD']) > 0:
            fp.write('================================================================\n')
            fp.write('修改MML命令属性联想\n')
            self.WriteModToFile(DiffDict, fp)
            fp.write('\n\n')
            fp.write('================================================================\n')
            
        fp.close()

    #写入新增命或删除命令到result.txt
    def WriteNeworRmvToFile(self, DiffDict, op, fp):        
        #打印新增或删除的MOC的所有命令
        for obj in DiffDict[op].keys():
            moc = DiffDict[op][obj]
            for cmd in moc.keys():
                CMDName = '%s %s\n'%(cmd,obj)
                fp.write(CMDName)
                
        #判断是否有修改命令的MOC
        if 'MOD' not in DiffDict.keys():
            return 0
              
        #打印已有MOC新增或删除的命令
        for obj in DiffDict['MOD'].keys():
            if op not in DiffDict['MOD'][obj]:
                continue
            moc = DiffDict['MOD'][obj][op]
            for cmd in moc.keys():
                CMDName = '%s %s\n'%(cmd,obj)
                fp.write(CMDName)

    #把修改的MOC命令写到result.txt
    def WriteModToFile(self, DiffDict, fp):
        for obj in DiffDict['MOD'].keys():
            #可能修改的命令
            moc = DiffDict['MOD'][obj]['MOD']
            for cmd in moc.keys():
                if self.CmdIsMod(moc[cmd]) != True:
                    continue
                CMDName = '%s %s\n'%(cmd,obj)
                fp.write(CMDName)
                self.WriteCMDModtoFile(moc[cmd], fp)
                
    #把增加，修改，或删除的属性及联想对象写的result.txt
    def WriteCMDModtoFile(self, CMDDict, fp):
        for op in CMDDict.keys():
            if len(CMDDict[op]) < 0:
                continue
            
            if op == 'ADD':
                fp.write('新增MML参数联想\n')
                for attr in CMDDict[op].keys():
                    AttrList = CMDDict[op][attr]
                    msgStr = u'%s \n联想对象为： %s 联想属性为：%s\n'%(attr, AttrList[0], AttrList[1])
                    msgStr += '\n'
                    fp.write(msgStr.encode('utf-8'))

            if op == 'RMV':
                fp.write('删除MML参数联想\n')
                for attr in CMDDict[op]:
                    msgStr = '%s\n'%attr
                    msgStr += '\n'
                    fp.write(msgStr)
              
            if op == 'MOD':
                if self.AttrIsMod(CMDDict[op]) == True:
                    fp.write('修改MML参数联想\n')
                else:
                    continue
                
                for attr in CMDDict[op]:
                    AttrDict = CMDDict[op][attr]
                    if AttrDict['new'][0] != AttrDict['old'][0] or AttrDict['new'][1] != AttrDict['old'][1]:
                        msgStr = '%s\n'%attr
                    else:
                        continue
                    if AttrDict['new'][0] != AttrDict['old'][0]:
                        msgStr += u'联想对象由 %s 改为 %s\n'%(AttrDict['old'][0],AttrDict['new'][0])
                    if AttrDict['new'][1] != AttrDict['old'][1]:
                        msgStr += u'联想属性由 %s 改为 %s\n'%(AttrDict['old'][1],AttrDict['new'][1])
                    msgStr += '\n'
                    fp.write(msgStr.encode('utf-8'))

    #判断命令属性是否修改
    def AttrIsMod(self, AttrDict):
        for attr in AttrDict.keys():
            if AttrDict[attr]['new'][0] != AttrDict[attr]['old'][0] or AttrDict[attr]['new'][1] != AttrDict[attr]['old'][1]:
                return True
        return False
    
    #判断命令是否修改
    def CmdIsMod(self, cmd):
        if 'ADD' in cmd.keys() and len(cmd['ADD']) > 0:
            return True
        if 'RMV' in cmd.keys() and len(cmd['RMV']) > 0:
            return True
        if self.AttrIsMod(cmd['MOD']) == True:
            return True
        return False