def create_output_action_list(self, pkt, output_filter):
ret = []
if self.after_trivially_unsat(pkt):
# TODO: somethign
pass
else:
if self.before_output is not None:
before_output = self.before_output.instantiate_fvs(
MapFVValue(None, pkt)).apply(pkt)
choose_before = before_output.associate([(1, self.id, 0)])
ret.append(choose_before)
if self.after_output is not None:
after_output = self.after_output.instantiate_fvs(
MapFVValue(None, pkt))
bplist = after_output.bplist
for i, bp in enumerate(bplist):
if i != after_output.index:
ret.append(
OutputAction([bp.negate().apply(pkt)],
[(1, self.id, 1)]))
else:
ret.append(
OutputAction([], [(1, self.id, 1)], output_filter))
else:
if self.before is None:
assert False, "We're doomed! "
def after_trivially_unsat(self, pkt):
# type:(MapInputValue) -> bool
conf = MapFVValue(self.fvs, pkt)
if not self.after_input.instantiate_fvs(MapFVValue(conf,
pkt)).apply(pkt):
return True
return False
def before_trivially_satisfied(self, pkt):
# type:(MapInputValue) -> bool
conf = MapFVValue(self.fvs, pkt)
if self.before_output is None:
if self.before_input.instantiate_fvs(MapFVValue(conf,
pkt)).apply(pkt):
return True
return False
def create_output_action_list(self, pkt):
ret = []
if self.after_trivially_unsat(pkt):
# TODO: somethign
print "if after is trivially unsatisfiable, we can choose between setting setting before to true or not"
if self.before_trivially_satisfied(pkt):
assert False, "should have been checked up front at record"
else:
before_output = self.before_output.instantiate_fvs(
MapFVValue(None, pkt))
bplist = before_output.bplist
for bp in bplist:
if isinstance(bp, BoundedEQ):
ret.append(
OutputAction([], [(0, self.id, 1)],
bp.negate().get_filter()))
else:
ret.append(
OutputAction([bp.negate().apply(pkt)],
[(0, self.id, 1)]))
ret.append(OutputAction([], [(0, self.id, 0)], Filter(
{}))) # Choose 0 by negating result
return OutputActionList(ret, False)
else:
if self.before_output is not None:
before_output = self.before_output.instantiate_fvs(
MapFVValue(None, pkt)).apply(pkt)
choose_before = before_output.associate([(0, self.id, 0)])
ret.append(choose_before)
if self.after_output is not None:
after_output = self.after_output.instantiate_fvs(
MapFVValue(None, pkt))
bplist = after_output.bplist
for bp in bplist:
if isinstance(bp, BoundedEQ):
ret.append(
OutputAction([], [(0, self.id, 1)],
bp.negate().get_filter()))
else:
ret.append(
OutputAction([bp.negate().apply(pkt)],
[(0, self.id, 1)]))
else:
if self.before is None:
assert False, "We're doomed! "
return OutputActionList(ret, False)
def after_trivially_unsat(self, pkt):
if self.after_input is not None:
try:
if not self.after_input.instantiate_fvs(MapFVValue(
None, pkt)).apply(pkt).is_true():
return True
except UnsatisfiableActionException:
return True
return False
def before_trivially_satisfied(self, pkt):
# type:(MapInputValue) -> bool
if self.before_output is None:
try:
if self.before_input.instantiate_fvs(MapFVValue(
None, pkt)).apply(pkt).is_true():
return True
except UnsatisfiableActionException:
pass
return False
def get_fv_value_mapping(fvs, pkt):
return MapFVValue(fvs, pkt)
def get_filter(self, pkt):
conf = MapFVValue(self.fvs, pkt)
return self.after.instantiate_fvs(conf).get_filter()
def apply(self, pkt):
# type: (MapInput,Value) -> OutputActionList
conf = MapFVValue(self.fvs, pkt)
ret = self.expr.instantiate_fvs(conf).apply(pkt)
return ret
def get_filter(self):
pkt = MapInputValue(None, 0, [])
return self.after.instantiate_fvs(MapFVValue(
None, pkt)).apply(pkt).get_filter()
pass
def get_fv_value_mapping(self, pkt):
# type: (MapInputValue) -> MapFVValue
return MapFVValue(self.fvs, pkt)