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_)
