condformats_serialization_generate.SerializationCodeGenerator Class Reference

Inheritance diagram for condformats_serialization_generate.SerializationCodeGenerator:

Public Member Functions
def	__init__ (self, scramFlags=None)
def	cleanFlags (self, flagsIn)
def	generate (self, outFileName)

Public Attributes
	classes
	cmssw_base
	split_path

Private Member Functions
def	_join_package_path (self, path)

Detailed Description

Definition at line 419 of file condformats_serialization_generate.py.

Constructor & Destructor Documentation

def condformats_serialization_generate.SerializationCodeGenerator.__init__	(		self,
			scramFlags = None
	)

Definition at line 421 of file condformats_serialization_generate.py.

    def __init__(self, scramFlags=None):

        self.cmssw_base = os.getenv('CMSSW_BASE')
        if self.cmssw_base is None:
            raise Exception('CMSSW_BASE is not set.')
        logging.debug('cmssw_base = %s', self.cmssw_base)

        cwd = os.getcwd()
        logging.debug('cwd = %s', cwd)

        if not cwd.startswith(self.cmssw_base):
            raise Exception('The filepath does not start with CMSSW_BASE.')

        relative_path = cwd[len(self.cmssw_base)+1:]
        logging.debug('relative_path = %s', relative_path)

        self.split_path = split_path(relative_path)
        logging.debug('splitpath = %s', self.split_path)

        if len(self.split_path) < 3:
            raise Exception('This script requires to be run inside a CMSSW package (usually within CondFormats), e.g. CondFormats/Alignment. The current path is: %s' % self.split_path)

        if self.split_path[0] != 'src':
            raise Exception('The first folder should be src.')

        if self.split_path[1] != 'CondFormats':
            raise Exception('The second folder should be CondFormats.')

        product_name = '%s%s' % (self.split_path[1], self.split_path[2])
        logging.debug('product_name = %s', product_name)

        if not scramFlags:
            cpp_flags = get_flags(product_name, 'CPPFLAGS')
            cxx_flags = get_flags(product_name, 'CXXFLAGS')
        else:
            cpp_flags = self.cleanFlags( scramFlags )
            cxx_flags = []

        # We are using libClang, thus we have to follow Clang include paths
        std_flags = get_default_gcc_search_paths(gcc='clang++')
        log_flags('cpp_flags', cpp_flags)
        log_flags('cxx_flags', cxx_flags)
        log_flags('std_flags', std_flags)

        flags = ['-xc++'] + cpp_flags + cxx_flags + std_flags

        headers_h = self._join_package_path('src', 'headers.h')
        logging.debug('headers_h = %s', headers_h)
        if not os.path.exists(headers_h):
            raise Exception('File %s does not exist. Impossible to serialize package.' % headers_h)

        logging.info('Searching serializable classes in %s/%s ...', self.split_path[1], self.split_path[2])

        logging.debug('Parsing C++ classes in file %s ...', headers_h)
        # On macOS we need to costruct library search path
        if "SCRAM_ARCH" in os.environ and re.match('osx10*',os.environ['SCRAM_ARCH']):
            cindex=clang.cindex
            libpath=os.path.dirname(os.path.realpath(clang.cindex.__file__))+"/../../lib"
            cindex.Config.set_library_path(libpath)
            index = cindex.Index.create()
        else :
            index = clang.cindex.Index.create()
        translation_unit = index.parse(headers_h, flags)
        if not translation_unit:
            raise Exception('Unable to load input.')

        severity_names = ('Ignored', 'Note', 'Warning', 'Error', 'Fatal')
        get_severity_name = lambda severity_num: severity_names[severity_num] if severity_num < len(severity_names) else 'Unknown'
        max_severity_level = 0 # Ignored
        diagnostics = get_diagnostics(translation_unit)
        for diagnostic in diagnostics:
            logf = logging.error

            # Ignore some known warnings
            if diagnostic['spelling'].startswith('argument unused during compilation') \
                or diagnostic['spelling'].startswith('unknown warning option'):
                logf = logging.debug

            logf('Diagnostic: [%s] %s', get_severity_name(diagnostic['severity']), diagnostic['spelling'])
            logf('   at line %s in %s', diagnostic['location'].line, diagnostic['location'].file)

            max_severity_level = max(max_severity_level, diagnostic['severity'])

        if max_severity_level >= 3: # Error
            raise Exception('Please, resolve all errors before proceeding.')

        self.classes = get_serializable_classes_members(translation_unit.cursor, only_from_path=self._join_package_path())

