Combine per-error-type error code enums into a single error code enum
- also suppress code generation of OFPortNo which is already handled
by the pre-written OFPort class
diff --git a/java_gen/codegen.py b/java_gen/codegen.py
index b84556c..d94d78a 100644
--- a/java_gen/codegen.py
+++ b/java_gen/codegen.py
@@ -50,7 +50,7 @@
shutil.rmtree(basedir)
os.makedirs(basedir)
copy_prewrite_tree(basedir)
-
+ java_model.adjust_ir()
gen = JavaGenerator(basedir)
gen.create_of_interfaces()
gen.create_of_classes()
diff --git a/java_gen/java_model.py b/java_gen/java_model.py
index 13a0d09..c074189 100644
--- a/java_gen/java_model.py
+++ b/java_gen/java_model.py
@@ -46,8 +46,99 @@
import java_gen.java_type as java_type
from java_gen.java_type import erase_type_annotation
+# Key is modified name of error code; value is OFErrorType value string
+error_type_map = {}
+
+def adjust_ir():
+ """
+ For Java we change of_error_message to combine the 16-bit type and code
+ fields into a single 32-bit code field and we combine the per-error-type
+ code enums into a single ofp_error_code enum. This enables the generated
+ OFErrorMsg class to have a getCode method that can return all supported
+ error codes. Otherwise we'd need to do something like having per-error-type
+ subclasses of OFErrorMsg that had a getCode that returned the different
+ error codes for each error type, which would be less convenient for clients
+ and would also entail changing the LOXI OF input files and impacting other
+ language backends.
+ """
+ for version in of_g.target_version_list:
+ of_protocol = of_g.ir[version]
+ error_type = find(lambda e: e.name == "ofp_error_type", of_protocol.enums)
+ if error_type == None:
+ raise Exception("ofp_error_type enum not found; OF version: " + str(version))
+ error_code_entries = []
+ # For each error type value look up the corresponding error code enum.
+ # Add those values to the combined entries for the new ofp_error_code
+ # enum. The name of the new value is formed by concatenating the name
+ # of the error type value with the name of the old error code value.
+ for error_type_entry in error_type.entries:
+ # Strip off the OFPxx prefix
+ prefix_length = error_type_entry.name.find('_')
+ if prefix_length < 0:
+ raise Exception("OFPET prefix not found for ofp_error_type value " + error_type_entry.name + "; OF version: " + str(version))
+ error_type_entry_name = error_type_entry.name[prefix_length+1:]
+ if error_type_entry_name == "EXPERIMENTER":
+ # There isn't an error code enum defined for the experimenter error type
+ # FIXME: Need to add support for the message ofp_error_experimenter_msg format
+ continue
+ # The per-error-type code enums follow a naming conventions where
+ # the middle part of the enum name is the same as the name of the
+ # error type value (except lower-case).
+ error_code_enum_name = "ofp_" + error_type_entry_name.lower() + "_code"
+ # Look up the error code enum from the IR
+ error_code_enum = None
+ for i, enum in enumerate(of_protocol.enums):
+ if enum.name == error_code_enum_name:
+ error_code_enum = enum
+ # We don't want to generate code for the per-error-type
+ # enum so remove it from the IR
+ del of_protocol.enums[i]
+ break
+ if error_code_enum == None:
+ raise Exception("Error code enum not found: " + error_code_enum_name + "; OF version: " + str(version))
+ for error_code_entry in error_code_enum.entries:
+ # Strip off the prefix from the entry name
+ prefix_length = error_code_entry.name.find('_')
+ if prefix_length < 0:
+ raise Exception("Prefix not found for error code value " + error_code_entry.name + "; OF version: " + str(version))
+ error_code_entry_name = error_code_entry.name[prefix_length+1:]
+ # Combine the entry type name and the error code name
+ error_code_entry_name = error_type_entry_name + "_" + error_code_entry_name
+ # Combine the entry type value and the error code value
+ error_code_entry_value = (error_type_entry.value << 16) + error_code_entry.value
+ # Add the enum entry to the combined ofp_error_code
+ # Note that the "OFPEC" prefix is arbitrary. It will be stripped
+ # off again during Java code generation, but there needs to be
+ # some/any prefix
+ error_code_entries.append(OFEnumEntry("OFPEC_" + error_code_entry_name, error_code_entry_value, {}))
+ error_type_map[error_code_entry_name] = error_type_entry_name
+ # We've collected all of the entries. Now we can add the enum to the IR
+ of_protocol.enums.append(OFEnum("ofp_error_code", error_code_entries, {'wire_type': 'uint32_t'}))
+
+ # We also need to patch the of_error_msg class to combine the 16-bit error
+ # type and code fields into a single 32-bit error code field
+ error_msg = find(lambda c: c.name == "of_error_msg", of_protocol.classes)
+ if error_msg == None:
+ raise Exception("of_error_msg class not found; OF version: " + str(version))
+ err_type_index = None
+ for i, member in enumerate(error_msg.members):
+ if member.name == "err_type":
+ # Keep track of the error type index so we can remove it once
+ # we've finished iterating
+ err_type_index = i
+ elif member.name == 'code':
+ # Change the code to be a 32-bit ofp_error_code enum value
+ error_msg.members[i] = OFDataMember("code", "ofp_error_code")
+ if err_type_index == None:
+ raise Exception("err_type member of of_error_msg not found; OF version: " + str(version))
+ del error_msg.members[err_type_index]
+
+
+def gen_error_type(enum_entry):
+ return "OFErrorType." + error_type_map[enum_entry.name]
+
class JavaModel(object):
- enum_blacklist = set(("OFDefinitions",))
+ enum_blacklist = set(("OFDefinitions", "OFPortNo"))
enum_entry_blacklist = defaultdict(lambda: set(), OFFlowWildcards=set([ "NW_DST_BITS", "NW_SRC_BITS", "NW_SRC_SHIFT", "NW_DST_SHIFT" ]))
# OFUint structs are there for god-knows what in loci. We certainly don't need them.
interface_blacklist = set( ("OFUint8", "OFUint32",))
@@ -166,6 +257,7 @@
enum_metadata_map = defaultdict(lambda: JavaModel.OFEnumMetadata((), None),
OFPortFeatures = OFEnumMetadata((OFEnumPropertyMetadata("PortSpeed", java_type.port_speed, gen_port_speed),), None),
OFPortState = OFEnumMetadata((OFEnumPropertyMetadata("StpState", java_type.boolean, gen_stp_state),), None),
+ OFErrorCode = OFEnumMetadata((OFEnumPropertyMetadata("ErrorType", java_type.error_type, gen_error_type),), None),
)
@property
diff --git a/java_gen/java_type.py b/java_gen/java_type.py
index 1dfb265..913992b 100644
--- a/java_gen/java_type.py
+++ b/java_gen/java_type.py
@@ -312,6 +312,8 @@
port_speed = JType("PortSpeed")
+error_type = JType("OFErrorType")
+
boolean = JType("boolean")
generic_t = JType("T")
diff --git a/java_gen/templates/const.java b/java_gen/templates/const.java
index 2cd0101..413c946 100644
--- a/java_gen/templates/const.java
+++ b/java_gen/templates/const.java
@@ -36,7 +36,6 @@
//:: include("_imports.java", msg=enum)
public enum ${class_name} {
-
//:: for i, entry in enumerate(enum.entries):
//:: if enum.metadata.properties:
//:: params = "({})".format(", ".join(entry.constructor_params))