GaudiKernel.ProcessJobOptions.JobOptsParser Class Reference

Public Member Functions
	__init__ (self)
	parse (self, file)

Public Attributes
dict	units = {}
dict	defines = {}

Static Public Attributes
	comment = re.compile(r"(//.*)$")
	comment_in_string = re.compile(r'(["\']).*//.*\1')
	directive = re.compile(r"^\s*#\s*([\w!]+)\s*(.*)\s*$")
tuple	comment_ml = (re.compile(r"/\*"), re.compile(r"\*/"))
str	statement_sep = ";"
	reference = re.compile(r"^@([\w.]*)$")

Protected Member Functions
	_include (self, file, function)
	_parse_units (self, file)
	_eval_statement (self, statement)

Protected Attributes
	_parse_units

Detailed Description

Definition at line 174 of file ProcessJobOptions.py.

Constructor & Destructor Documentation

__init__()

GaudiKernel.ProcessJobOptions.JobOptsParser.__init__

(

self

)

Definition at line 184 of file ProcessJobOptions.py.

    def __init__(self):
        # parser level states
        self.units = {}
        self.defines = {}
 

Member Function Documentation

_eval_statement()

GaudiKernel.ProcessJobOptions.JobOptsParser._eval_statement ( self, statement )

protected

Definition at line 341 of file ProcessJobOptions.py.

    def _eval_statement(self, statement):
        from GaudiKernel.Proxy.Configurable import (
            Configurable,
            ConfigurableGeneric,
            PropertyReference,
        )
 
        # statement = statement.replace("\n","").strip()
        _log.info("%s%s", statement, self.statement_sep)
 
        property, value = statement.split("=", 1)
 
        inc = None
        if property[-1] in ["+", "-"]:
            inc = property[-1]
            property = property[:-1]
 
        property = property.strip()
        value = value.strip()
 
        # find the configurable to apply the property to
        # parent_cfg = None
        # while '.' in property:
        #    component, property = property.split('.',1)
        #    if parent_cfg:
        #        if hasattr(parent_cfg,component):
        #            cfg = getattr(parent_cfg,component)
        #        else:
        #            cfg = ConfigurableGeneric(component)
        #            setattr(parent_cfg,component,cfg)
        #    else:
        #        cfg = ConfigurableGeneric(component)
        #    parent_cfg = cfg
 
        # remove spaces around dots
        property = ".".join([w.strip() for w in property.split(".")])
        component, property = property.rsplit(".", 1)
        if component in Configurable.allConfigurables:
            cfg = Configurable.allConfigurables[component]
        else:
            cfg = ConfigurableGeneric(component)
 
        # value = os.path.expandvars(value)
        value = value.replace("true", "True").replace("false", "False")
        if value[0] == "{":
            # Try to guess if the values looks like a dictionary
            if ":" in value and not (
                value[: value.index(":")].count('"') % 2
                or value[: value.index(":")].count("'") % 2
            ):
                # for dictionaries, keep the surrounding {}
                value = "{" + value[1:-1].replace("{", "[").replace("}", "]") + "}"
            else:  # otherwise replace all {} with []
                value = value.replace("{", "[").replace("}", "]")
 
        # We must escape '\' because eval tends to interpret them
        value = value.replace("\\", "\\\\")
        # Restore special cases ('\n', '\t' and '\"') (see GAUDI-1001)
        value = (
            value.replace(r"\\n", r"\n").replace(r"\\t", r"\t").replace(r'\\"', r"\"")
        )
        # replace r'\n' and r'\t' that are outside double quoted strings
        value = '"'.join(
            [
                (v if i % 2 else re.sub(r"\\[nt]", " ", v))
                for i, v in enumerate(value.split('"'))
            ]
        )
 
        # interprete the @ operator
        m = self.reference.match(value)
        if m:
            # this allows late binding of references
            value = PropertyReference(m.group(1))
        else:
            value = eval(value, self.units)
 
        # if type(value) is str    : value = os.path.expandvars(value)
        # elif type(value) is list : value = [ type(item) is str and os.path.expandvars(item) or item for item in value ]
 
        if property not in cfg.__slots__ and not hasattr(cfg, property):
            # check if the case of the property is wrong (old options are case insensitive)
            lprop = property.lower()
            for p in cfg.__slots__:
                if lprop == p.lower():
                    _log.warning(
                        "property '%s' was requested for %s, but the correct spelling is '%s'",
                        property,
                        cfg.name(),
                        p,
                    )
                    property = p
                    break
 
        # consider the += and -=
        if inc == "+":
            if hasattr(cfg, property):
                prop = getattr(cfg, property)
                if isinstance(prop, dict):
                    for k in value:
                        prop[k] = value[k]
                else:
                    prop += value
            else:
                setattr(cfg, property, value)
        elif inc == "-":
            if hasattr(cfg, property):
                prop = getattr(cfg, property)
                if isinstance(prop, dict):
                    for k in value:
                        if k in prop:
                            del prop[k]
                        else:
                            _log.warning(
                                "key '%s' not in %s.%s", k, cfg.name(), property
                            )
                else:
                    for k in value:
                        if k in prop:
                            prop.remove(k)
                        else:
                            _log.warning(
                                "value '%s' not in %s.%s", k, cfg.name(), property
                            )
        else:
            setattr(cfg, property, value)
 
 

