Add enums and text for BACnet Errors (#257)

Add new enumerations for BACnet Errors
Add new enumerations from BACnet Errata
Add enumeration text for new enumerations.

Co-authored-by: Steve Karg <skarg@users.sourceforge.net>

src/bacnet/bacenum.h

@@ -540,7 +540,8 @@ typedef enum {
     PROP_ISSUER_CERTIFICATE_FILES = 511,
     /* The special property identifiers all, optional, and required  */
     /* are reserved for use in the ReadPropertyConditional and */
-    /* ReadPropertyMultiple services or services not defined in this standard. */
+    /* ReadPropertyMultiple services or services not defined in this standard.
+     */
     /* Enumerated values 0-511 are reserved for definition by ASHRAE.  */
     /* Enumerated values 512-4194303 may be used by others subject to the  */
     /* procedures and constraints described in Clause 23.  */
@@ -577,22 +578,24 @@ typedef enum {
     PROP_DEFAULT_COLOR = 4194330,
     PROP_DEFAULT_COLOR_TEMPERATURE = 4194331,
     PROP_OVERRIDE_COLOR_REFERENCE = 4194332,
+    PROP_COLOR_COMMAND = 4194334,
+    PROP_HIGH_END_TRIM = 4194335,
+    PROP_LOW_END_TRIM = 4194336,
+    PROP_TRIM_FADE_TIME = 4194337,
+    /* Enumerated values 4194303-16777215 are reserved
+       for definition by ASHRAE.  */
     /* do the max range inside of enum so that
        compilers will allocate adequate sized datatype for enum
        which is used to store decoding */
-    MAX_BACNET_PROPERTY_ID = UINT32_MAX
+    MAX_BACNET_PROPERTY_ID = 16777215
 } BACNET_PROPERTY_ID;
 
-
 typedef enum {
     EVENT_LOW_LIMIT_ENABLE = 1,
     EVENT_HIGH_LIMIT_ENABLE = 2
 } BACNET_LIMIT_ENABLE;
 
-typedef enum {
+typedef enum { ACTION_DIRECT = 0, ACTION_REVERSE = 1 } BACNET_ACTION;
-    ACTION_DIRECT = 0,
-    ACTION_REVERSE = 1
-} BACNET_ACTION;
 
 typedef enum {
     MIN_BINARY_PV = 0, /* for validating incoming values */
@@ -1843,10 +1846,77 @@ typedef enum {
     ERROR_CODE_VALUE_TOO_LONG = 134,
     ERROR_CODE_ABORT_INSUFFICIENT_SECURITY = 135,
     ERROR_CODE_ABORT_SECURITY_ERROR = 136,
-
+    ERROR_CODE_DUPLICATE_ENTRY = 137,
-    MAX_BACNET_ERROR_CODE = 137,
+    ERROR_CODE_INVALID_VALUE_IN_THIS_STATE = 138,
-
+    ERROR_CODE_INVALID_OPERATION_IN_THIS_STATE = 139,
+    ERROR_CODE_LIST_ITEM_NOT_NUMBERED = 140,
+    ERROR_CODE_LIST_ITEM_NOT_TIMESTAMPED = 141,
+    ERROR_CODE_INVALID_DATA_ENCODING = 142,
+    ERROR_CODE_BVLC_FUNCTION_UNKNOWN = 143,
+    ERROR_CODE_BVLC_PROPRIETARY_FUNCTION_UNKNOWN = 144,
+    ERROR_CODE_HEADER_ENCODING_ERROR = 145,
+    ERROR_CODE_HEADER_NOT_UNDERSTOOD = 146,
+    ERROR_CODE_MESSAGE_INCOMPLETE = 147,
+    ERROR_CODE_NOT_A_BACNET_SC_HUB = 148,
+    ERROR_CODE_PAYLOAD_EXPECTED = 149,
+    ERROR_CODE_UNEXPECTED_DATA = 150,
+    ERROR_CODE_NODE_DUPLICATE_VMAC = 151,
+    ERROR_CODE_HTTP_UNEXPECTED_RESPONSE_CODE = 152,
+    ERROR_CODE_HTTP_NO_UPGRADE = 153,
+    ERROR_CODE_HTTP_RESOURCE_NOT_LOCAL = 154,
+    ERROR_CODE_HTTP_PROXY_AUTHENTICATION_FAILED = 155,
+    ERROR_CODE_HTTP_RESPONSE_TIMEOUT = 156,
+    ERROR_CODE_HTTP_RESPONSE_SYNTAX_ERROR = 157,
+    ERROR_CODE_HTTP_RESPONSE_VALUE_ERROR = 158,
+    ERROR_CODE_HTTP_RESPONSE_MISSING_HEADER = 159,
+    ERROR_CODE_HTTP_WEBSOCKET_HEADER_ERROR = 160,
+    ERROR_CODE_HTTP_UPGRADE_REQUIRED = 161,
+    ERROR_CODE_HTTP_UPGRADE_ERROR = 162,
+    ERROR_CODE_HTTP_TEMPORARY_UNAVAILABLE = 163,
+    ERROR_CODE_HTTP_NOT_A_SERVER = 164,
+    ERROR_CODE_HTTP_ERROR = 165,
+    ERROR_CODE_WEBSOCKET_SCHEME_NOT_SUPPORTED = 166,
+    ERROR_CODE_WEBSOCKET_UNKNOWN_CONTROL_MESSAGE = 167,
+    ERROR_CODE_WEBSOCKET_CLOSE_ERROR = 168,
+    ERROR_CODE_WEBSOCKET_CLOSED_BY_PEER = 169,
+    ERROR_CODE_WEBSOCKET_ENDPOINT_LEAVES = 170,
+    ERROR_CODE_WEBSOCKET_PROTOCOL_ERROR = 171,
+    ERROR_CODE_WEBSOCKET_DATA_NOT_ACCEPTED = 172,
+    ERROR_CODE_WEBSOCKET_CLOSED_ABNORMALLY = 173,
+    ERROR_CODE_WEBSOCKET_DATA_INCONSISTENT = 174,
+    ERROR_CODE_WEBSOCKET_DATA_AGAINST_POLICY = 175,
+    ERROR_CODE_WEBSOCKET_FRAME_TOO_LONG = 176,
+    ERROR_CODE_WEBSOCKET_EXTENSION_MISSING = 177,
+    ERROR_CODE_WEBSOCKET_REQUEST_UNAVAILABLE = 178,
+    ERROR_CODE_WEBSOCKET_ERROR = 179,
+    ERROR_CODE_TLS_CLIENT_CERTIFICATE_ERROR = 180,
+    ERROR_CODE_TLS_SERVER_CERTIFICATE_ERROR = 181,
+    ERROR_CODE_TLS_CLIENT_AUTHENTICATION_FAILED = 182,
+    ERROR_CODE_TLS_SERVER_AUTHENTICATION_FAILED = 183,
+    ERROR_CODE_TLS_CLIENT_CERTIFICATE_EXPIRED = 184,
+    ERROR_CODE_TLS_SERVER_CERTIFICATE_EXPIRED = 185,
+    ERROR_CODE_TLS_CLIENT_CERTIFICATE_REVOKED = 186,
+    ERROR_CODE_TLS_SERVER_CERTIFICATE_REVOKED = 187,
+    ERROR_CODE_TLS_ERROR = 188,
+    ERROR_CODE_DNS_UNAVAILABLE = 189,
+    ERROR_CODE_DNS_NAME_RESOLUTION_FAILED = 190,
+    ERROR_CODE_DNS_RESOLVER_FAILURE = 191,
+    ERROR_CODE_DNS_ERROR = 192,
+    ERROR_CODE_TCP_CONNECT_TIMEOUT = 193,
+    ERROR_CODE_TCP_CONNECTION_REFUSED = 194,
+    ERROR_CODE_TCP_CLOSED_BY_LOCAL = 195,
+    ERROR_CODE_TCP_CLOSED_OTHER = 196,
+    ERROR_CODE_TCP_ERROR = 197,
+    ERROR_CODE_IP_ADDRESS_NOT_REACHABLE = 198,
+    ERROR_CODE_IP_ERROR = 199,
+    ERROR_CODE_CERTIFICATE_EXPIRED = 200,
+    ERROR_CODE_CERTIFICATE_INVALID = 201,
+    ERROR_CODE_CERTIFICATE_MALFORMED = 202,
+    ERROR_CODE_CERTIFICATE_REVOKED = 203,
+    ERROR_CODE_UNKNOWN_KEY2 = 204,
+    ERROR_CODE_REFERENCED_PORT_IN_ERROR = 205,
     /* Enumerated values 0-255 are reserved for definition by ASHRAE. */
+    ERROR_CODE_RESERVED_MAX = 255,
     /* Enumerated values 256-65535 may be used by others subject to */
     /* the procedures and constraints described in Clause 23. */
     /* do the max range inside of enum so that

src/bacnet/bactext.c

@@ -160,8 +160,8 @@ bool bactext_application_tag_index(
         bacnet_application_tag_names, search_name, found_index);
 }
 
-INDTEXT_DATA bacnet_object_type_names[] = {
+INDTEXT_DATA bacnet_object_type_names[] = { { OBJECT_ANALOG_INPUT,
-    { OBJECT_ANALOG_INPUT, "analog-input" },
+                                                "analog-input" },
     { OBJECT_ANALOG_OUTPUT, "analog-output" },
     { OBJECT_ANALOG_VALUE, "analog-value" },
     { OBJECT_BINARY_INPUT, "binary-input" },
@@ -214,16 +214,13 @@ INDTEXT_DATA bacnet_object_type_names[] = {
     { OBJECT_NETWORK_PORT, "network-port" },
     { OBJECT_ELEVATOR_GROUP, "elevator-group" },
     { OBJECT_ESCALATOR, "escalator" }, { OBJECT_LIFT, "lift" },
-    { OBJECT_STAGING, "staging" },
+    { OBJECT_STAGING, "staging" }, { OBJECT_AUDIT_LOG, "audit-log" },
-    { OBJECT_AUDIT_LOG, "audit-log" },
+    { OBJECT_AUDIT_REPORTER, "audit-reporter" }, { OBJECT_COLOR, "color" },
-    { OBJECT_AUDIT_REPORTER, "audit-reporter" },
-    { OBJECT_COLOR, "color" },
     { OBJECT_COLOR_TEMPERATURE, "color-temperature" },
     /* Enumerated values 0-127 are reserved for definition by ASHRAE.
        Enumerated values 128-1023 may be used by others subject to
        the procedures and constraints described in Clause 23. */
-    { 0, NULL }
+    { 0, NULL } };
-};
 
 const char *bactext_object_type_name(unsigned index)
 {
@@ -670,8 +667,7 @@ INDTEXT_DATA bacnet_property_names[] = {
         "default-subordinate-relationship" },
     { PROP_REPRESENTS, "represents" },
     { PROP_DEFAULT_PRESENT_VALUE, "default-present-value" },
-    { PROP_PRESENT_STAGE, "present-stage" },
+    { PROP_PRESENT_STAGE, "present-stage" }, { PROP_STAGES, "stages" },
-    { PROP_STAGES, "stages" },
     { PROP_STAGE_NAMES, "stage-names" },
     { PROP_TARGET_REFERENCES, "target-references" },
     { PROP_AUDIT_SOURCE_LEVEL, "audit-source-level" },
@@ -682,11 +678,11 @@ INDTEXT_DATA bacnet_property_names[] = {
     { PROP_DELETE_ON_FORWARD, "delete-on-forward" },
     { PROP_MAXIMUM_SEND_DELAY, "maximum-send-delay" },
     { PROP_MONITORED_OBJECTS, "monitored-objects" },
-    { PROP_SEND_NOW, "send-now" },
+    { PROP_SEND_NOW, "send-now" }, { PROP_FLOOR_NUMBER, "floor-number" },
-    { PROP_FLOOR_NUMBER, "floor-number" },
     { PROP_DEVICE_UUID, "device-uuid" },
     { PROP_ADDITIONAL_REFERENCE_PORTS, "additional-reference-ports" },
-    { PROP_CERTIFICATE_SIGNING_REQUEST_FILE, "certificate-signing-request-file" },
+    { PROP_CERTIFICATE_SIGNING_REQUEST_FILE,
+        "certificate-signing-request-file" },
     { PROP_COMMAND_VALIDATION_RESULT, "command-validation-result" },
     { PROP_ISSUER_CERTIFICATE_FILES, "issuer-certificate-files" },
     { PROP_MAX_BVLC_LENGTH_ACCEPTED, "max-bvlc-length-accepted" },
@@ -697,19 +693,24 @@ INDTEXT_DATA bacnet_property_names[] = {
     { PROP_SC_DIRECT_CONNECT_ACCEPT_ENABLE, "sc-direct-connect-accept-enable" },
     { PROP_SC_DIRECT_CONNECT_ACCEPT_URIS, "sc-direct-connect-accept-uris" },
     { PROP_SC_DIRECT_CONNECT_BINDING, "sc-direct-connect-binding" },
-    { PROP_SC_DIRECT_CONNECT_CONNECTION_STATUS, "sc-direct-connect-connection-status" },
+    { PROP_SC_DIRECT_CONNECT_CONNECTION_STATUS,
-    { PROP_SC_DIRECT_CONNECT_INITIATE_ENABLE, "sc-direct-connect-initiate-enable" },
+        "sc-direct-connect-connection-status" },
+    { PROP_SC_DIRECT_CONNECT_INITIATE_ENABLE,
+        "sc-direct-connect-initiate-enable" },
     { PROP_SC_DISCONNECT_WAIT_TIMEOUT, "sc-disconnect-wait-timeout" },
     { PROP_SC_FAILED_CONNECTION_REQUESTS, "sc-failed-connection-requests" },
-    { PROP_SC_FAILOVER_HUB_CONNECTION_STATUS, "sc-failover-hub-connection-status" },
+    { PROP_SC_FAILOVER_HUB_CONNECTION_STATUS,
+        "sc-failover-hub-connection-status" },
     { PROP_SC_FAILOVER_HUB_URI, "sc-failover-hub-uri" },
     { PROP_SC_HUB_CONNECTOR_STATE, "sc-hub-connector-state" },
     { PROP_SC_HUB_FUNCTION_ACCEPT_URIS, "sc-hub-function-accept-uris" },
     { PROP_SC_HUB_FUNCTION_BINDING, "sc-hub-function-binding" },
-    { PROP_SC_HUB_FUNCTION_CONNECTION_STATUS, "sc-hub-function-connection-status" },
+    { PROP_SC_HUB_FUNCTION_CONNECTION_STATUS,
+        "sc-hub-function-connection-status" },
     { PROP_SC_HUB_FUNCTION_ENABLE, "sc-hub-function-enable" },
     { PROP_SC_HEARTBEAT_TIMEOUT, "sc-heartbeat-timeout" },
-    { PROP_SC_PRIMARY_HUB_CONNECTION_STATUS, "sc-primary-hub-connection-status" },
+    { PROP_SC_PRIMARY_HUB_CONNECTION_STATUS,
+        "sc-primary-hub-connection-status" },
     { PROP_SC_PRIMARY_HUB_URI, "sc-primary-hub-uri" },
     { PROP_SC_MAXIMUM_RECONNECT_TIME, "sc-maximum-reconnect-time" },
     { PROP_SC_MINIMUM_RECONNECT_TIME, "sc-minimum-reconnect-time" },
@@ -717,8 +718,7 @@ INDTEXT_DATA bacnet_property_names[] = {
     { PROP_COLOR_REFERENCE, "color-reference" },
     { PROP_DEFAULT_COLOR, "default-color" },
     { PROP_DEFAULT_COLOR_TEMPERATURE, "default-color-temperature" },
-    { PROP_OVERRIDE_COLOR_REFERENCE, "override-color-reference" },
+    { PROP_OVERRIDE_COLOR_REFERENCE, "override-color-reference" }, { 0, NULL }
-    { 0, NULL }
 };
 
 const char *bactext_property_name(unsigned index)
@@ -1221,7 +1221,93 @@ INDTEXT_DATA bacnet_error_code_names[] = { { ERROR_CODE_OTHER, "other" },
     { ERROR_CODE_OUT_OF_MEMORY, "out-of-memory" },
     { ERROR_CODE_VALUE_TOO_LONG, "value-too-long" },
     { ERROR_CODE_ABORT_INSUFFICIENT_SECURITY, "abort-insufficient-security" },
-    { ERROR_CODE_ABORT_SECURITY_ERROR, "abort-security-error" }, { 0, NULL } };
+    { ERROR_CODE_ABORT_SECURITY_ERROR, "abort-security-error" },
+    { ERROR_CODE_DUPLICATE_ENTRY, "duplicate-entry" },
+    { ERROR_CODE_INVALID_VALUE_IN_THIS_STATE, "invalid-value-in-this-state" },
+    { ERROR_CODE_INVALID_OPERATION_IN_THIS_STATE,
+        "invalid-operation-in-this-state" },
+    { ERROR_CODE_LIST_ITEM_NOT_NUMBERED, "list-item-not-numbered" },
+    { ERROR_CODE_LIST_ITEM_NOT_TIMESTAMPED, "list-item-not-timestamped" },
+    { ERROR_CODE_INVALID_DATA_ENCODING, "invalid-data-encoding" },
+    { ERROR_CODE_BVLC_FUNCTION_UNKNOWN, "bvlc-function-unknown" },
+    { ERROR_CODE_BVLC_PROPRIETARY_FUNCTION_UNKNOWN,
+        "bvlc-proprietary-function-unknown" },
+    { ERROR_CODE_HEADER_ENCODING_ERROR, "header-encoding-error" },
+    { ERROR_CODE_HEADER_NOT_UNDERSTOOD, "header-not-understood" },
+    { ERROR_CODE_MESSAGE_INCOMPLETE, "message-incomplete" },
+    { ERROR_CODE_NOT_A_BACNET_SC_HUB, "not-a-bacnet-sc-hub" },
+    { ERROR_CODE_PAYLOAD_EXPECTED, "payload-expected" },
+    { ERROR_CODE_UNEXPECTED_DATA, "unexpected-data" },
+    { ERROR_CODE_NODE_DUPLICATE_VMAC, "node-duplicate-vmac" },
+    { ERROR_CODE_HTTP_UNEXPECTED_RESPONSE_CODE,
+        "http-unexpected-response-code" },
+    { ERROR_CODE_HTTP_NO_UPGRADE, "http-no-upgrade" },
+    { ERROR_CODE_HTTP_RESOURCE_NOT_LOCAL, "http-resource-not-local" },
+    { ERROR_CODE_HTTP_PROXY_AUTHENTICATION_FAILED,
+        "http-proxy-authentication-failed" },
+    { ERROR_CODE_HTTP_RESPONSE_TIMEOUT, "http-response-timeout" },
+    { ERROR_CODE_HTTP_RESPONSE_SYNTAX_ERROR, "http-response-syntax-error" },
+    { ERROR_CODE_HTTP_RESPONSE_VALUE_ERROR, "http-response-value-error" },
+    { ERROR_CODE_HTTP_RESPONSE_MISSING_HEADER, "http-response-missing-header" },
+    { ERROR_CODE_HTTP_WEBSOCKET_HEADER_ERROR, "http-websocket-header-error" },
+    { ERROR_CODE_HTTP_UPGRADE_REQUIRED, "http-upgrade-required" },
+    { ERROR_CODE_HTTP_UPGRADE_ERROR, "http-upgrade-error" },
+    { ERROR_CODE_HTTP_TEMPORARY_UNAVAILABLE, "http-temporary-unavailable" },
+    { ERROR_CODE_HTTP_NOT_A_SERVER, "http-not-a-server" },
+    { ERROR_CODE_HTTP_ERROR, "http-error" },
+    { ERROR_CODE_WEBSOCKET_SCHEME_NOT_SUPPORTED,
+        "websocket-scheme-not-supported" },
+    { ERROR_CODE_WEBSOCKET_UNKNOWN_CONTROL_MESSAGE,
+        "websocket-unknown-control-message" },
+    { ERROR_CODE_WEBSOCKET_CLOSE_ERROR, "websocket-close-error" },
+    { ERROR_CODE_WEBSOCKET_CLOSED_BY_PEER, "websocket-closed-by-peer" },
+    { ERROR_CODE_WEBSOCKET_ENDPOINT_LEAVES, "websocket-endpoint-leaves" },
+    { ERROR_CODE_WEBSOCKET_PROTOCOL_ERROR, "websocket-protocol-error" },
+    { ERROR_CODE_WEBSOCKET_DATA_NOT_ACCEPTED, "websocket-data-not-accepted" },
+    { ERROR_CODE_WEBSOCKET_CLOSED_ABNORMALLY, "websocket-closed-abnormally" },
+    { ERROR_CODE_WEBSOCKET_DATA_INCONSISTENT, "websocket-data-inconsistent" },
+    { ERROR_CODE_WEBSOCKET_DATA_AGAINST_POLICY,
+        "websocket-data-against-policy" },
+    { ERROR_CODE_WEBSOCKET_FRAME_TOO_LONG, "websocket-frame-too-long" },
+    { ERROR_CODE_WEBSOCKET_EXTENSION_MISSING, "websocket-extension-missing" },
+    { ERROR_CODE_WEBSOCKET_REQUEST_UNAVAILABLE,
+        "websocket-request-unavailable" },
+    { ERROR_CODE_WEBSOCKET_ERROR, "websocket-error" },
+    { ERROR_CODE_TLS_CLIENT_CERTIFICATE_ERROR, "tls-client-certificate-error" },
+    { ERROR_CODE_TLS_SERVER_CERTIFICATE_ERROR, "tls-server-certificate-error" },
+    { ERROR_CODE_TLS_CLIENT_AUTHENTICATION_FAILED,
+        "tls-client-authentication-failed" },
+    { ERROR_CODE_TLS_SERVER_AUTHENTICATION_FAILED,
+        "tls-server-authentication-failed" },
+    { ERROR_CODE_TLS_CLIENT_CERTIFICATE_EXPIRED,
+        "tls-client-certificate-expired" },
+    { ERROR_CODE_TLS_SERVER_CERTIFICATE_EXPIRED,
+        "tls-server-certificate-expired" },
+    { ERROR_CODE_TLS_CLIENT_CERTIFICATE_REVOKED,
+        "tls-client-certificate-revoked" },
+    { ERROR_CODE_TLS_SERVER_CERTIFICATE_REVOKED,
+        "tls-server-certificate-revoked" },
+    { ERROR_CODE_TLS_ERROR, "tls-error" },
+    { ERROR_CODE_DNS_UNAVAILABLE, "dns-unavailable" },
+    { ERROR_CODE_DNS_NAME_RESOLUTION_FAILED, "dns-name-resolution-failed" },
+    { ERROR_CODE_DNS_RESOLVER_FAILURE, "dns-resolver-failure" },
+    { ERROR_CODE_DNS_ERROR, "dns-error" },
+    { ERROR_CODE_TCP_CONNECT_TIMEOUT, "tcp-connect-timeout" },
+    { ERROR_CODE_TCP_CONNECTION_REFUSED, "tcp-connection-refused" },
+    { ERROR_CODE_TCP_CLOSED_BY_LOCAL, "tcp-closed-by-local" },
+    { ERROR_CODE_TCP_CLOSED_OTHER, "tcp-closed-other" },
+    { ERROR_CODE_TCP_ERROR, "tcp-error" },
+    { ERROR_CODE_IP_ADDRESS_NOT_REACHABLE, "ip-address-not-reachable" },
+    { ERROR_CODE_IP_ERROR, "ip-error" },
+    { ERROR_CODE_CERTIFICATE_EXPIRED, "certificate-expired" },
+    { ERROR_CODE_CERTIFICATE_INVALID, "certificate-invalid" },
+    { ERROR_CODE_CERTIFICATE_MALFORMED, "certificate-malformed" },
+    { ERROR_CODE_CERTIFICATE_REVOKED, "certificate-revoked" },
+    { ERROR_CODE_UNKNOWN_KEY2, "unknown-key" },
+    { ERROR_CODE_REFERENCED_PORT_IN_ERROR, "referenced-port-in-error" },
+    /* Enumerated values 256-65535 may be used by others subject to */
+    /* the procedures and constraints described in Clause 23. */
+    { 0, NULL } };
 
 const char *bactext_error_code_name(unsigned index)
 {
@@ -1287,10 +1373,8 @@ bool bactext_days_of_week_index(const char *search_name, unsigned *found_index)
         bacnet_days_of_week_names, search_name, found_index);
 }
 
-INDTEXT_DATA bacnet_notify_type_names[] = {
+INDTEXT_DATA bacnet_notify_type_names[] = { { NOTIFY_ALARM, "alarm" },
-    { NOTIFY_ALARM, "alarm" },
+    { NOTIFY_EVENT, "event" }, { NOTIFY_ACK_NOTIFICATION, "ack-notification" },
-    { NOTIFY_EVENT, "event" },
-    { NOTIFY_ACK_NOTIFICATION, "ack-notification" },
     { 0, NULL } };
 
 const char *bactext_notify_type_name(unsigned index)
@@ -1299,8 +1383,7 @@ const char *bactext_notify_type_name(unsigned index)
         bacnet_notify_type_names, index, ASHRAE_Reserved_String);
 }
 
-bool bactext_notify_type_index(
+bool bactext_notify_type_index(const char *search_name, unsigned *found_index)
-    const char *search_name, unsigned *found_index)
 {
     return indtext_by_istring(
         bacnet_notify_type_names, search_name, found_index);
@@ -1335,8 +1418,7 @@ const char *bactext_event_state_name(unsigned index)
         bacnet_event_state_names, index, ASHRAE_Reserved_String);
 }
 
-bool bactext_event_state_index(
+bool bactext_event_state_index(const char *search_name, unsigned *found_index)
-    const char *search_name, unsigned *found_index)
 {
     return indtext_by_istring(
         bacnet_event_state_names, search_name, found_index);
@@ -1348,16 +1430,15 @@ bool bactext_event_state_strtol(const char *search_name, unsigned *found_index)
         bacnet_event_state_names, search_name, found_index);
 }
 
