/usr/share/pyshared/vamos/model.py is in undertaker 1.3b-1.1.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 | #
# vamos - common auxiliary functionality
#
# Copyright (C) 2011-2012 Christian Dietrich <christian.dietrich@informatik.uni-erlangen.de>
# Copyright (C) 2011-2012 Reinhard Tartler <tartler@informatik.uni-erlangen.de>
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
from vamos.rsf2model.RsfReader import RsfReader
import logging
import re
class Model(dict):
def __init__(self, path, rsf = None):
dict.__init__(self)
self.path = path
self.always_on_items = set()
with open(path) as fd:
self.parse(fd)
if not rsf and path.endswith(".model"):
rsf = path[:-len(".model")] + ".rsf"
if rsf:
try:
with open(rsf) as f:
self.rsf = RsfReader(f)
except IOError:
logging.warning ("no rsf file for model %s was found", path)
def parse(self, fd):
for line in fd.readlines():
line = line.strip()
if line.startswith("UNDERTAKER_SET ALWAYS_ON"):
line = line.split(" ")[2:]
always_on_items = [ l.strip(" \t\"") for l in line]
for item in always_on_items:
self[item] = None
self.always_on_items.add(item)
continue
elif line.startswith("I:") or line.startswith("UNDERTAKER_SET"):
continue
line = line.split(" ", 1)
if len(line) == 1:
self[line[0]] = None
elif len(line) == 2:
self[line[0]] = line[1].strip(" \"\t\n")
def mentioned_items(self, key):
"""
@return list of mentioned items of the key's implications
"""
expr = self.get(key, "")
if expr == None:
return []
expr = re.split("[()&!|><-]", expr)
expr = [x.strip() for x in expr]
return [x for x in expr if len(x) > 0]
def leaf_features(self):
"""
Leaf features are feature that aren't mentioned anywhere else
@return list of leaf features in model
"""
# Dictionary of mentioned items
features = dict([(key, False) for key in self.keys()
if not key.endswith("_MODULE")])
for key in features.keys():
items = self.mentioned_items(key)
items += self.mentioned_items(key + "_MODULE")
for mentioned in items:
# Strip _MODULE POSTFIX
if mentioned.endswith("_MODULE"):
mentioned = mentioned[:-len("_MODULE")]
# A Leaf can't "unleaf" itself. This is important for
# circular relations like:
#
# CONFIG_A -> !CONFIG_A_MODULE
# CONFIG_A_MODULE -> !CONFIG_A
if key != mentioned and mentioned in features:
features[mentioned] = True
return sorted([key for key in features if features[key] == False])
def get_type(self, symbol):
"""
RuntimeError gets raised if no corresponding rsf is found.
@return data type of symbol.
"""
if not self.rsf:
raise RuntimeError("No corresponding rsf file found.")
if symbol.startswith("CONFIG_"):
symbol = symbol[len("CONFIG_"):]
return self.rsf.get_type(symbol)
def is_bool_tristate(self, symbol):
"""
Returns true if symbol is tristate, otherwise false is returned.
Raises RuntimeError if no corresponding rsf-file is found.
"""
if not self.rsf:
raise RuntimeError("No corresponding rsf file found.")
if symbol.startswith("CONFIG_"):
symbol = symbol[len("CONFIG_"):]
return self.rsf.is_bool_tristate(symbol)
def slice_symbols(self, initial):
"""
Apply the slicing algorithm to the given set of symbols
returns a list of interesting symbol
"""
if type(initial) == list:
stack = initial
else:
stack = [initial]
visited = set()
while len(stack) > 0:
symbol = stack.pop()
visited.add(symbol)
for new_symbols in self.mentioned_items(symbol):
if not new_symbols in visited:
stack.append(new_symbols)
return list(visited)
|