_include()

GaudiKernel.ProcessJobOptions.JobOptsParser._include ( self, file, function )

protected

Definition at line 189 of file ProcessJobOptions.py.

    def _include(self, file, function):
        file = _find_file(file)
        if _to_be_included(file):
            _log.info("--> Including file '%s'", file)
            function(file)
            _log.info("<-- End of file '%s'", file)
 

_parse_units()

GaudiKernel.ProcessJobOptions.JobOptsParser._parse_units ( self, file )

protected

Definition at line 329 of file ProcessJobOptions.py.

    def _parse_units(self, file):
        for line in open(file):
            if "//" in line:
                line = line[: line.index("//")]
            line = line.strip()
            if not line:
                continue
            nunit, value = line.split("=")
            factor, unit = nunit.split()
            value = eval(value) / eval(factor)
            self.units[unit] = value
 

parse()

GaudiKernel.ProcessJobOptions.JobOptsParser.parse	(		self,
			file )

Definition at line 196 of file ProcessJobOptions.py.

    def parse(self, file):
        # states for the "translation unit"
        statement = ""
 
        ifdef_level = 0
        ifdef_skipping = False
        ifdef_skipping_level = 0
 
        in_string = False
 
        f = open(_find_file(file))
        l = f.readline()
        if l.startswith("#!"):
            # Skip the first line if it starts with "#!".
            # It allows to use options files as scripts.
            l = f.readline()
 
        while l:
            l = (
                l.rstrip() + "\n"
            )  # normalize EOL chars (to avoid problems with DOS new-line on Unix)
 
            # single line comment
            m = self.comment.search(l)
            if m:
                # check if the '//' is part of a string
                m2 = self.comment_in_string.search(l)
                # the '//' is part of a string if we find the quotes around it
                # and they are not part of the comment itself
                if not (m2 and m2.start() < m.start()):
                    # if it is not the case, we can remove the comment from the
                    # statement
                    l = l[: m.start()] + l[m.end() :]
            # process directives
            m = self.directive.search(l)
            if m:
                directive_name = m.group(1)
                directive_arg = m.group(2).strip()
                if directive_name == "include":
                    included_file = directive_arg.strip("'\"")
                    importOptions(included_file)
                elif directive_name == "units":
                    units_file = directive_arg.strip("'\"")
                    self._include(units_file, self._parse_units)
                elif directive_name in ["ifdef", "ifndef"]:
                    ifdef_skipping_level = ifdef_level
                    ifdef_level += 1
                    if directive_arg in self.defines:
                        ifdef_skipping = directive_name == "ifndef"
                    else:
                        ifdef_skipping = directive_name == "ifdef"
                elif directive_name == "else":
                    ifdef_skipping = not ifdef_skipping
                elif directive_name == "endif":
                    ifdef_level -= 1
                    if ifdef_skipping and ifdef_skipping_level == ifdef_level:
                        ifdef_skipping = False
                elif directive_name == "pragma":
                    if not directive_arg:
                        l = f.readline()
                        continue
                    pragma = directive_arg.split()
                    if pragma[0] == "print":
                        if len(pragma) > 1:
                            if pragma[1].upper() in ["ON", "TRUE", "1"]:
                                PrintOn()
                            else:
                                PrintOff()
                else:
                    _log.warning("unknown directive '%s'", directive_name)
                l = f.readline()
                continue
 
            if ifdef_skipping:
                l = f.readline()
                continue
 
            # multi-line comment
            m = self.comment_ml[0].search(l)
            if m:
                l, l1 = l[: m.start()], l[m.end() :]
                m = self.comment_ml[1].search(l1)
                while not m:
                    l1 = f.readline()
                    if not l1:
                        break  # EOF
                    m = self.comment_ml[1].search(l1)
                if not l1 and not m:
                    raise ParserError(
                        "End Of File reached before end of multi-line comment"
                    )
                l += l1[m.end() :]
 
            # if we are in a multiline string, we add to the statement
            # everything until the next '"'
            if in_string:
                string_end = l.find('"')
                if string_end >= 0:
                    statement += l[: string_end + 1]
                    l = l[string_end + 1 :]
                    in_string = False  # the string ends here
                else:
                    statement += l
                    l = ""
            else:  # check if we have a string
                string_start = l.find('"')
                if string_start >= 0:
                    string_end = l.find('"', string_start + 1)
                    if string_end >= 0:
                        # the string is opened and closed
                        statement += l[: string_end + 1]
                        l = l[string_end + 1 :]
                    else:
                        # the string is only opened
                        statement += l
                        in_string = True
                        l = f.readline()
                        continue
 
            if self.statement_sep in l:
                i = l.index(self.statement_sep)
                statement += l[:i]
                self._eval_statement(statement.strip().replace("\n", "\\n"))
                statement = l[i + 1 :]
                # it may happen (bug #37479) that the rest of the statement
                # contains a comment.
                if statement.lstrip().startswith("//"):
                    statement = ""
            else:
                statement += l
 
            l = f.readline()
 