-INDTEXT_DATA bacnet_event_type_names[] = {
+INDTEXT_DATA bacnet_event_type_names[] = { { EVENT_CHANGE_OF_BITSTRING,
-    { EVENT_CHANGE_OF_BITSTRING, "change-of-bitstring" },
+                                               "change-of-bitstring" },
     { EVENT_CHANGE_OF_STATE, "change-of-state" },
     { EVENT_CHANGE_OF_VALUE, "change-of-value" },
     { EVENT_COMMAND_FAILURE, "command-failure" },
     { EVENT_FLOATING_LIMIT, "floating-limit" },
     { EVENT_OUT_OF_RANGE, "out-of-range" },
     { EVENT_CHANGE_OF_LIFE_SAFETY, "change-of-life-safety" },
-    { EVENT_EXTENDED, "extended" },
+    { EVENT_EXTENDED, "extended" }, { EVENT_BUFFER_READY, "buffer-ready" },
-    { EVENT_BUFFER_READY, "buffer-ready" },
     { EVENT_UNSIGNED_RANGE, "unsigned-range" },
     { EVENT_ACCESS_EVENT, "access-event" },
     { EVENT_DOUBLE_OUT_OF_RANGE, "double-out-of-range" },
@@ -1368,8 +1449,7 @@ INDTEXT_DATA bacnet_event_type_names[] = {
     { EVENT_CHANGE_OF_RELIABILITY, "change-of-reliability" },
     { EVENT_NONE, "none" },
     { EVENT_CHANGE_OF_DISCRETE_VALUE, "change-of-discrete-value" },
-    { EVENT_CHANGE_OF_TIMER, "change-of-timer" },
+    { EVENT_CHANGE_OF_TIMER, "change-of-timer" }, { 0, NULL } };
-    { 0, NULL } };
 
 const char *bactext_event_type_name(unsigned index)
 {
@@ -1378,14 +1458,12 @@ const char *bactext_event_type_name(unsigned index)
         Vendor_Proprietary_String);
 }
 
