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 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 init(self, enumerationList):
"""Generate list of #include directives necessary to compile code
in this category."""
self.addinIncludeList_ = self.enumIncludes(enumerationList, False)
if self.addinIncludes_ == None:
self.addinIncludeList_ += "#include <%s/%s.hpp>\n" % (environment.config().libRootDirectory(), self.name_)
else:
for includeFile in self.addinIncludes_:
self.addinIncludeList_ += "#include <%s>\n" % includeFile
if self.generateVOs_:
self.addinIncludeList_ += "#include <%s/valueobjects/vo_%s.hpp>\n" % (
environment.config().libRootDirectory(),
self.name_,
)
self.serializationIncludeList_ = self.enumIncludes(enumerationList, True)
if self.serializationIncludes_ == None:
self.serializationIncludeList_ += Category.SERIALIZATION_INCLUDES % {
"categoryName": self.name_,
"libRootDirectory": environment.config().libRootDirectory(),
}
else:
for includeFile in self.serializationIncludes_:
self.serializationIncludeList_ += "#include <%s>\n" % includeFile
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,
'namespaceObjects' : environment.config().namespaceObjects(),
'categoryIncludes' : categoryIncludes })
self.bufferHeader_.set({
'categoryName' : cat.name(),
'namespaceObjects' : environment.config().namespaceObjects(),
'bufferHpp' : bufferHpp })
fileNameCpp = '%scpp_%s.cpp' % ( self.rootPath_, cat.name())
outputfile.OutputFile(self, fileNameCpp, cat.copyright(), self.bufferBody_)
fileNameHpp = '%scpp_%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 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 <Addins/Calc/%s.hpp>\n' % cat.name()
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)
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 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 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)
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)
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 __init__(self, addinIds):
"""Initialize the AddinList object."""
self.categoryList_ = categorylist.CategoryList()
if environment.config().usingEnumerations():
self.enumerationList_ = enumerationlist.EnumerationList()
self.enumerationList_.update(environment.config())
else:
self.enumerationList_ = None
self.categoryList_.init(self.enumerationList_)
self.addins_ = []
for addinId in addinIds:
creator, fileName = AddinList.creators[addinId]
self.addins_.append(utilities.serializeObject(creator, 'metadata/addins/' + fileName))
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 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 includeList(self, loopBuffer=None):
"""Return the list of #include directives required for source code
relating to this Category."""
ret = self.addinIncludeList_
if loopBuffer and self.containsLoopFunction_:
ret += loopBuffer % (environment.config().libRootDirectory(), self.name_)
return ret
def __init__(self):
"""Configure the function to loop."""
# Save a reference to the input parameter on which the function loops.
self.loopParamRef_ = None
for param in self.func_.parameterList().parameters():
if param.name() == self.func_.loopParameter():
self.loopParamRef_ = param
break
if not self.loopParamRef_:
raise exceptions.BehaviorLoopParameterException(self.func_.name(), self.func_.loopParameter())
if self.loopParamRef_.default():
raise exceptions.BehaviorLoopDefaultException(self.func_.name(), self.func_.loopParameter())
# Try to trap a few of the common problems that would prevent
# the generated source code of the loop function from compiling.
if self.loopParamRef_.tensorRank() != common.VECTOR:
raise exceptions.BehaviorLoopNonVectorException(self.func_.name(), self.func_.loopParameter())
if self.func_.returnValue().tensorRank() != common.VECTOR:
raise exceptions.BehaviorReturnNonVectorException(self.func_.name(), self.func_.loopParameter())
# Configure the function to loop on the given parameter.
self.loopParamRef_.setLoop(True)
self.func_.returnValue().setLoop(True)
self.functionName_ = environment.config().namespaceObjects() + '::' + self.func_.name()
self.functionSignature_ = ''
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 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 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 serialize(self, serializer):
"""Load/unload class state to/from serializer object."""
serializer.serializeAttribute(self, common.NAME)
serializer.serializeProperty(self, common.DESCRIPTION)
serializer.serializeProperty(self, common.LONG_DESC, self.description_)
serializer.serializeObjectDict(self, supportedplatform.SupportedPlatform)
serializer.serializeProperty(self, common.ALIAS, environment.config().namespaceObjects() + '::' + self.name_)
serializer.serializeObject(self, parameterlist.ParameterList)
serializer.serializeBoolean(self, common.DOCUMENTATION_ONLY)
serializer.serializeAttributeBoolean(self, common.DEPENDENCY_TRIGGER, True)
serializer.serializeAttributeBoolean(self, 'visible', True)
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 invokeRule(self):
return self.ruleResult_ % {
'classname' : self.param_.fullType().classname(),
common.DEFAULT_VALUE : self.param_.default(),
common.DESC_LEN : len(self.paramDesc_),
common.DESCRIPTION : self.paramDesc_,
common.ERROR_VALUE : self.param_.errorValue(),
common.INDENT2 : self.indent_ + ' ',
common.INDENT : self.indent_,
common.NAME : self.param_.name(),
common.NAME_CONVERTED : self.param_.nameConverted(),
common.NAME_UPPER : self.param_.name().upper(),
common.NAMESPACE_LIB : environment.config().namespaceLibrary(),
common.NAMESPACE_OBJ : environment.config().namespaceObjects(),
common.NATIVE_TYPE : self.param_.fullType().nativeType(),
common.OBJECT_REFERENCE : self.param_.fullType().objectReference(),
common.SUPER_TYPE : self.param_.fullType().superType(),
common.TENSOR_RANK : self.param_.tensorRank(),
common.TYPE : self.param_.fullType().value() }
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 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 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 generate(self, categoryList, enumerationList):
"""Generate doxygen documentation files."""
self.categoryList_ = categoryList
self.enumerationList_ = enumerationList
log.Log.instance().logMessage(' begin generating Doxygen ...')
self.generateDocs()
if environment.config().usingEnumerations():
self.generateEnums()
self.generateCategoryDoc()
log.Log.instance().logMessage(' done generating Doxygen.')
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 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)
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)
def invokeRule(self):
return self.ruleResult_ % {
'classname': self.param_.fullType().classname(),
common.DEFAULT_VALUE: self.param_.default(),
common.DESC_LEN: len(self.paramDesc_),
common.DESCRIPTION: self.paramDesc_,
common.ERROR_VALUE: self.param_.errorValue(),
common.INDENT2: self.indent_ + ' ',
common.INDENT: self.indent_,
common.NAME: self.param_.name(),
common.NAME_CONVERTED: self.param_.nameConverted(),
common.NAME_UPPER: self.param_.name().upper(),
common.NAMESPACE_LIB: environment.config().namespaceLibrary(),
common.NAMESPACE_OBJ: environment.config().namespaceObjects(),
common.NATIVE_TYPE: self.param_.fullType().nativeType(),
common.OBJECT_REFERENCE: self.param_.fullType().objectReference(),
common.SUPER_TYPE: self.param_.fullType().superType(),
common.TENSOR_RANK: self.param_.tensorRank(),
common.TYPE: self.param_.fullType().value()
}
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 generateBody(self, addin):
"""Generate source code for function body."""
return Constructor.funcCtorBuffer_ % {
'functionName' : self.name_,
'idStrip' : addin.idStrip(self.parameterList_),
'idSuffix' : addin.objectIdSuffix(),
'libraryFunction' : self.libraryFunction_,
'libraryParameters' : self.parameterList_.generate(addin.libraryCall()),
'namespaceObjects' : environment.config().namespaceObjects(),
'overwriteVariable' : addin.overwriteVariable(),
'repositoryClass' : addin.repositoryClass(),
'voParameters' : self.parameterList_.generate(addin.voCall()) }
def enumIncludes(self, enumerationList, constructorOnly):
ret = ""
if environment.config().usingEnumerations():
enumIncludes = []
for func in self.functions_.values():
if constructorOnly and not func.generateVOs():
continue
enumIncludes.extend(enumerationList.enumIncludes(func.parameterList().parameters()))
enumIncludesUnique = self.sort_uniq(enumIncludes)
for enumInclude in enumIncludesUnique:
ret += "#include <%s>\n" % enumInclude
return ret
def generate(self, categoryList, enumerationList):
"""Generate doxygen documentation files."""
self.categoryList_ = categoryList
self.enumerationList_ = enumerationList
log.Log.instance().logMessage(' begin generating Doxygen ...')
self.generateDocs()
if environment.config().usingEnumerations():
self.generateEnums()
self.generateCategoryDoc()
log.Log.instance().logMessage(' done generating Doxygen.')
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 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 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 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 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 generateBody(self, addin):
"""Generate source code for function body."""
return Constructor.funcCtorBuffer_ % {
'functionName': self.name_,
'idStrip': addin.idStrip(self.parameterList_),
'idSuffix': addin.objectIdSuffix(),
'libraryFunction': self.libraryFunction_,
'libraryParameters': self.parameterList_.generate(
addin.libraryCall()),
'namespaceObjects': environment.config().namespaceObjects(),
'overwriteVariable': addin.overwriteVariable(),
'repositoryClass': addin.repositoryClass(),
'voParameters': self.parameterList_.generate(addin.voCall())
}
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 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())
buf += self.bufferIdlFunction_.text() % (returnTypeIDL,
func.name(), parameterList)
buf2 = self.bufferIdlHeader_.text() % { 'buffer' : buf }
idlFile = environment.config().namespaceLibrary() + 'AddinCalc.idl'
fileName = self.rootPath_ + idlFile
outputfile.OutputFile(self, fileName, self.copyright_, buf2, True)
def generateBody(self, addin):
"""Generate source code for the body of the function."""
if self.functionSignature_:
functionSignature = '(' + environment.config().namespaceObjects() + '::' + self.functionSignature_ + ')'
else:
functionSignature = ''
addin.bufferLoop().set({
'inputList' : self.func_.parameterList().generate(addin.loopInputs()),
'inputParam' : addin.loopName(self.loopParamRef_),
'functionCodeName' : self.functionCodeName_,
'functionName' : self.functionName_,
'functionSignature' : functionSignature,
'inputType' : addin.loopReturnType().apply(self.loopParamRef_),
'returnType' : addin.loopReturnType().apply(self.func_.returnValue()) })
return addin.bufferLoop().text()
def serialize(self, serializer):
"""Load/unload class state to/from serializer object."""
serializer.serializeAttribute(self, common.NAME)
serializer.serializeProperty(self, common.DESCRIPTION)
serializer.serializeProperty(self, common.LONG_DESC, self.description_)
serializer.serializeObjectDict(self,
supportedplatform.SupportedPlatform)
serializer.serializeProperty(
self, common.ALIAS,
environment.config().namespaceObjects() + '::' + self.name_)
serializer.serializeObject(self, parameterlist.ParameterList)
serializer.serializeBoolean(self, common.DOCUMENTATION_ONLY)
serializer.serializeAttributeBoolean(self, common.DEPENDENCY_TRIGGER,
True)
serializer.serializeAttributeBoolean(self, 'visible', True)
def __init__(self, addinIds):
"""Initialize the AddinList object."""
self.categoryList_ = categorylist.CategoryList()
if environment.config().usingEnumerations():
self.enumerationList_ = enumerationlist.EnumerationList()
else:
self.enumerationList_ = None
self.categoryList_.init(self.enumerationList_)
self.addins_ = []
for addinId in addinIds:
creator, fileName = AddinList.creators[addinId]
self.addins_.append(
utilities.serializeObject(creator,
'metadata/addins/' + fileName))
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 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 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 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 printCopyright(self, copyright):
"""Print the copyright message relevant for this source code file."""
copyrightTrim = OutputFile.TRIM_WHITESPACE.sub(' ', copyright)
self.outFile_.write(environment.config().copyrightBuffer() %
{'copyright': copyrightTrim})
def generateRegister(self):
"""Generate source code for serialization factory."""
allIncludes = ''
bufferRegister = ''
# Keep track of the ID assigned to each Addin class by
# the boost serialization framework. This number is initialized to 4
# because 0-3 are reserved for ObjectHandler as explained in file
# QuantLibAddin/qlo/serialization/register/serialization_oh.cpp
classID = 4
# Initialize the global map with the values reserved for ObjectHandler.
# 0 and 1 refer respectively to ValueObject and vector of ValueObject,
# but these are omitted because they never occur in app XML data.
idMap = { 'ohGroup' : 2, 'ohRange' : 3 }
for cat in self.categoryList_.categories(
'*', self.coreCategories_, self.addinCategories_):
if not cat.generateVOs(): continue
bufferCpp = ''
allIncludes += Serialization.REGISTER_INCLUDE % {
'categoryName' : cat.name(),
'addinDirectory' : environment.config().libRootDirectory() }
bufferRegister += Serialization.REGISTER_TYPE % {
'categoryDisplayName' : cat.displayName(),
'categoryName' : cat.name() }
self.bufferSerializeDeclaration_.set({
'addinDirectory' : environment.config().libRootDirectory(),
'categoryName' : cat.name(),
'namespaceAddin' : environment.config().namespaceObjects() })
headerFile = '%sregister/serialization_%s.hpp' % (
self.rootPath_, cat.name() )
outputfile.OutputFile(self, headerFile, self.copyright_, self.bufferSerializeDeclaration_)
for func in cat.functions('*'):
if not func.generateVOs(): continue
bufferCpp += Serialization.REGISTER_CALL % {
'classID' : classID,
'functionName' : func.name(),
'namespaceObjects' : environment.config().namespaceObjects() }
idMap[func.name()] = classID
classID += 1
self.bufferSerializeBody_.set({
'addinDirectory' : environment.config().libRootDirectory(),
'bufferCpp' : bufferCpp,
'categoryName' : cat.name(),
'libRootDirectory' : environment.config().libRootDirectory(),
'namespaceAddin' : environment.config().namespaceObjects() })
cppFile = '%sregister/serialization_%s.cpp' % ( self.rootPath_, cat.name() )
outputfile.OutputFile(self, cppFile, self.copyright_, self.bufferSerializeBody_)
self.bufferSerializeAll_.set({
'includeGuard' : environment.config().libRootDirectory(),
'allIncludes' : allIncludes,
'addinDirectory' : environment.config().libRootDirectory() })
allFilename = self.rootPath_ + 'register/serialization_all.hpp'
outputfile.OutputFile(self, allFilename, self.copyright_, self.bufferSerializeAll_)
self.bufferSerializeRegister_.set({
'addinDirectory' : environment.config().libRootDirectory(),
'bufferRegister' : bufferRegister,
'namespaceAddin' : environment.config().namespaceObjects() })
factoryFile = self.rootPath_ + 'register/serialization_register.hpp'
outputfile.OutputFile(self, factoryFile, self.copyright_, self.bufferSerializeRegister_)