Member Function Documentation

def condformats_serialization_generate.SerializationCodeGenerator._join_package_path (   self,   path  )

private

Definition at line 509 of file condformats_serialization_generate.py.

References condformats_serialization_generate.SerializationCodeGenerator.cmssw_base, and condformats_serialization_generate.SerializationCodeGenerator.split_path.

Referenced by condformats_serialization_generate.SerializationCodeGenerator.generate().

    def _join_package_path(self, *path):
        return os.path.join(self.cmssw_base, self.split_path[0], self.split_path[1], self.split_path[2], *path)

def condformats_serialization_generate.SerializationCodeGenerator.cleanFlags	(		self,
			flagsIn
	)

Definition at line 512 of file condformats_serialization_generate.py.

    def cleanFlags(self, flagsIn):
        flags = [ flag for flag in flagsIn if not flag.startswith(('-march', '-mtune', '-fdebug-prefix-map', '-ax', '-wd')) ]
        blackList = ['--', '-fipa-pta', '-xSSE3', '-fno-crossjumping', '-fno-aggressive-loop-optimizations']
        return [x for x in flags if x not in blackList]

def condformats_serialization_generate.SerializationCodeGenerator.generate	(		self,
			outFileName
	)

Definition at line 517 of file condformats_serialization_generate.py.

References condformats_serialization_generate.SerializationCodeGenerator._join_package_path(), condformats_serialization_generate.SerializationCodeGenerator.classes, join(), condformats_serialization_generate.sanitise(), and condformats_serialization_generate.SerializationCodeGenerator.split_path.

    def generate(self, outFileName):

        filename = outFileName
        if not filename:  # in case we're not using scram, this may not be set, use the default then, assuming we're in the package dir ...
            filename = self._join_package_path('src', 'Serialization.cc')

        n_serializable_classes = 0

        source = headers_template.format(headers=os.path.join(self.split_path[1], self.split_path[2], 'src', 'headers.h'))

        for klass in sorted(self.classes):
            (node, serializable, all_template_types, base_objects, members, transients) = self.classes[klass]

            if not serializable:
                continue

            n_serializable_classes += 1

            skip_instantiation = False
            for template_types in all_template_types:
                if template_types:
                    skip_instantiation = True
                    source += ('template <%s>' % ', '.join(['%s %s' % template_type for template_type in template_types])) + '\n'

            source += serialize_method_begin_template.format(klass=klass) + '\n'

            for base_object_name in base_objects:
                base_object_name_sanitised = sanitise(base_object_name)
                source += serialize_method_base_object_template.format(base_object_name=base_object_name, base_object_name_sanitised=base_object_name_sanitised) + '\n'

            for member_name in members:
                member_name_sanitised = sanitise(member_name)
                source += serialize_method_member_template.format(member_name=member_name, member_name_sanitised=member_name_sanitised) + '\n'

            source += serialize_method_end

            if skip_instantiation:
                source += '\n'
            else:
                source += instantiation_template.format(klass=klass) + '\n'

        if n_serializable_classes == 0:
            raise Exception('No serializable classes found, while this package has a headers.h file.')

        # check if we have a file for template instantiations and other "special" code:
        if os.path.exists( './src/SerializationManual.h' ) :
            source += '#include "%s/%s/src/SerializationManual.h"\n' % (self.split_path[1], self.split_path[2])

        logging.info('Writing serialization code for %s classes in %s ...', n_serializable_classes, filename)
        with open(filename, 'wb') as fd:
            fd.write(source)

Member Data Documentation

condformats_serialization_generate.SerializationCodeGenerator.classes

Definition at line 507 of file condformats_serialization_generate.py.

Referenced by condformats_serialization_generate.SerializationCodeGenerator.generate().

condformats_serialization_generate.SerializationCodeGenerator.cmssw_base

Definition at line 423 of file condformats_serialization_generate.py.

Referenced by condformats_serialization_generate.SerializationCodeGenerator._join_package_path().

condformats_serialization_generate.SerializationCodeGenerator.split_path

Definition at line 437 of file condformats_serialization_generate.py.

Referenced by condformats_serialization_generate.SerializationCodeGenerator._join_package_path(), and condformats_serialization_generate.SerializationCodeGenerator.generate().