def parse_int(symbol_str, value_str, to_add = 1): as_list = to_add.__class__ == ListType assignments_str = None value = None range_value = None if (len(value_str) > 0): (signed, number) = parse_literal(value_str) if (number != None): value = LiteralIntValue(number, signed) int_value = value.value range_value = (RangeList([RangeNode(int_value, int_value, \ to_add)], \ as_list)) else: assignments_str = value_str value = AssignmentsIntValue(value_str) right = value.main_value.right if (right == None): range_value = None else: right_ranges = right.ranges new_ranges = [] for rr in right_ranges: new_ranges.append(RangeNode(rr[0], \ rr[1], \ to_add)) if (len(new_ranges) == 0): range_value = None else: range_value = RangeList(new_ranges, \ as_list) return ParsedInt(symbol_str, value, range_value, to_add)
def vote(self):
choices = self._vote()
if (choices is None):
return None
elif (self.rangify):
combined_range = RangeList(choices, self.as_list)
return [combined_range]
else:
return choices
def typed_update(self, parsed_value):
int_value = parsed_value.value
to_add = parsed_value.to_add
updated_counts = []
if (int_value == None):
parsed_range_value = parsed_value.range_value
if (parsed_range_value is None):
self.range_list.increment(to_add)
else:
self.add_range_list(parsed_range_value)
elif (int_value.__class__ == LiteralIntValue):
value = int_value.value
self.add_range_list(RangeList([RangeNode(value, value, \
to_add)], \
self.as_list))
elif (int_value.__class__ == AssignmentsIntValue):
right = int_value.main_value.right
if (right == None):
self.range_list.increment(to_add)
else:
right_ranges = right.ranges
new_ranges = []
for rr in right_ranges:
new_ranges.append(RangeNode(rr[0], \
rr[1], \
to_add))
range_list = RangeList(new_ranges, \
self.as_list)
if (len(new_ranges) == 0):
range_list.increment(to_add)
self.add_range_list(range_list)
else:
throw_error(str(int_value) + \
" is of unknown integer type, " + \
str(int_value.__class__))
if (len(self.range_list.ranges) == 0):
rest_count = None
if (self.range_list.as_list):
rest_count = len(self.range_list.rest)
else:
rest_count = self.range_list.rest
if (rest_count == 0):
throw_error("No ranges added")
return updated_counts
def parse_int_spec_value_part(range_string):
opposite = False
if (len(range_string) > 1 and range_string[0] == NOT_MARKER):
opposite = True
range_string = range_string[1:]
ranges = []
range_strings = range_string.split(OUT_RANGES_DELIM)
for range_string in range_strings:
(least_str, most_str) = range_string.split(OUT_RANGE_DELIM)
least = int(least_str)
most = int(most_str)
ranges.append(RangeNode(least, most))
range_spec = RangeList(ranges)
return IntSpecValuePart(opposite, range_spec)
def reparse_int(value_string, to_add = 1): range_value = None if (len(value_string) > 0 and value_string != UNKNOWN_STR): ranges = [] range_strings = value_string.split(OUT_RANGES_DELIM) for range_string in range_strings: (least_str, most_str) = \ range_string.split(OUT_RANGE_DELIM) least = int(least_str) most = int(most_str) ranges.append(RangeNode(least, most)) range_value = RangeList(ranges, to_add) return ParsedInt(None, None, range_value, to_add)
def _cast_vote(self, vote_holder, votes, infallible=None):
if (infallible is None):
infallible = votes is None
total_count = self.branch_stat.get_total_count()
if (infallible or votes is None):
# Vote that the function is infallible.
vote_holder.record_vote(None, 1.0, total_count)
else:
# Vote for the specific constraints.
key_votes = []
for index in votes:
key_votes.append(self.vote_points[index][0])
if (self.rangify):
error_range = RangeList(key_votes, False)
vote_holder.record_vote(error_range, 1.0, \
total_count)
else:
vote_holder.record_votes(key_votes, \
total_count)
from ranges import RangeNode, RangeList
BIG_SINGLE = RangeList([RangeNode(-1024, 1024)])
SMALL_SINGLE = RangeList([RangeNode(0, 32)])
ABOVE_SMALL_SINGLE = RangeList([RangeNode(33, 34), RangeNode(36, 38)])
ABOVE_RESULT = RangeList([RangeNode(0, 32), RangeNode(33, 34), \
RangeNode(36, 38)])
BELOW_SMALL_SINGLE = RangeList([RangeNode(-5, -3), RangeNode(-2, -1)])
BELOW_RESULT = RangeList([RangeNode(-5, -3), RangeNode(-2, -1), \
RangeNode(0, 32)])
WITHIN_BIG = RangeList([RangeNode(-25, -5), RangeNode(-4, -2), \
RangeNode(2, 4), RangeNode(5, 25)])
WITHIN_BIG_RESULT = RangeList([RangeNode(-1024, -26), RangeNode(-25, -5, 2), \
RangeNode(-4, -2, 2), RangeNode(-1, 1), \
RangeNode(2, 4, 2), RangeNode(5, 25, 2), \
RangeNode(26, 1024)])
AROUND_SMALL_SINGLE = RangeList([RangeNode(-5, -3), RangeNode(35, 50)])
AROUND_RESULT = RangeList([RangeNode(-5, -3), RangeNode(0, 32), \
RangeNode(35, 50)])
TOUCH_SMALL_SINGLE_BELOW = RangeList([RangeNode(-5, 3), RangeNode(35, 50)])
TOUCH_BELOW_RESULT = RangeList([RangeNode(-5, -1), RangeNode(0, 3, 2), \
RangeNode(4, 32), RangeNode(35, 50)])
TOUCH_SMALL_SINGLE_ABOVE = RangeList([RangeNode(-5, -3), RangeNode(30, 50)])
TOUCH_ABOVE_RESULT = RangeList([RangeNode(-5, -3), RangeNode(0, 29), \
RangeNode(30, 32, 2), RangeNode(33, 50)])
def __init__(self, threshold_ratio, as_list=False):
VoteResult.__init__(self, threshold_ratio, as_list)
self.range_votes = RangeList([], as_list)
def __init__(self, as_list=False):
ValueStat.__init__(self, INT_TYPE_START, as_list)
self.range_list = RangeList([], as_list)
self.bound_ranges = RangeList([], False, rest=RangeBinder())
class IntegerStat(ValueStat):
def __init__(self, as_list=False):
ValueStat.__init__(self, INT_TYPE_START, as_list)
self.range_list = RangeList([], as_list)
self.bound_ranges = RangeList([], False, rest=RangeBinder())
def add_range_list(self, new_range_list):
self.bound_ranges.add(new_range_list.clone_binder())
self.range_list.add(new_range_list)
def typed_update(self, parsed_value):
int_value = parsed_value.value
to_add = parsed_value.to_add
updated_counts = []
if (int_value == None):
parsed_range_value = parsed_value.range_value
if (parsed_range_value is None):
self.range_list.increment(to_add)
else:
self.add_range_list(parsed_range_value)
elif (int_value.__class__ == LiteralIntValue):
value = int_value.value
self.add_range_list(RangeList([RangeNode(value, value, \
to_add)], \
self.as_list))
elif (int_value.__class__ == AssignmentsIntValue):
right = int_value.main_value.right
if (right == None):
self.range_list.increment(to_add)
else:
right_ranges = right.ranges
new_ranges = []
for rr in right_ranges:
new_ranges.append(RangeNode(rr[0], \
rr[1], \
to_add))
range_list = RangeList(new_ranges, \
self.as_list)
if (len(new_ranges) == 0):
range_list.increment(to_add)
self.add_range_list(range_list)
else:
throw_error(str(int_value) + \
" is of unknown integer type, " + \
str(int_value.__class__))
if (len(self.range_list.ranges) == 0):
rest_count = None
if (self.range_list.as_list):
rest_count = len(self.range_list.rest)
else:
rest_count = self.range_list.rest
if (rest_count == 0):
throw_error("No ranges added")
return updated_counts
def show_data(self):
return "%s; %s"%(str(self.total_count), \
str(self.range_list))
def _gen_unnormalized(self):
unnormalized = IntegerStat()
base = None
if (self.as_list):
base = [1]
else:
base = 1
unnormalized.range_list = \
self.range_list.gen_normalized(base)
return unnormalized
def _gen_normalized(self):
normalized = IntegerStat()
normalized.range_list = \
self.range_list.gen_normalized(self.total_count)
return normalized
def _add(self, other):
total = IntegerStat(self.as_list)
total.range_list = self.range_list.clone_flat()
total.range_list.add(other.range_list)
return total
def __iter__(self):
return IntegerIter(self)
def short_str(self):
return range_list.short_str()
def is_wanted_key(self, target_key, candidate_key):
if (target_key is None):
return candidate_key is None
elif (candidate_key is None):
return False
return target_key.contains(candidate_key)
def key_is_unknown(self, key):
return key == None
def has_unknown(self):
return self.range_list.has_rest()
def covers(self, key):
if (self.range_list.has_rest()):
if (key is None):
return (COVER_EXACT, None)
else:
return (COVER_OVER, UNKNOWN_STR)
elif (key is None):
return (COVER_UNDER, UNKNOWN_STR)
coverers = self.bound_ranges.get_coverers(key)
if (len(coverers) == 0):
return (COVER_UNDER, key.short_str())
least = key.least
most = key.most
beginning = coverers[0].least
if (beginning < least):
return (COVER_OVER, coverers[0].short_str())
if (beginning > least):
missing = RangeNode(least, beginning - 1)
return (COVER_UNDER, missing.short_str())
end = coverers[-1].most
if (end > most):
return (COVER_OVER, coverers[-1].short_str())
if (end < most):
missing = RangeNode(end + 1, most)
return (COVER_UNDER, missing.short_str())
last_end = least
found_over = False
over = None
for coverer in coverers:
binder = coverer.count
for bound in binder:
if (bound.least < least or most < bound.most):
over = bound
found_over = True
pre_gap = coverer.least - 1
if (last_end < pre_gap):
missing = RangeNode(last_end, pre_gap)
return (COVER_UNDER, missing.short_str())
last_end = coverer.most + 1
if (found_over):
return (COVER_OVER, over.short_str())
return (COVER_EXACT, None)
def contains_parsed(self, parsed_value):
if (self.range_list.has_rest):
return True
else:
smooth = smoothen(self.range_list)
return smooth.contains_list(parsed_value.range_value)
def get_overlaps(self, other):
return self.range_list.find_overlaps(other.range_list)
def get_parsed_overlaps(self, other):
return self.range_list.find_overlaps(other.range_value)