-bool bactext_event_type_index(
+bool bactext_event_type_index(const char *search_name, unsigned *found_index)
-    const char *search_name, unsigned *found_index)
 {
     return indtext_by_istring(
         bacnet_event_type_names, search_name, found_index);
 }
 
-
 INDTEXT_DATA bacnet_binary_present_value_names[] = {
     { BINARY_INACTIVE, "inactive" }, { BINARY_ACTIVE, "active" }, { 0, NULL }
 };
@@ -1550,8 +1628,7 @@ INDTEXT_DATA lighting_in_progress[] = { { BACNET_LIGHTING_IDLE, "idle" },
     { BACNET_LIGHTING_RAMP_ACTIVE, "ramp" },
     { BACNET_LIGHTING_NOT_CONTROLLED, "not" },
     { BACNET_LIGHTING_OTHER, "other" },
-    { BACNET_LIGHTING_TRIM_ACTIVE, "trim-active" },
+    { BACNET_LIGHTING_TRIM_ACTIVE, "trim-active" }, { 0, NULL } };
-    { 0, NULL } };
 
 const char *bactext_lighting_in_progress(unsigned index)
 {
@@ -1601,16 +1678,14 @@ const char *bactext_lighting_operation_name(unsigned index)
     }
 }
 
-INDTEXT_DATA bacnet_color_operation_names[] = {
+INDTEXT_DATA bacnet_color_operation_names[] = { { BACNET_COLOR_OPERATION_NONE,
-    { BACNET_COLOR_OPERATION_NONE, "none" },
+                                                    "none" },
     { BACNET_COLOR_OPERATION_FADE_TO_COLOR, "fade-to-color" },
     { BACNET_COLOR_OPERATION_FADE_TO_CCT, "fade-to-cct" },
     { BACNET_COLOR_OPERATION_RAMP_TO_CCT, "ramp-to-cct" },
     { BACNET_COLOR_OPERATION_STEP_UP_CCT, "step-up-cct" },
     { BACNET_COLOR_OPERATION_STEP_DOWN_CCT, "step-down-cct" },
-    { BACNET_COLOR_OPERATION_STOP, "stop" },
+    { BACNET_COLOR_OPERATION_STOP, "stop" }, { 0, NULL } };
-    { 0, NULL }
-};
 
 const char *bactext_color_operation_name(unsigned index)
 {