def WriteClientFile(headerFiles, pf, ph, genericFunctions): codeGenCommon.WriteWarning(ClientFileText) print >> ClientFileText, '\n' + '\n'.join('#include "%s"' % h for h in headerFiles) + '\n' print >> ClientFileText, codeGenCommon.DefaultPackerUnpacker print >> ClientFileText, common.FormatCode(ClientGenericCode) # Note that this does not need to be an ordered dictionary, unlike genericFunctions protoDict = { n: codeGenCommon.GetFuncPrototypeStr(f) for n, f in genericFunctions.items() } print >> ClientFileText, common.FormatCode(ClientStartFuncCode, proto=protoDict) print >> ClientFileText, ClientStartClientCode for f in pf.values(): #print f if f.handlerName: # Write out the handler first; there should only be one # todo: How can this be enforced for h in ph.values(): if h.name == f.handlerName: WriteClientHandler(f, h, ClientHandlerTemplate) break # Write out the functions next WriteFuncCode(f, FuncImplTemplate) funcsWithHandlers = [f for f in pf.values() if f.handlerName] WriteAsyncHandler(funcsWithHandlers, AsyncHandlerTemplate) return ClientFileText
def WriteLocalHeaderFile(pf, ph, hashValue, fileName, serviceName): # TODO: This is a temporary workaround. Some API files require a larger message size, so # hand-code the required size. The size is not increased for all API files, because # this could significantly increase memory usage, although it is bumped up a little # bit from 1000 to 1100. # # In the future, this size will be automatically calculated. # if fileName.endswith( ("le_secStore_messages.h", "secStoreAdmin_messages.h") ): maxMsgSize = 8500 elif fileName.endswith("le_cfg_messages.h"): maxMsgSize = 1600 else: maxMsgSize = 1100 codeGenCommon.WriteWarning(LocalHeaderFileText) WriteIncludeGuardBegin(LocalHeaderFileText, fileName) print >>LocalHeaderFileText, common.FormatCode(LocalHeaderStartTemplate, idString=hashValue, serviceName=serviceName, maxMsgSize=maxMsgSize) # Write out the message IDs for the functions for i, name in enumerate(pf): print >>LocalHeaderFileText, "#define _MSGID_%s %i" % (name, i) print >>LocalHeaderFileText WriteIncludeGuardEnd(LocalHeaderFileText, fileName) return LocalHeaderFileText
def WriteHandlerCode(func, template): # The prototype parameter is only needed for the AsyncFuncHandlerTemplate, but it does no # harm to always include it. It will be ignored for the other template(s). funcStr = common.FormatCode( template, func=func, respondProto=codeGenCommon.GetRespondFuncPrototypeStr(func)) print >> ServerFileText, funcStr
def WriteServerFile(headerFiles, pf, ph, genericFunctions, genAsync): codeGenCommon.WriteWarning(ServerFileText) print >> ServerFileText, '\n' + '\n'.join('#include "%s"' % h for h in headerFiles) + '\n' print >> ServerFileText, codeGenCommon.DefaultPackerUnpacker print >> ServerFileText, ServerGenericCode # Note that this does not need to be an ordered dictionary, unlike genericFunctions protoDict = { n: codeGenCommon.GetFuncPrototypeStr(f) for n, f in genericFunctions.items() } print >> ServerFileText, common.FormatCode(ServerStartFuncCode, proto=protoDict) print >> ServerFileText, ServerStartClientCode for f in pf.values(): #print f if f.handlerName: # Write out the handler first; there should only be one per function for h in ph.values(): if h.name == f.handlerName: WriteAsyncFuncCode(f, h, FuncAsyncTemplate) break # Write out the functions next. # Functions that have handler parameters, or are Add and Remove handler functions are # never asynchronous. if genAsync and not f.handlerName and not f.isRemoveHandler: WriteHandlerCode(f, AsyncFuncHandlerTemplate) else: WriteHandlerCode(f, FuncHandlerTemplate) WriteMsgHandler(pf.values(), MsgHandlerTemplate) return ServerFileText
def WriteTypeDefinition(fp, typeDef): typeDefStr = common.FormatCode(TypeDefinitionTemplate, typeDef=typeDef) print >>fp, typeDefStr
def WriteCommonInterface(fp, startTemplate, pf, ph, pt, importList, fileName, genericFunctions, headerComments, genAsync): codeGenCommon.WriteWarning(fp) # Write the user-supplied doxygen-style header comments for comments in headerComments: print >>fp, comments WriteIncludeGuardBegin(fp, fileName) print >>fp, common.FormatCode(startTemplate) # Write the imported include files. if importList: print >>fp, '// Interface specific includes' for i in importList: print >>fp, '#include "%s"' % i print >>fp, '\n' # Write out the prototypes for the generic functions for s in genericFunctions.values(): print >>fp, "%s;\n" % codeGenCommon.GetFuncPrototypeStr(s) # Write out the type definitions for t in pt.values(): # Types that have a simple definition will have the appropriate attribute; otherwise call an # explicit function to write out the definition. if hasattr(t, "definition"): WriteTypeDefinition(fp, t) elif isinstance( t, codeTypes.EnumData ): WriteEnumDefinition(fp, t) elif isinstance( t, codeTypes.BitMaskData ): # TODO: Bitmask may get it's own function later WriteEnumDefinition(fp, t) else: # todo: Should I print an error or something here? pass # Write out the handler type definitions for h in ph.values(): WriteHandlerTypeDef(fp, h) # Write out the function prototypes, and if required, the respond function prototypes for f in pf.values(): #print f # Functions that have handler parameters, or are Add and Remove handler functions are # never asynchronous. if genAsync and not f.handlerName and not f.isRemoveHandler : print >>fp, "%s;\n" % codeGenCommon.GetRespondFuncPrototypeStr(f) print >>fp, "%s;\n" % codeGenCommon.GetServerAsyncFuncPrototypeStr(f) else: print >>fp, "%s;\n" % codeGenCommon.GetFuncPrototypeStr(f) WriteIncludeGuardEnd(fp, fileName)
def WriteIncludeGuardEnd(fp, fileName): print >>fp, common.FormatCode(IncludeGuardEndTemplate, fileName=FormatFileName(fileName))
def WriteHandlerTypeDef(fp, handler): headerComment = AddHandlerParamComments(handler.comment, handler.parmList) handlerStr = common.FormatCode(HandlerTypeTemplate, handler=handler, headerComment=headerComment) print >>fp, handlerStr
def WriteEnumDefinition(fp, enumDef): enumDefStr = common.FormatCode(EnumDefinitionTemplate, enumDef=enumDef) print >>fp, enumDefStr
def GetServerAsyncFuncPrototypeStr(func): funcStr = common.FormatCode(ServerAsyncFuncPrototypeTemplate, func=func) # Remove any leading or trailing whitespace on the return string, such as newlines, so that # it doesn't add extra, unintended, spaces in the generated code output. return funcStr.strip()
def FormatHeaderComment(comment): comment = '\n * '.join(comment.splitlines()) headerComment = common.FormatCode(HeaderCommentTemplate, comment=comment) # Strip any leading/trailing white space return headerComment.strip()
def WriteAsyncFuncCode(func, handler, template): handlerStr = common.FormatCode(template, func=func, handler=handler) print >> ServerFileText, handlerStr
def WriteMsgHandler(flist, template): print >> ServerFileText, common.FormatCode(template, funcList=flist)
def WriteFuncCode(func, template): funcStr = common.FormatCode( template, func=func, prototype=codeGenCommon.GetFuncPrototypeStr(func)) print >> ClientFileText, funcStr
def WriteAsyncHandler(flist, template): print >> ClientFileText, common.FormatCode(template, funcList=flist)
def WriteClientHandler(func, handler, template): funcStr = common.FormatCode(template, func=func, handler=handler) print >> ClientFileText, funcStr