def generateFunctions(self): """Generate source code for all functions in all categories.""" self.bufferAll_.set({'path': self.relativePath_}) loopIncludes = '''\ #include <%s/loop/loop_%s.hpp> #include <''' + self.relativePath_ + '''/loop.hpp>\n''' for cat in self.categoryList_.categories(self.name_, self.coreCategories_, self.addinCategories_): categoryIncludes = cat.includeList(loopIncludes) self.bufferAll_.append("#include <Addins/Cpp/%s.hpp>\n" % cat.name()) bufferCpp = '' bufferHpp = '' for func in cat.functions(self.name_): bufferCpp += self.generateFunction(func) bufferHpp += self.generateDeclaration(func) self.bufferBody_.set({ 'bufferCpp': bufferCpp, 'categoryIncludes': categoryIncludes }) self.bufferHeader_.set({ 'categoryName': cat.name(), 'bufferHpp': bufferHpp }) fileNameCpp = '%s%s.cpp' % (self.rootPath_, cat.name()) outputfile.OutputFile(self, fileNameCpp, cat.copyright(), self.bufferBody_) fileNameHpp = '%s%s.hpp' % (self.rootPath_, cat.name()) outputfile.OutputFile(self, fileNameHpp, cat.copyright(), self.bufferHeader_) self.bufferAll_.append("\n") fileNameAll = '%saddincpp.hpp' % self.rootPath_ outputfile.OutputFile(self, fileNameAll, self.copyright_, self.bufferAll_)
def generateCreators(self): """Generate source code for all functions in all categories.""" bufferAll = '' for cat in self.categoryList_.categories('*', self.coreCategories_, self.addinCategories_): if not cat.generateVOs(): continue bufferDeclarations = '' bufferCreators = '' bufferAll += Serialization.INCLUDE_CREATOR % { 'categoryName' : cat.name(), 'libRootDirectory' : environment.config().libRootDirectory() } for func in cat.functions('*'): if not func.generateVOs(): continue bufferDeclarations += Serialization.DECLARE_CREATOR % { 'functionName' : func.name() } bufferCreators += self.bufferCreator_.set({ 'cppConversions' : func.parameterList().generate( self.cppConversions_), 'enumConversions' : func.parameterList().generate( self.enumConversions_), 'functionName' : func.name(), 'libraryCall' : func.parameterList().generate( self.libraryCall_), 'libraryConversions' : func.parameterList().generate( self.libraryConversions_), 'libraryFunction' : func.libraryFunction(), 'objectConversions' : func.parameterList().generate( self.objectConversions_), 'namespaceObjects' : environment.config().namespaceObjects(), 'referenceConversions' : func.parameterList().generate( self.referenceConversions_), 'populateObjectIDs' : func.parameterList().generate( self.populateObjectIDs_) }) self.bufferHeader_.set({ 'categoryName' : cat.name(), 'bufferDeclarations' : bufferDeclarations, 'libRootDirectory' : environment.config().libRootDirectory(), 'namespaceObjects' : environment.config().namespaceObjects() }) createHeaderFile = self.rootPath_ + 'create/create_' + cat.name() + '.hpp' outputfile.OutputFile(self, createHeaderFile, self.copyright_, self.bufferHeader_) self.bufferIncludes_.set({ 'bufferCreators' : bufferCreators, 'serializationIncludes' : cat.serializationIncludes(), 'categoryName' : cat.name() }) createBodyFile = self.rootPath_ + 'create/create_' + cat.name() + '.cpp' outputfile.OutputFile(self, createBodyFile, self.copyright_, self.bufferIncludes_) self.bufferAll_.set({ 'bufferAll' : bufferAll, 'libRootDirectory' : environment.config().libRootDirectory() }) createAllFile = self.rootPath_ + 'create/create_all.hpp' outputfile.OutputFile(self, createAllFile, self.copyright_, self.bufferAll_)
def generateFuncMap(self): """Generate help text for function wizard.""" buf = '' for cat in self.categoryList_.categories(self.name_, self.coreCategories_, self.addinCategories_): buf += ' // %s\n\n' % cat.displayName() for func in cat.functions(self.name_, supportedplatform.MANUAL): buf += ' // %s\n\n' % func.name() buf += MAPLINE % ('funcMap', func.name(), func.name()) buf += MAPLINE % ('funcDesc', func.name(), func.description()) for param in func.parameterList().parameters(): buf += PARMLINE % ('argName', func.name(), param.name()) buf += PARMLINE % ('argDesc', func.name(), param.description()) buf += '\n' # replaced # buf2 ='' # buf2 = self.bufferMap_.text() % { # 'prefix' : environment.config().prefix(), # 'addinClassName' : 'QLAddin', # 'buffer' : buf } # fileName = self.rootPath_ + MAPFILE # outputfile.OutputFile(self, fileName, self.copyright_, buf2, True) # by self.bufferMap_.set({ 'prefix' : environment.config().prefix(), 'addinClassName' : 'CalcAddins_impl', 'buffer' : buf }) fileName = self.rootPath_ + MAPFILE outputfile.OutputFile(self, fileName, self.copyright_, self.bufferMap_, True)
def generateEnums(self): """Generate documentation for enumerations.""" bufClassLinks = '' for i in xrange(self.enumerationList_.enumeratedClassGroupsCount()): bufClassLinks += Doxygen.LINE_REF_CLASS % i bufTypeLinks = '' for i in xrange(self.enumerationList_.enumeratedTypeGroupsCount()): bufTypeLinks += Doxygen.LINE_REF_TYPE % i bufClassDocs = '' i = 0 for enumeratedClassGroup in self.enumerationList_.enumeratedClassGroups( ): bufClassDocs += self.generateEnumeratedClass( enumeratedClassGroup, i, Doxygen.LINE_SECTION_CLASS, Doxygen.LINE_TABLE % 'Class') i += 1 bufTypeDocs = '' i = 0 for enumeratedTypeGroup in self.enumerationList_.enumeratedTypeGroups( ): bufTypeDocs += self.generateEnumeratedType( enumeratedTypeGroup, i, Doxygen.LINE_SECTION_TYPE, Doxygen.LINE_TABLE % 'Type') i += 1 self.bufferEnumerations_.set({ 'classLinks': bufClassLinks, 'typeLinks': bufTypeLinks, 'classDocs': bufClassDocs, 'typeDocs': bufTypeDocs }) fileName = self.rootPath_ + 'enums.docs' outputfile.OutputFile(self, fileName, self.enumerationList_.enumeratedTypeCopyright(), self.bufferEnumerations_)
def generate(self, categoryList, enumerationList): """Generate source code for ValueObjects.""" self.categoryList_ = categoryList self.enumerationList_ = enumerationList allIncludes = '' log.Log.instance().logMessage(' begin generating ValueObjects ...') for cat in self.categoryList_.categories('*', self.coreCategories_, self.addinCategories_): if cat.generateVOs(): allIncludes += ValueObjects.VO_INCLUDE % { 'categoryName': cat.name(), 'libRootDirectory': environment.config().libRootDirectory() } if self.headersInline_: self.generateHeadersInline(cat) else: self.generateHeaders(cat) self.generateFunctions(cat) self.bufferAll_.set({ 'allIncludes': allIncludes, 'libRootDirectory': environment.config().libRootDirectory() }) allFilename = self.rootPath_ + 'vo_all.hpp' outputfile.OutputFile(self, allFilename, self.copyright_, self.bufferAll_) log.Log.instance().logMessage(' done generating ValueObjects.')
def outputRegisterFile(self, registerCode, unregisterCode, categoryName): """Write to disk the buffer for registering functions.""" self.bufferRegisterFile_.set({ 'categoryName' : categoryName.capitalize(), 'registerCode' : registerCode, 'unregisterCode' : unregisterCode }) registerFile = "%sregister/register_%s.cpp" % ( self.rootPath_, categoryName) outputfile.OutputFile(self, registerFile, self.copyright_, self.bufferRegisterFile_)
def generateExportSymbols(self): """Generate directives that cause exported symbols to be available to clients of this Addin.""" exportSymbols = '' for cat in self.categoryList_.categories(self.name_, self.coreCategories_, self.addinCategories_, supportedplatform.MANUAL): for func in cat.functions(self.name_, supportedplatform.MANUAL): exportSymbols += '#pragma comment (linker, "/export:_%s")\n' % func.name() self.exportStub_.set({'exportSymbols' : exportSymbols}) fileName = self.rootPath_ + 'functions/export.hpp' outputfile.OutputFile(self, fileName, self.copyright_, self.exportStub_)
def generateFunctions(self): """Generate source code for all functions in all categories.""" for cat in self.categoryList_.categories(self.name_, self.coreCategories_, self.addinCategories_): categoryIncludes = cat.includeList(LOOP_INCLUDES) self.bufferIncludes_.set({ 'categoryIncludes' : categoryIncludes }) for func in cat.functions(self.name_): self.bufferIncludes_.append(self.generateFunction(func)) fileName = '%sfunctions/%s.cpp' % ( self.rootPath_, cat.name()) outputfile.OutputFile(self, fileName, cat.copyright(), self.bufferIncludes_)
def generateHeaders(self, cat): """Generate source for function prototypes.""" bufHeader = '' for func in cat.functions(self.name_): bufHeader += self.generateHeader(func, ';\n') buf = CAddin.BUFFER_HEADER % { 'cat_name' : cat.name(), 'func_headers' : bufHeader, 'lib_name' : environment.config().prefix() } fileName = self.rootPath_ + cat.name() + '.h' fileHeader = outputfile.OutputFile(self, fileName, None, buf, False)
def generateLoops(self, cat): """Generate type definitions required for source code for loop functions.""" buf = '' for func in cat.functions('*'): if func.loopParameter(): buf += self.generateLoop(func) self.bufferFile_.set({ 'buffer' : buf, 'namespace' : environment.config().namespaceObjects() }) fileName = self.rootPath_ + 'loop_' + cat.name() + '.hpp' outputfile.OutputFile(self, fileName, self.copyright_, self.bufferFile_)
def generateFunctionList(self, allFuncs): """Generate alphabetical list of links to all functions.""" allFuncs.sort() bufList = '' for func in allFuncs: bufList += '\\ref %s ()\\n\n' % func self.bufferHeader_.set({ 'application' : environment.config().namespaceObjects(), 'count' : len(allFuncs), 'list' : bufList }) fileName = self.rootPath_ + 'allfunctions.docs' outputfile.OutputFile(self, fileName, self.copyright_, self.bufferHeader_)
def generateFuncHeaders(self, cat): """Generate source for function prototypes.""" prototypes = '' for func in cat.functions(self.name): prototypes += GuileAddin.BUF_HEADER % (func.name, ';\n') buf = self.bufferHeader.text % { 'categoryName': cat.name, 'prefix': environment.config().prefix, 'prototypes': prototypes } fileName = self.rootPath_ + cat.name() + '.h' outputfile.OutputFile(self, fileName, cat.copyright, buf, False)
def generateEnumeratedPairs(self): """Generate source file for enumerated types.""" if not self.enumerationList_.hasEnumeratedPairs: return buffer = '' # code to register the enumeration for enumeratedPairGroup in self.enumerationList_.enumeratedPairGroups( ): buffer += self.generateEnumeratedPair(enumeratedPairGroup) self.bufferEnumPairs_.set({'buffer': buffer}) fileName = self.rootPath_ + 'register_pairs.cpp' outputfile.OutputFile(self, fileName, self.enumerationList_.enumeratedPairCopyright(), self.bufferEnumPairs_)
def generateFunctions(self, cat): """Generate source for function implementations.""" codeBuffer = '' for func in cat.functions(self.name_): codeBuffer += self.generateHeader(func, ' {') codeBuffer += self.generateFunction(func) buf = self.bufferIncludes_.text() % { 'includes' : cat.includeList(), 'name' : cat.name(), 'prefix' : environment.config().prefix(), 'libRoot' : environment.config().libRootDirectory(), 'code' : codeBuffer } fileName = self.rootPath_ + cat.name() + '.cpp' outputfile.OutputFile(self, fileName, None, buf, False)
def generateInitFunc(self): """Generate initialisation function.""" headers = '' registrations = '' i = 0 for cat in self.categoryList_.categories(self.name_): i += 1 headers += '#include <' + cat.name() + '.h>\n' registrations += self.generateRegistrations(cat) #if i < len(self.categoryList_.categoryNames()): # registrations += '\n' buf = self.bufferInitFunc.text % (headers, registrations) fileName = self.rootPath + environment.config().prefix + 'addin.c' outputfile.OutputFile(self, fileName, self.copyright, buf, False)
def generateFunctions(self): """Generate source for function implementations.""" for cat in self.categoryList_.categories(self.name_): self.generateFuncHeaders(cat) code = '' for func in cat.functions(self.name_): code += GuileAddin.BUF_HEADER % (func.name(), ' {') code += self.generateFunction(func) buf = self.bufferIncludes_.text() % { 'includes': cat.includeList(), 'categoryName': cat.name, 'libRoot': environment.config().libRootDirectory, 'prefix': environment.config().prefix, 'code': code } fileName = self.rootPath_ + cat.name() + '.cpp' outputfile.OutputFile(self, fileName, cat.copyright, buf, False)
def generateAutoHeader(self): """Generate header file that lists all other headers.""" bufHeader = '' for cat in self.categoryList_.categories(self.name_, self.coreCategories_, self.addinCategories_): bufHeader += '#include <%s.hpp>\n' % cat.name() # replaced # buf = self.bufferHeader_.text() % { # 'prefix' : environment.config().prefix(), # 'buffer' : bufHeader } # fileName = self.rootPath_ + environment.config().libRootDirectory() + '_all.hpp' # outputfile.OutputFile(self, fileName, self.copyright_, buf, True) # by self.bufferHeader_.set({ 'prefix' : environment.config().prefix(), 'buffer' : bufHeader }) fileName = self.rootPath_ + environment.config().libRootDirectory() + '_all.hpp' outputfile.OutputFile(self, fileName, self.copyright_, self.bufferHeader_, True)
def generateCategoryDoc(self): """Generate page listing function categories.""" # ensure list of links is sorted alphabetically by display name dispNmToCatNm = {} displayNames = [] for cat in self.categoryList_.categories( '*', self.coreCategories_, self.addinCategories_): dispNmToCatNm[cat.displayName()] = cat.name() displayNames.append(cat.displayName()) displayNames.sort() bufCat = '' for displayKey in displayNames: bufCat += '\\ref func_%s\\n\n' % dispNmToCatNm[displayKey] self.bufferCategories_.set({ 'application' : environment.config().namespaceObjects(), 'categories' : bufCat }) fileName = self.rootPath_ + 'categories.docs' outputfile.OutputFile(self, fileName, self.copyright_, self.bufferCategories_)
def generate(self, categoryList, enumerationList): """Generate source code for C addin.""" self.categoryList_ = categoryList self.enumerationList_ = enumerationList log.Log.instance().logMessage(' begin generating C ...') summaryHeaders = '' for cat in self.categoryList_.categories(self.name_): self.generateHeaders(cat) self.generateFunctions(cat) summaryHeaders += '#include <Addins/C/%s.h>\n' % cat.name() buf = self.bufferHeader_.text() % { 'prefix' : environment.config().prefix(), 'headers' : summaryHeaders } fileName = self.rootPath_ + environment.config().prefix() + 'addin.h' outputfile.OutputFile(self, fileName, self.copyright_, buf, False) log.Log.instance().logMessage(' done generating C.')
def generateFunctions(self, cat): """Generate source for function implementations.""" bufFunc = '' for func in cat.functions('*'): if func.generateVOs(): bufFunc += self.generateFunction(func) self.bufferIncludes_.set({ 'categoryName': cat.name(), 'functions': bufFunc, 'libRoot': environment.config().libRootDirectory(), 'namespaceObjects': environment.config().namespaceObjects() }) fileName = self.rootPath_ + 'vo_' + cat.name() + '.cpp' outputfile.OutputFile(self, fileName, self.copyright_, self.bufferIncludes_)
def generateHeaders(self, cat): """Generate class source for constructor function prototypes.""" bufHeader = '' for func in cat.functions('*'): if func.generateVOs(): bufHeader += self.generateHeader(func) self.bufferIncludesDecl_.set({ 'categoryName': cat.name(), 'headers': bufHeader, 'libRoot': environment.config().libRootDirectory(), 'namespaceObjects': environment.config().namespaceObjects() }) fileName = self.rootPath_ + 'vo_' + cat.name() + '.hpp' outputfile.OutputFile(self, fileName, self.copyright_, self.bufferIncludesDecl_)
def generateHeaders(self): """Generate source for function prototypes.""" for cat in self.categoryList_.categories(self.name_, self.coreCategories_, self.addinCategories_): buf = '' for func in cat.functions(self.name_, supportedplatform.MANUAL): buf += self.generateHeader(func) # replaced # buf2 = self.bufferCategory_.text() % { # 'prefix' : environment.config().prefix(), # 'categoryName' : cat.name(), # 'buffer' : buf } # fileName = self.rootPath_ + cat.name() + '.hpp' # outputfile.OutputFile(self, fileName, cat.copyright(), buf2, True) # by self.bufferCategory_.set({ 'prefix' : environment.config().prefix(), 'categoryName' : cat.name(), 'buffer' : buf }) fileName = self.rootPath_ + cat.name() + '.hpp' outputfile.OutputFile(self, fileName, cat.copyright(), self.bufferCategory_, True)
def generateEnumeratedTypes(self): """Generate source file for enumerated types.""" if not self.enumerationList_.hasEnumeratedTypes: return codeRegister = '' # code to register the enumeration codeUnregister = '' # code to unregister the enumeration for enumeratedTypeGroup in self.enumerationList_.enumeratedTypeGroups( ): codeRegister += self.generateEnumeratedType(enumeratedTypeGroup) codeUnregister += Enumerations.ENUM_UNREGISTER % { 'type': enumeratedTypeGroup.type() } self.bufferEnumTypes_.set({ 'codeRegister': codeRegister, 'codeUnregister': codeUnregister }) fileName = self.rootPath_ + 'register_types.cpp' outputfile.OutputFile(self, fileName, self.enumerationList_.enumeratedTypeCopyright(), self.bufferEnumTypes_)
def generateDocs(self): """Generate doxygen documentation files.""" allFuncs = [] for cat in self.categoryList_.categories( '*', self.coreCategories_, self.addinCategories_): bufLink = '' bufDoc = '' for func in cat.functions('*'): if not func.visible(): continue bufLink += '\\ref %s ()\\n\n' % func.name() bufDoc += self.generateFunctionDoc(func) allFuncs.append(func.name()) self.bufferFile_.set({ 'categoryDescription' : cat.description(), 'categoryDisplayName' : cat.displayName(), 'categoryName' : cat.name(), 'documentation' : bufDoc, 'links' : bufLink }) fileName = self.rootPath_ + cat.name() + '.docs' outputfile.OutputFile(self, fileName, cat.copyright(), self.bufferFile_) self.generateFunctionList(allFuncs)
def generateFactory(self): """Generate source code for all functions in all categories.""" bufferCreators = '' for cat in self.categoryList_.categories('*', self.coreCategories_, self.addinCategories_): if not cat.generateVOs(): continue bufferCreators += '\n // %s\n\n' % cat.displayName() for func in cat.functions('*'): if not func.generateVOs(): continue bufferCreators += Serialization.REGISTER_CREATOR % { 'functionName' : func.name() } self.bufferFactory_.set({ 'bufferCreators' : bufferCreators, 'libRootDirectory' : environment.config().libRootDirectory(), 'namespaceObjects' : environment.config().namespaceObjects() }) factoryFile = self.rootPath_ + 'register_creators.cpp' outputfile.OutputFile(self, factoryFile, self.copyright_, self.bufferFactory_)
def generateAddin(self): """Generate source code to register functions.""" registerCalls = '' unregisterCalls = '' registerDeclarations = '' unregisterDeclarations = '' self.functionCount_ = 0 for cat in self.categoryList_.categories(self.name_, self.coreCategories_, self.addinCategories_, supportedplatform.MANUAL): categoryName = cat.name().capitalize() registerCalls += 8 * ' ' + 'register' + categoryName + '(xDll);\n' unregisterCalls += 8 * ' ' + 'unregister' + categoryName + '(xDll);\n' registerDeclarations += 'extern void register' + categoryName + '(const XLOPER&);\n' unregisterDeclarations += 'extern void unregister' + categoryName + '(const XLOPER&);\n' self.generateRegisterFunctions(cat) self.bufferRegisterCall_.set({ 'prefix' : environment.config().prefix().capitalize(), 'registerCalls' : registerCalls, 'unregisterCalls' : unregisterCalls, 'registerDeclarations' : registerDeclarations, 'unregisterDeclarations' : unregisterDeclarations }) registerCall = self.rootPath_ + 'register/register_all.cpp' outputfile.OutputFile(self, registerCall, self.copyright_, self.bufferRegisterCall_)
def generateIDL(self): """Generate the IDL file for the addin.""" buf = '' for cat in self.categoryList_.categories(self.name_, self.coreCategories_, self.addinCategories_): buf += ' // %s\n\n' % cat.name() for func in cat.functions(self.name_, supportedplatform.MANUAL): parameterList = func.parameterList().generate(self.ruleIDL_) returnTypeIDL = self.returnTypeIDL_.apply(func.returnValue()) # replaced # buf += self.bufferIdlFunction_.text() % (returnTypeIDL, # func.name(), parameterList) # by buf += ' ' + returnTypeIDL + ' ' + func.name() + '(' + parameterList + ');\n\n' # replaced # buf2 = self.bufferIdlHeader_.text() % { 'buffer' : buf } # idlFile = environment.config().namespaceLibrary() + 'AddinCalc.idl' # fileName = self.rootPath_ + idlFile # outputfile.OutputFile(self, fileName, self.copyright_, buf2, True) # by self.bufferIdlHeader_.set({ 'buffer' : buf }) idlFile = environment.config().namespaceLibrary() + 'AddinCalc.idl' fileName = self.rootPath_ + idlFile outputfile.OutputFile(self, fileName, self.copyright_, self.bufferIdlHeader_, True)
def generateFunctions(self): """Generate source for function implementations.""" for cat in self.categoryList_.categories(self.name_, self.coreCategories_, self.addinCategories_): buf = '' for func in cat.functions(self.name_): buf += self.generateFunction(func) categoryIncludes = cat.includeList(LOOP_INCLUDES) # replaced # buf2 = self.bufferIncludes_.text() % { # 'categoryIncludes' : categoryIncludes, # 'prefix' : environment.config().prefix(), # 'libRoot' : environment.config().libRootDirectory(), # 'buffer' : buf } # fileName = self.rootPath_ + cat.name() + '.cpp' # outputfile.OutputFile(self, fileName, cat.copyright(), buf2, True) # by self.bufferIncludes_.set({ 'categoryIncludes' : categoryIncludes, 'prefix' : environment.config().prefix(), 'libRoot' : environment.config().libRootDirectory(), 'buffer' : buf }) fileName = self.rootPath_ + cat.name() + '.cpp' outputfile.OutputFile(self, fileName, cat.copyright(), self.bufferIncludes_, True)
def generateFunctions(self): """Generate source code for all functions in all categories.""" loopIncludes = '' mpcbuffer = '' mpcdatareaderbuffer = '' # mpcdatareaderbufferNT = '' mpcbufferJava = '' idlfiles = '' mwcbufferJava = '' for cat in self.categoryList_.categories("Cpp", self.coreCategories_, self.addinCategories_): idlfilesTypeSupport = '' readersImplHpp = '' readersImplCpp = '' qlAddinName = cat.name() if (cat.name() == 'index') : cat.name_ = 'qlIndex' if (cat.name() == 'swap') : cat.name_ = 'qlSwapNS' categoryIncludes = cat.includeList(loopIncludes) idlfile = '\t%s.idl\n' % ( cat.name() ) idlfileTypeSupport = '\t%sTypeSupport.idl\n' % ( cat.name() ) readerImplHpp = '\t%sDataReaderListenerImpl.hpp\n' % ( cat.name() ) readerImplCpp = '\t%sDataReaderListenerImpl.cpp\n' % ( cat.name() ) bufferCpp = '' bufferHpp = '' bufferIDL = '' for func in cat.functions("Cpp"): bufferCpp += self.generateFunction(func, cat) bufferHpp += self.generateDataReaderDeclaration(func, cat) bufferIDL += self.generateIDL(func, cat) idlfiles += idlfile mpcbuffer += self.generateLib(func, cat, idlfile, idlfileTypeSupport, readerImplHpp, readerImplCpp) mpcdatareaderbuffer += self.generateLibDataReader(func, cat, idlfile, idlfileTypeSupport, readerImplHpp, readerImplCpp) # mpcdatareaderbufferNT += self.generateLibDataReaderNT(func, cat, idlfile, idlfileTypeSupport, readerImplHpp, readerImplCpp) print("Processing catalog : " + cat.name()) self.bufferBody_.set({ 'bufferCpp' : bufferCpp, 'qlAddinName' : qlAddinName, 'categoryName' : cat.name(), 'categoryIncludes' : categoryIncludes }) self.bufferHeader_.set({ 'categoryName' : cat.name(), 'bufferHpp' : bufferHpp, 'qlAddinName' : qlAddinName, 'categoryIncludes' : categoryIncludes }) self.bufferModule_.set({ 'categoryName' : cat.name(), 'bufferIdl' : bufferIDL }) self.bufferMpc_.set({ 'mpcbuffer' : mpcbuffer }) self.bufferMpcDataReader_.set({ 'mpcdatareaderbuffer' : mpcdatareaderbuffer }) # self.bufferMpcDataReaderNT_.set({ 'mpcdatareaderbuffer' : mpcdatareaderbufferNT }) fileNameCpp = '%s%sDataReaderListenerImpl.cpp' % ( self.rootPath_, cat.name()) outputfile.OutputFile(self, fileNameCpp, cat.copyright(), self.bufferBody_) fileNameHpp = '%s%sDataReaderListenerImpl.hpp' % ( self.rootPath_, cat.name()) outputfile.OutputFile(self, fileNameHpp, cat.copyright(), self.bufferHeader_) fileNameIdl = '%s%s.idl' % ( self.rootPath_, cat.name()) outputfile.OutputFile(self, fileNameIdl, cat.copyright(), self.bufferModule_) java_dir = '../java/Addins/OpenDDS/%s' % ( cat.name() ) if not os.path.exists(java_dir): os.makedirs(java_dir) fileNameJavaIdl = '%s/%s.idl' % ( java_dir, cat.name() ) outputfile.OutputFile( self, fileNameJavaIdl, cat.copyright(), self.bufferModule_ ) mpcbufferJava = self.generateLibJava( cat.name(), cat.name() + ".idl" ) self.bufferMpcJava_.set({ 'mpcbuffer' : mpcbufferJava }) self.bufferMpcJava_.append("\n") fileNameMpcJava = '%s/QLDDS_Java_%s.mpc' % ( java_dir, cat.name() ) outputfile.OutputFile( self, fileNameMpcJava, '', self.bufferMpcJava_ ) mpc_java_path = '%s/QLDDS_Java_%s.mpc' % ( cat.name(), cat.name() ) mwcbufferJava += mpc_java_path + '\n' self.bufferMpc_.append("\n") fileNameMpc = '%sQLDDS.mpc' % self.rootPath_ outputfile.OutputFile(self, fileNameMpc, '', self.bufferMpc_) self.bufferMpcDataReader_.append("\n") fileNameMpc = '%sQLDDSDataReaders.mpc' % self.rootPath_ outputfile.OutputFile(self, fileNameMpc, '', self.bufferMpcDataReader_) # self.bufferMpcDataReaderNT_.append("\n") # fileNameMpc = '%sQLDDSDataReaders_vc.mpc' % self.rootPath_ # outputfile.OutputFile(self, fileNameMpc, '', self.bufferMpcDataReaderNT_) self.bufferMwcJava_.set({'paths' : mwcbufferJava }) self.bufferMwcJava_.append("\n") fileNameMwcJava = '../java/Addins/OpenDDS/QLDDS_Java.mwc' outputfile.OutputFile(self, fileNameMwcJava, '', self.bufferMwcJava_ )
def generateFunctionCount(self): """Generate a header indicating the number of functions in this addin.""" self.bufferNumFunc_.set({ 'functionCount' : self.functionCount_ }) fileName = self.rootPath_ + 'functions/functioncount.hpp' outputfile.OutputFile(self, fileName, self.copyright_, self.bufferNumFunc_)