Member Data Documentation

_parse_units

GaudiKernel.ProcessJobOptions.JobOptsParser._parse_units

protected

Definition at line 239 of file ProcessJobOptions.py.

comment

GaudiKernel.ProcessJobOptions.JobOptsParser.comment = re.compile(r"(//.*)$")

static

Definition at line 175 of file ProcessJobOptions.py.

comment_in_string

GaudiKernel.ProcessJobOptions.JobOptsParser.comment_in_string = re.compile(r'(["\']).*//.*\1')

static

Definition at line 178 of file ProcessJobOptions.py.

comment_ml

tuple GaudiKernel.ProcessJobOptions.JobOptsParser.comment_ml = (re.compile(r"/\*"), re.compile(r"\*/"))

static

Definition at line 180 of file ProcessJobOptions.py.

defines

dict GaudiKernel.ProcessJobOptions.JobOptsParser.defines = {}

Definition at line 187 of file ProcessJobOptions.py.

directive

GaudiKernel.ProcessJobOptions.JobOptsParser.directive = re.compile(r"^\s*#\s*([\w!]+)\s*(.*)\s*$")

static

Definition at line 179 of file ProcessJobOptions.py.

reference

GaudiKernel.ProcessJobOptions.JobOptsParser.reference = re.compile(r"^@([\w.]*)$")

static

Definition at line 182 of file ProcessJobOptions.py.

statement_sep

GaudiKernel.ProcessJobOptions.JobOptsParser.statement_sep = ";"

static

Definition at line 181 of file ProcessJobOptions.py.

units

dict GaudiKernel.ProcessJobOptions.JobOptsParser.units = {}

Definition at line 186 of file ProcessJobOptions.py.

---

The documentation for this class was generated from the following file:

• GaudiKernel/python/GaudiKernel/ProcessJobOptions.py