@platformatic/rdkafka 4.0.1 → 4.1.0

package/deps/librdkafka/src/rdkafka_transport.c

@@ -278,10 +278,17 @@ static ssize_t rd_kafka_transport_socket_recvmsg(rd_kafka_transport_t *rktrans,
         if (unlikely(r <= 0)) {
                 if (r == -1 && rd_socket_errno == EAGAIN)
                         return 0;
-                else if (r == 0 || (r == -1 && rd_socket_errno == ECONNRESET)) {
+                else if (r == 0) {
                         /* Receive 0 after POLLIN event means
                          * connection closed. */
-                        rd_snprintf(errstr, errstr_size, "Disconnected");
+                        rd_snprintf(errstr, errstr_size,
+                                    "Disconnected: connection closed by "
+                                    "peer: receive 0 after POLLIN");
+                        return -1;
+                } else if (r == -1 && rd_socket_errno == ECONNRESET) {
+                        rd_snprintf(errstr, errstr_size,
+                                    "Disconnected: connection "
+                                    "reset by peer");
                         return -1;
                 } else if (r == -1) {
                         rd_snprintf(errstr, errstr_size, "%s",
@@ -335,7 +342,9 @@ static ssize_t rd_kafka_transport_socket_recv0(rd_kafka_transport_t *rktrans,
                 } else if (unlikely(r == 0)) {
                         /* Receive 0 after POLLIN event means
                          * connection closed. */
-                        rd_snprintf(errstr, errstr_size, "Disconnected");
+                        rd_snprintf(errstr, errstr_size,
+                                    "Disconnected: connection closed by "
+                                    "peer: receive 0 after POLLIN");
                         return -1;
                 }
 
@@ -543,33 +552,6 @@ void rd_kafka_transport_post_connect_setup(rd_kafka_transport_t *rktrans) {
         rd_kafka_broker_t *rkb = rktrans->rktrans_rkb;
         unsigned int slen;
 
-        /* Set socket send & receive buffer sizes if configuerd */
-        if (rkb->rkb_rk->rk_conf.socket_sndbuf_size != 0) {
-                if (setsockopt(
-                        rktrans->rktrans_s, SOL_SOCKET, SO_SNDBUF,
-                        (void *)&rkb->rkb_rk->rk_conf.socket_sndbuf_size,
-                        sizeof(rkb->rkb_rk->rk_conf.socket_sndbuf_size)) ==
-                    RD_SOCKET_ERROR)
-                        rd_rkb_log(rkb, LOG_WARNING, "SNDBUF",
-                                   "Failed to set socket send "
-                                   "buffer size to %i: %s",
-                                   rkb->rkb_rk->rk_conf.socket_sndbuf_size,
-                                   rd_socket_strerror(rd_socket_errno));
-        }
-
-        if (rkb->rkb_rk->rk_conf.socket_rcvbuf_size != 0) {
-                if (setsockopt(
-                        rktrans->rktrans_s, SOL_SOCKET, SO_RCVBUF,
-                        (void *)&rkb->rkb_rk->rk_conf.socket_rcvbuf_size,
-                        sizeof(rkb->rkb_rk->rk_conf.socket_rcvbuf_size)) ==
-                    RD_SOCKET_ERROR)
-                        rd_rkb_log(rkb, LOG_WARNING, "RCVBUF",
-                                   "Failed to set socket receive "
-                                   "buffer size to %i: %s",
-                                   rkb->rkb_rk->rk_conf.socket_rcvbuf_size,
-                                   rd_socket_strerror(rd_socket_errno));
-        }
-
         /* Get send and receive buffer sizes to allow limiting
          * the total number of bytes passed with iovecs to sendmsg()
          * and recvmsg(). */
@@ -598,19 +580,6 @@ void rd_kafka_transport_post_connect_setup(rd_kafka_transport_t *rktrans) {
         } else if (rktrans->rktrans_sndbuf_size < 1024 * 64)
                 rktrans->rktrans_sndbuf_size =
                     1024 * 64; /* Use at least 64KB */
-
-
-#ifdef TCP_NODELAY
-        if (rkb->rkb_rk->rk_conf.socket_nagle_disable) {
-                int one = 1;
-                if (setsockopt(rktrans->rktrans_s, IPPROTO_TCP, TCP_NODELAY,
-                               (void *)&one, sizeof(one)) == RD_SOCKET_ERROR)
-                        rd_rkb_log(rkb, LOG_WARNING, "NAGLE",
-                                   "Failed to disable Nagle (TCP_NODELAY) "
-                                   "on socket: %s",
-                                   rd_socket_strerror(rd_socket_errno));
-        }
-#endif
 }
 
 
@@ -746,7 +715,9 @@ static void rd_kafka_transport_io_event(rd_kafka_transport_t *rktrans,
                 if (r == 0 /* handshake still in progress */ &&
                     (events & POLLHUP)) {
                         rd_kafka_broker_conn_closed(
-                            rkb, RD_KAFKA_RESP_ERR__TRANSPORT, "Disconnected");
+                            rkb, RD_KAFKA_RESP_ERR__TRANSPORT,
+                            "Disconnected: during "
+                            "SSL connection handshake");
                         return;
                 }
 
@@ -770,7 +741,8 @@ static void rd_kafka_transport_io_event(rd_kafka_transport_t *rktrans,
                 if (events & POLLHUP) {
                         rd_kafka_broker_fail(rkb, LOG_ERR,
                                              RD_KAFKA_RESP_ERR__AUTHENTICATION,
-                                             "Disconnected");
+                                             "Disconnected: hung up from "
+                                             "peer in state AUTH_LEGACY");
 
                         return;
                 }
@@ -781,7 +753,6 @@ static void rd_kafka_transport_io_event(rd_kafka_transport_t *rktrans,
         case RD_KAFKA_BROKER_STATE_AUTH_HANDSHAKE:
         case RD_KAFKA_BROKER_STATE_AUTH_REQ:
         case RD_KAFKA_BROKER_STATE_UP:
-        case RD_KAFKA_BROKER_STATE_UPDATE:
 
                 if (events & POLLIN) {
                         while (rkb->rkb_state >= RD_KAFKA_BROKER_STATE_UP &&
@@ -795,7 +766,9 @@ static void rd_kafka_transport_io_event(rd_kafka_transport_t *rktrans,
 
                 if (events & POLLHUP) {
                         rd_kafka_broker_conn_closed(
-                            rkb, RD_KAFKA_RESP_ERR__TRANSPORT, "Disconnected");
+                            rkb, RD_KAFKA_RESP_ERR__TRANSPORT,
+                            "Disconnected: connection closed by "
+                            "peer: POLLHUP");
                         return;
                 }
 
@@ -1081,6 +1054,45 @@ rd_kafka_transport_t *rd_kafka_transport_new(rd_kafka_broker_t *rkb,
         }
 #endif
 
+#ifdef TCP_NODELAY
+        if (rkb->rkb_rk->rk_conf.socket_nagle_disable) {
+                int one = 1;
+                if (setsockopt(s, IPPROTO_TCP, TCP_NODELAY, (void *)&one,
+                               sizeof(one)) == RD_SOCKET_ERROR)
+                        rd_rkb_log(rkb, LOG_WARNING, "NAGLE",
+                                   "Failed to disable Nagle (TCP_NODELAY) "
+                                   "on socket: %s",
+                                   rd_socket_strerror(rd_socket_errno));
+        }
+#endif
+
+        /* Set socket send & receive buffer sizes if configuerd */
+        if (rkb->rkb_rk->rk_conf.socket_sndbuf_size != 0) {
+                if (setsockopt(
+                        s, SOL_SOCKET, SO_SNDBUF,
+                        (void *)&rkb->rkb_rk->rk_conf.socket_sndbuf_size,
+                        sizeof(rkb->rkb_rk->rk_conf.socket_sndbuf_size)) ==
+                    RD_SOCKET_ERROR)
+                        rd_rkb_log(rkb, LOG_WARNING, "SNDBUF",
+                                   "Failed to set socket send "
+                                   "buffer size to %i: %s",
+                                   rkb->rkb_rk->rk_conf.socket_sndbuf_size,
+                                   rd_socket_strerror(rd_socket_errno));
+        }
+
+        if (rkb->rkb_rk->rk_conf.socket_rcvbuf_size != 0) {
+                if (setsockopt(
+                        s, SOL_SOCKET, SO_RCVBUF,
+                        (void *)&rkb->rkb_rk->rk_conf.socket_rcvbuf_size,
+                        sizeof(rkb->rkb_rk->rk_conf.socket_rcvbuf_size)) ==
+                    RD_SOCKET_ERROR)
+                        rd_rkb_log(rkb, LOG_WARNING, "RCVBUF",
+                                   "Failed to set socket receive "
+                                   "buffer size to %i: %s",
+                                   rkb->rkb_rk->rk_conf.socket_rcvbuf_size,
+                                   rd_socket_strerror(rd_socket_errno));
+        }
+
         /* Set the socket to non-blocking */
         if ((r = rd_fd_set_nonblocking(s))) {
                 rd_snprintf(errstr, errstr_size,

package/deps/librdkafka/src/rdkafka_transport.h

@@ -88,6 +88,11 @@ void rd_kafka_transport_set_blocked(rd_kafka_transport_t *rktrans,
         } while (0)
 #endif
 
+static RD_INLINE RD_UNUSED rd_bool_t
+rd_kafka_transport_error_disconnected(const char *errstr) {
+        return strncmp(errstr, "Disconnected", 12) == 0;
+}
+
 
 void rd_kafka_transport_init(void);
 

package/deps/librdkafka/src/rdkafka_txnmgr.c

@@ -2029,7 +2029,7 @@ rd_kafka_error_t *rd_kafka_send_offsets_to_transaction(
         rd_kafka_topic_partition_list_sort_by_topic(valid_offsets);
 
         rko                    = rd_kafka_op_new_cb(rk, RD_KAFKA_OP_TXN,
-                                 rd_kafka_txn_op_send_offsets_to_transaction);
+                                                    rd_kafka_txn_op_send_offsets_to_transaction);
         rko->rko_u.txn.offsets = valid_offsets;
         rko->rko_u.txn.cgmetadata =
             rd_kafka_consumer_group_metadata_dup(cgmetadata);
@@ -2958,6 +2958,11 @@ static void rd_kafka_txn_handle_FindCoordinator(rd_kafka_t *rk,
                             NodeId);
                 err = RD_KAFKA_RESP_ERR__UNKNOWN_BROKER;
         }
+        if (rkb && rkb->rkb_source != RD_KAFKA_LEARNED) {
+                rd_kafka_broker_destroy(rkb);
+                rkb = NULL;
+                err = RD_KAFKA_RESP_ERR__UNKNOWN_BROKER;
+        }
         rd_kafka_rdunlock(rk);
 
         if (err)

package/deps/librdkafka/src/rdmap.c

@@ -404,12 +404,17 @@ static int unittest_typed_map2(void) {
 static int unittest_untyped_map(void) {
         rd_map_t rmap;
         int pass, i, r;
-        int cnt     = 100000;
+        int cnt     = rd_unittest_with_valgrind ? 1000 : 100000;
         int exp_cnt = 0, get_cnt = 0, iter_cnt = 0;
         const rd_map_elem_t *elem;
         rd_ts_t ts     = rd_clock();
         rd_ts_t ts_get = 0;
 
+        if (rd_unittest_with_valgrind)
+                RD_UT_WARN(
+                    "Reducing count in "
+                    "untyped map test when using Valgrind");
+
         rd_map_init(&rmap, cnt, rd_map_str_cmp, rd_map_str_hash, rd_free,
                     rd_free);
 

package/deps/librdkafka/src/rdrand.c

@@ -30,6 +30,7 @@
 #include "rdrand.h"
 #include "rdtime.h"
 #include "tinycthread.h"
+#include "rdmurmur2.h"
 
 int rd_jitter(int low, int high) {
         int rand_num;
@@ -40,8 +41,17 @@ int rd_jitter(int low, int high) {
         if (unlikely(seed == 0)) {
                 struct timeval tv;
                 rd_gettimeofday(&tv, NULL);
-                seed = (unsigned int)(tv.tv_usec / 1000);
+                seed = (unsigned int)(tv.tv_usec);
                 seed ^= (unsigned int)(intptr_t)thrd_current();
+
+                /* When many threads are created at the same time and the
+                 * thread id is different only by a few bits it's possible that
+                 * `rand_r`, that is initially multiplying by `1103515245`,
+                 * truncates the variable bits and uses the same seed for
+                 * different threads. By applying `murmur2` we ensure that seed
+                 * variability is distributed across various bits at different
+                 * positions. */
+                seed = (unsigned int)rd_murmur2(&seed, sizeof(seed));
         }
 
         rand_num = rand_r(&seed);

package/deps/librdkafka/src/rdtime.h

@@ -2,6 +2,7 @@
  * librd - Rapid Development C library
  *
  * Copyright (c) 2012-2022, Magnus Edenhill
+ *               2025, Confluent Inc.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -168,12 +169,11 @@ static RD_INLINE int rd_timeout_ms(rd_ts_t timeout_us) {
  * @brief Initialize an absolute timeout based on the provided \p timeout_ms
  *        and given clock \p now
  *
- * To be used with rd_timeout_adjust().
+ * To be used with rd_timeout_remains() or rd_timeout_remains_us().
  *
  * Honours RD_POLL_INFINITE, RD_POLL_NOWAIT.
  *
- * @returns the absolute timeout which should later be passed
- *          to rd_timeout_adjust().
+ * @returns the absolute timeout.
  */
 static RD_INLINE rd_ts_t rd_timeout_init0(rd_ts_t now, int timeout_ms) {
         if (timeout_ms == RD_POLL_INFINITE || timeout_ms == RD_POLL_NOWAIT)
@@ -182,6 +182,23 @@ static RD_INLINE rd_ts_t rd_timeout_init0(rd_ts_t now, int timeout_ms) {
         return now + ((rd_ts_t)timeout_ms * 1000);
 }
 
+/**
+ * @brief Initialize an absolute timeout based on the provided \p timeout_us
+ *        and given clock \p now
+ *
+ * To be used with rd_timeout_remains() or rd_timeout_remains_us().
+ *
+ * Honours RD_POLL_INFINITE, RD_POLL_NOWAIT.
+ *
+ * @returns the absolute timeout.
+ */
+static RD_INLINE rd_ts_t rd_timeout_init_us0(rd_ts_t now, rd_ts_t timeout_us) {
+        if (timeout_us == RD_POLL_INFINITE || timeout_us == RD_POLL_NOWAIT)
+                return timeout_us;
+
+        return now + timeout_us;
+}
+
 
 /**
  * @brief Initialize an absolute timeout based on the provided \p timeout_ms
@@ -198,6 +215,32 @@ static RD_INLINE rd_ts_t rd_timeout_init(int timeout_ms) {
         return rd_timeout_init0(rd_clock(), timeout_ms);
 }
 
+/**
+ * @brief Initialize an absolute timeout based on the provided \p timeout_us
+ *        and current clock.
+ *
+ * To be used with rd_timeout_remains() or rd_timeout_remains_us().
+ *
+ * Honours RD_POLL_INFINITE, RD_POLL_NOWAIT.
+ *
+ * @returns the absolute timeout.
+ */
+static RD_INLINE rd_ts_t rd_timeout_init_us(rd_ts_t timeout_us) {
+        return rd_timeout_init_us0(rd_clock(), timeout_us);
+}
+
+/**
+ * @brief Gets time since epoch (UTC).
+ */
+static RD_INLINE void rd_timespec_get(struct timespec *tspec) {
+#if defined(__APPLE__) || (defined(__ANDROID__) && __ANDROID_API__ < 29)
+        struct timeval tv;
+        gettimeofday(&tv, NULL);
+        TIMEVAL_TO_TIMESPEC(&tv, tspec);
+#else
+        timespec_get(tspec, TIME_UTC);
+#endif
+}
 
 /**
  * @brief Initialize an absolute timespec timeout based on the provided
@@ -213,13 +256,7 @@ static RD_INLINE void rd_timeout_init_timespec_us(struct timespec *tspec,
                 tspec->tv_sec  = timeout_us;
                 tspec->tv_nsec = 0;
         } else {
-#if defined(__APPLE__) || (defined(__ANDROID__) && __ANDROID_API__ < 29)
-                struct timeval tv;
-                gettimeofday(&tv, NULL);
-                TIMEVAL_TO_TIMESPEC(&tv, tspec);
-#else
-                timespec_get(tspec, TIME_UTC);
-#endif
+                rd_timespec_get(tspec);
                 tspec->tv_sec += timeout_us / 1000000;
                 tspec->tv_nsec += (timeout_us % 1000000) * 1000;
                 if (tspec->tv_nsec >= 1000000000) {
@@ -243,13 +280,7 @@ static RD_INLINE void rd_timeout_init_timespec(struct timespec *tspec,
                 tspec->tv_sec  = timeout_ms;
                 tspec->tv_nsec = 0;
         } else {
-#if defined(__APPLE__) || (defined(__ANDROID__) && __ANDROID_API__ < 29)
-                struct timeval tv;
-                gettimeofday(&tv, NULL);
-                TIMEVAL_TO_TIMESPEC(&tv, tspec);
-#else
-                timespec_get(tspec, TIME_UTC);
-#endif
+                rd_timespec_get(tspec);
                 tspec->tv_sec += timeout_ms / 1000;
                 tspec->tv_nsec += (timeout_ms % 1000) * 1000000;
                 if (tspec->tv_nsec >= 1000000000) {

package/deps/librdkafka/src/rdunittest.c

@@ -55,6 +55,7 @@
 #include "rdkafka_txnmgr.h"
 
 rd_bool_t rd_unittest_assert_on_failure = rd_false;
+rd_bool_t rd_unittest_with_valgrind     = rd_false;
 rd_bool_t rd_unittest_on_ci             = rd_false;
 rd_bool_t rd_unittest_slow              = rd_false;
 
@@ -416,6 +417,7 @@ static int unittest_rdclock(void) {
 
 extern int unittest_string(void);
 extern int unittest_cgrp(void);
+extern int unittest_mock_cluster(void);
 #if WITH_SASL_SCRAM
 extern int unittest_scram(void);
 #endif
@@ -426,7 +428,10 @@ extern int unittest_http(void);
 #endif
 #if WITH_OAUTHBEARER_OIDC
 extern int unittest_sasl_oauthbearer_oidc(void);
+extern int unittest_sasl_oauthbearer_oidc_jwt_bearer(void);
+extern int unittest_sasl_oauthbearer_oidc_assertion(void);
 #endif
+extern int unittest_telemetry(void);
 extern int unittest_telemetry_decode(void);
 
 int rd_unittest(void) {
@@ -435,42 +440,48 @@ int rd_unittest(void) {
                 const char *name;
                 int (*call)(void);
         } unittests[] = {
-                {"sysqueue", unittest_sysqueue},
-                {"string", unittest_string},
-                {"map", unittest_map},
-                {"rdbuf", unittest_rdbuf},
-                {"rdvarint", unittest_rdvarint},
-                {"crc32c", unittest_rd_crc32c},
-                {"msg", unittest_msg},
-                {"murmurhash", unittest_murmur2},
-                {"fnv1a", unittest_fnv1a},
+            {"sysqueue", unittest_sysqueue},
+            {"string", unittest_string},
+            {"map", unittest_map},
+            {"rdbuf", unittest_rdbuf},
+            {"rdvarint", unittest_rdvarint},
+            {"crc32c", unittest_rd_crc32c},
+            {"msg", unittest_msg},
+            {"murmurhash", unittest_murmur2},
+            {"fnv1a", unittest_fnv1a},
+            {"mock", unittest_mock_cluster},
 #if WITH_HDRHISTOGRAM
-                {"rdhdrhistogram", unittest_rdhdrhistogram},
+            {"rdhdrhistogram", unittest_rdhdrhistogram},
 #endif
 #ifdef _WIN32
-                {"rdclock", unittest_rdclock},
+            {"rdclock", unittest_rdclock},
 #endif
-                {"conf", unittest_conf},
-                {"broker", unittest_broker},
-                {"request", unittest_request},
+            {"conf", unittest_conf},
+            {"broker", unittest_broker},
+            {"request", unittest_request},
 #if WITH_SASL_OAUTHBEARER
-                {"sasl_oauthbearer", unittest_sasl_oauthbearer},
+            {"sasl_oauthbearer", unittest_sasl_oauthbearer},
 #endif
-                {"aborted_txns", unittest_aborted_txns},
-                {"cgrp", unittest_cgrp},
+            {"aborted_txns", unittest_aborted_txns},
+            {"cgrp", unittest_cgrp},
 #if WITH_SASL_SCRAM
-                {"scram", unittest_scram},
+            {"scram", unittest_scram},
 #endif
-                {"assignors", unittest_assignors},
+            {"assignors", unittest_assignors},
 #if WITH_CURL
-                {"http", unittest_http},
+            {"http", unittest_http},
 #endif
 #if WITH_OAUTHBEARER_OIDC
-                {"sasl_oauthbearer_oidc", unittest_sasl_oauthbearer_oidc},
+            {"sasl_oauthbearer_oidc", unittest_sasl_oauthbearer_oidc},
+            {"sasl_oauthbearer_oidc_jwt_bearer",
+             unittest_sasl_oauthbearer_oidc_jwt_bearer},
+            {"sasl_oauthbearer_oidc_assertion",
+             unittest_sasl_oauthbearer_oidc_assertion},
 #endif
-                {"telemetry", unittest_telemetry_decode},
-                {NULL}
-        };
+            {"telemetry", unittest_telemetry},
+            {"telemetry_decode", unittest_telemetry_decode},
+            {"feature", unittest_feature},
+            {NULL}};
         int i;
         const char *match = rd_getenv("RD_UT_TEST", NULL);
         int cnt           = 0;
@@ -482,7 +493,13 @@ int rd_unittest(void) {
                 rd_unittest_on_ci = rd_true;
         }
 
-        if (rd_unittest_on_ci || (ENABLE_DEVEL + 0)) {
+        if (rd_strcmp(rd_getenv("TEST_MODE", NULL), "valgrind") == 0) {
+                RD_UT_SAY("Unittests running with valgrind");
+                rd_unittest_with_valgrind = rd_true;
+        }
+
+        if (rd_unittest_on_ci || rd_unittest_with_valgrind ||
+            (ENABLE_DEVEL + 0)) {
                 RD_UT_SAY("Unittests will not error out on slow CPUs");
                 rd_unittest_slow = rd_true;
         }

package/deps/librdkafka/src/rdunittest.h

@@ -2,6 +2,7 @@
  * librdkafka - Apache Kafka C library
  *
  * Copyright (c) 2017-2022, Magnus Edenhill
+ *               2025, Confluent Inc.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -34,6 +35,7 @@
 
 extern rd_bool_t rd_unittest_assert_on_failure;
 extern rd_bool_t rd_unittest_on_ci;
+extern rd_bool_t rd_unittest_with_valgrind;
 extern rd_bool_t rd_unittest_slow;
 
 #define ENABLE_CODECOV ENABLE_DEVEL

package/deps/librdkafka/src/rdwin32.h

@@ -42,7 +42,7 @@
 #include <winsock2.h> /* for sockets + struct timeval */
 #include <io.h>
 #include <fcntl.h>
-
+#include <windows.h>
 
 /**
  * Types

package/deps/librdkafka/src/regexp.c

@@ -95,16 +95,17 @@ static Rune canon(Rune c) {
 
 /* Scan */
 
-enum { L_CHAR = 256,
-       L_CCLASS,  /* character class */
-       L_NCCLASS, /* negative character class */
-       L_NC,      /* "(?:" no capture */
-       L_PLA,     /* "(?=" positive lookahead */
-       L_NLA,     /* "(?!" negative lookahead */
-       L_WORD,    /* "\b" word boundary */
-       L_NWORD,   /* "\B" non-word boundary */
-       L_REF,     /* "\1" back-reference */
-       L_COUNT    /* {M,N} */
+enum {
+        L_CHAR = 256,
+        L_CCLASS,  /* character class */
+        L_NCCLASS, /* negative character class */
+        L_NC,      /* "(?:" no capture */
+        L_PLA,     /* "(?=" positive lookahead */
+        L_NLA,     /* "(?!" negative lookahead */
+        L_WORD,    /* "\b" word boundary */
+        L_NWORD,   /* "\B" non-word boundary */
+        L_REF,     /* "\1" back-reference */
+        L_COUNT    /* {M,N} */
 };
 
 static int hex(Restate *g, int c) {
@@ -451,21 +452,23 @@ static int lex(Restate *g) {
 
 /* Parse */
 
-enum { P_CAT,
-       P_ALT,
-       P_REP,
-       P_BOL,
-       P_EOL,
-       P_WORD,
-       P_NWORD,
-       P_PAR,
-       P_PLA,
-       P_NLA,
-       P_ANY,
-       P_CHAR,
-       P_CCLASS,
-       P_NCCLASS,
-       P_REF };
+enum {
+        P_CAT,
+        P_ALT,
+        P_REP,
+        P_BOL,
+        P_EOL,
+        P_WORD,
+        P_NWORD,
+        P_PAR,
+        P_PLA,
+        P_NLA,
+        P_ANY,
+        P_CHAR,
+        P_CCLASS,
+        P_NCCLASS,
+        P_REF
+};
 
 struct Renode {
         unsigned char type;
@@ -662,23 +665,25 @@ static Renode *parsealt(Restate *g) {
 
 /* Compile */
 
-enum { I_END,
-       I_JUMP,
-       I_SPLIT,
-       I_PLA,
-       I_NLA,
-       I_ANYNL,
-       I_ANY,
-       I_CHAR,
-       I_CCLASS,
-       I_NCCLASS,
-       I_REF,
-       I_BOL,
-       I_EOL,
-       I_WORD,
-       I_NWORD,
-       I_LPAR,
-       I_RPAR };
+enum {
+        I_END,
+        I_JUMP,
+        I_SPLIT,
+        I_PLA,
+        I_NLA,
+        I_ANYNL,
+        I_ANY,
+        I_CHAR,
+        I_CCLASS,
+        I_NCCLASS,
+        I_REF,
+        I_BOL,
+        I_EOL,
+        I_WORD,
+        I_NWORD,
+        I_LPAR,
+        I_RPAR
+};
 
 struct Reinst {
         unsigned char opcode;