| # Copyright 2019-present Infosys Limited |
| # SPDX-License-Identifier: Apache-2.0 |
| |
| import re |
| from template import Template |
| import os |
| from openpyxl import load_workbook |
| |
| libData = {} |
| progData = {} |
| template = Template() |
| wb = load_workbook('dataModel/prototypeV8.xlsx') |
| class xlUtils: |
| def __init__(self): |
| pass |
| |
| |
| def extractField(field): |
| varName = '' |
| varType = '' |
| encodeCondition = '' |
| decodeCondition = '' |
| validation = '' |
| count = '' |
| mVarName = re.search('^(\w+)',str(field)) |
| mVarType = re.search(':Type\[(\w+)\]',str(field)) |
| mEnCond = re.search(':Condition\[([^\:]*)\]',str(field)) |
| mDeCond = re.search(':DecodeCondition\[([^\:]*)]',str(field)) |
| mValid = re.search(':Validation\[([^\:]+)\]',str(field)) |
| mCount = re.search(':Count\[([^\:]*)]',str(field)) |
| if mVarName: |
| varName = mVarName.group(1) |
| |
| if mVarType: |
| varType = mVarType.group(1) |
| |
| if mEnCond: |
| encodeCondition = mEnCond.group(1) |
| |
| if mDeCond: |
| decodeCondition = mDeCond.group(1) |
| else: |
| if mEnCond: |
| decodeCondition = mEnCond.group(1) |
| |
| |
| if mValid: |
| validation = mValid.group(1) |
| dataVarName = 'data.' + varName |
| validation = re.sub(r'\$.',dataVarName,validation) |
| |
| if mCount: |
| count = mCount.group(1) |
| |
| return (varName,varType,encodeCondition,decodeCondition,validation,count) |
| |
| def lengthToType(byteLength): |
| lTdict = {1:'Uint8',2:'Uint16',3:'Uint32',4:'Uint32',5:'Uint64',6:'Uint64',7:'Uint64',8:'Uint64',65535:'Uint8',9:'Uint8',12:'Uint8'} |
| return lTdict[byteLength] |
| |
| def getByteLength(sheet,i): |
| length = 0 |
| lengthStr = '' |
| cell_value_C = xlUtils.getCellValue(sheet,i,'C') |
| octets = str(cell_value_C) |
| |
| mTo = re.search('to',str(octets)) |
| mVar = re.search('^variable\[(.*)]',str(octets)) |
| mToD = re.search('^(\d+) to (\d+)',str(octets)) |
| mToWD = re.search('^(\w) to (\w)\+(\d+)',str(octets)) |
| mToWWD = re.search('^(\w)\+(\d+) to (\w)\+(\d+)',str(octets)) |
| |
| if not mTo: |
| if mVar: |
| lenStr = mVar.group(1) |
| length = 65535 |
| lengthStr = lenStr |
| |
| elif xlUtils.getBitLength(sheet,i,'D') == 8: |
| length = 1 |
| |
| else: |
| if mToD: |
| toD = mToD.group(1) |
| toD2 = mToD.group(2) |
| length = int(toD2) - int(toD) + 1 |
| |
| elif mToWD: |
| ToWD = mToWD.group(3) |
| length = int(ToWD) + 1 |
| |
| elif mToWWD: |
| ToWWD2 = mToWWD.group(2) |
| ToWWD4 = mToWWD.group(4) |
| length = int(ToWWD4) - int(ToWWD2) + 1 |
| return (length,lengthStr) |
| |
| def getBitLength(sheet,i,j): |
| length = 0 |
| fieldName = xlUtils.getCellValue(sheet,i,j) |
| mcolDtoK = re.search('[D-K]',j) |
| if fieldName != None and mcolDtoK: |
| for k in map(chr, range( ord(j), ord('L'))): |
| fName = xlUtils.getCellValue(sheet,i,k) |
| |
| if length == 0: |
| length = length + 1 |
| |
| elif fName == None: |
| length = length + 1 |
| |
| else: |
| break |
| return length |
| |
| |
| def getCellValue(sheet,row,column): |
| colNum = 0 |
| chartoint = {'A' : 1,'B' : 2, 'C' : 3, 'D' : 4, 'E' : 5, 'F' : 6, 'G' : 7, |
| 'H' : 8, 'I' : 9, 'J' : 10, 'K' : 11, 'L' : 12, 'M' : 13, 'N' : 14, |
| 'O' : 15, 'P' : 16, 'Q' : 17, 'R' : 18, 'S' : 19, 'T' : 20, 'U' : 21, |
| 'V' : 22, 'W' : 23, 'X' : 24, 'Y' : 25, 'Z' : 26} |
| |
| colNum = chartoint[column] |
| cellvalue = sheet.cell(row=row, column=colNum).value |
| return cellvalue |
| |
| def getVarNameFromString(localString,typeName): |
| |
| localString = localString.lower() |
| varName = '' |
| localString = re.sub(r'\(.*\)'," ",localString) |
| localString=localString.replace('/'," ") |
| localString = re.sub('-'," ",localString) |
| tokens = [x.capitalize() for x in localString.split(" ")] |
| varName = varName.join(tokens) |
| varName = varName[0].upper() + varName[1:] |
| if typeName == 1: |
| return varName |
| else: |
| return varName[0].lower() + varName[1:] |
| |
| def templateProcess(templateData,ttFileNameCpp,ttFileNameH,outputDirCpp,outputDirH): |
| |
| |
| template = Template() |
| |
| if not os.path.exists(outputDirCpp): |
| os.makedirs(outputDirCpp) |
| outputFileNameCpp = templateData['fileName'] + '.cpp' |
| |
| template.__init__({'OUTPUT' : outputFileNameCpp, 'OUTPUT_PATH' : outputDirCpp}) |
| template.process(ttFileNameCpp, {'tempdata' : templateData}) |
| |
| |
| if not os.path.exists(outputDirH): |
| os.makedirs(outputDirH) |
| outputFileNameH = templateData['fileName'] + '.h' |
| template.__init__({'OUTPUT' : outputFileNameH, 'OUTPUT_PATH' : outputDirH}) |
| template.process(ttFileNameH, {'tempdata' : templateData}) |
| |
| def addToMakeSo(libName,objFile,srcFile): |
| |
| fileData = {} |
| fileData['objFile'] = objFile |
| fileData['sourceFile'] = srcFile |
| if libName not in libData: |
| lib = libName |
| lib = re.sub(r'.so','',lib) |
| libData[libName] = {} |
| libData[libName]['libName'] = lib |
| libData[libName]['fileList'] = [] |
| if fileData not in libData[libName]['fileList']: |
| libData[libName]['fileList'].append(fileData) |
| |
| def addToMakeExe(progName,objFile,srcFile): |
| fileData = {} |
| fileData['objFile'] = objFile |
| fileData['sourceFile'] = srcFile |
| |
| if progName not in progData: |
| prog = progName |
| prog = re.sub(r'.exe','',prog) |
| progData[progName] = {} |
| progData[progName]['progName'] = prog |
| |
| progData[progName]['fileList'] = [] |
| progData[progName]['fileList'].append(fileData) |
| |
| def addSoToMakeExe(progName,soName): |
| if progName not in progData: |
| prog = progName |
| prog = re.sub(r'.exe','',prog) |
| progData[progName] = {} |
| progData[progName]['progName'] = prog |
| |
| progData[progName]['soList'] = [] |
| progData[progName]['soList'].append(soName) |
| |
| def generateMakeFile(): |
| makeFileData = {} |
| |
| for libr in libData.keys(): |
| makeFileData['libList'] = [] |
| makeFileData['libList'].append(libData[libr]) |
| for prog in progData.keys(): |
| makeFileData['progList']=[] |
| makeFileData['progList'].append(progData[prog]) |
| |
| |
| ttFileName = 'tts/makefiletemplate.tt' |
| |
| fileName = 'Makefile' |
| outputDir='../../src/gtpV2Codec' |
| |
| template.__init__({'OUTPUT' : fileName, 'OUTPUT_PATH' : outputDir}) |
| template.process(ttFileName, {'makefiledata': makeFileData}) |
| |
| xlUtils() |