cleanup: Add nullability to more function params and return types.

Author: iphydf

auto_tests/scenarios/scenario_group_by_id_test.c

@@ -53,11 +53,6 @@ static void script(ToxNode *self, void *ctx)
         group_number = tox_group_by_id(tox, invalid_chat_id, &err_by_id);
         ck_assert_int_eq(err_by_id, TOX_ERR_GROUP_BY_ID_NOT_FOUND);
         ck_assert_uint_eq(group_number, UINT32_MAX);
-
-        // Test tox_group_by_id with NULL ID
-        group_number = tox_group_by_id(tox, NULL, &err_by_id);
-        ck_assert_int_eq(err_by_id, TOX_ERR_GROUP_BY_ID_NULL);
-        ck_assert_uint_eq(group_number, UINT32_MAX);
     }
 
     // Create another group to ensure it works with multiple groups

other/event_tooling/generate_event_c.cpp

@@ -168,7 +168,7 @@ std::string zero_initializer_for_type(const std::string& type) {
     }
 }
 
-void generate_event_impl(const std::string& event_name, const std::vector<EventType>& event_types) {
+void generate_event_impl(const std::string& event_name, const std::vector<EventType>& event_types, bool is_public = true) {
     const std::string event_name_l = str_tolower(event_name);
     const std::string event_name_u = str_toupper(event_name);
     std::string file_name = output_folder + "/" + event_name_l + ".c";
@@ -543,7 +543,7 @@ void generate_event_impl(const std::string& event_name, const std::vector<EventT
     f << "    mem_delete(mem, " << event_name_l << ");\n}\n\n";
 
     // add
-    f << "static Tox_Event_" << event_name << " *tox_events_add_" << event_name_l << "(Tox_Events *_Nonnull events, const Memory *_Nonnull mem)\n{\n";
+    f << "static Tox_Event_" << event_name << " *_Nullable tox_events_add_" << event_name_l << "(Tox_Events *_Nonnull events, const Memory *_Nonnull mem)\n{\n";
     f << "    Tox_Event_" << event_name << " *const " << event_name_l << " = tox_event_" << event_name_l << "_new(mem);\n\n";
     f << "    if (" << event_name_l << " == nullptr) {\n";
     f << "        return nullptr;\n    }\n\n";
@@ -552,8 +552,7 @@ void generate_event_impl(const std::string& event_name, const std::vector<EventT
     f << "    event.data." << event_name_l << " = " << event_name_l << ";\n\n";
     f << "    if (!tox_events_add(events, &event)) {\n";
     f << "        tox_event_" << event_name_l << "_free(" << event_name_l << ", mem);\n";
-    f << "        return nullptr;\n";
-    f << "    }\n";
+    f << "        return nullptr;\n    }\n";
     f << "    return " << event_name_l << ";\n}\n\n";
 
     // unpack
@@ -566,7 +565,7 @@ void generate_event_impl(const std::string& event_name, const std::vector<EventT
     f << "    return tox_event_" << event_name_l << "_unpack_into(*event, bu);\n}\n\n";
 
     // alloc
-    f << "static Tox_Event_" << event_name << " *tox_event_" << event_name_l << "_alloc(Tox_Events_State *_Nonnull state)\n{\n";
+    f << "static Tox_Event_" << event_name << " *_Nullable tox_event_" << event_name_l << "_alloc(Tox_Events_State *_Nonnull state)\n{\n";
     f << "    if (state->events == nullptr) {\n        return nullptr;\n    }\n\n";
     f << "    Tox_Event_" << event_name << " *" << event_name_l << " = tox_events_add_" << event_name_l << "(state->events, state->mem);\n\n";
     f << "    if (" << event_name_l << " == nullptr) {\n";
@@ -583,7 +582,7 @@ void generate_event_impl(const std::string& event_name, const std::vector<EventT
 
 )";
     f << "void tox_events_handle_" << event_name_l << "(\n";
-    f << "    Tox *tox";
+    f << "    Tox " << (is_public ? "*_Nonnull " : "*") << "tox";
 
     for (const auto& t : event_types) {
         f << ",\n    ";
@@ -593,17 +592,17 @@ void generate_event_impl(const std::string& event_name, const std::vector<EventT
                     f << (t.cb_type.empty() ? t.type : t.cb_type) << " " << t.name;
                 },
                 [&](const EventTypeByteRange& t) {
-                    f << "const " << t.type_c_arg << " *" << t.name_data << ", " << t.type_length_cb << " " << t.name_length_cb;
+                    f << "const " << t.type_c_arg << " " << (is_public ? "*_Nullable " : "*") << t.name_data << ", " << t.type_length_cb << " " << t.name_length_cb;
                 },
                 [&](const EventTypeByteArray& t) {
-                    f << "const uint8_t *" << t.name;
+                    f << "const uint8_t " << (is_public ? "*_Nonnull " : "*") << t.name;
                 }
             },
             t
         );
     }
 
-    f << ",\n    void *user_data)\n{\n";
+    f << ",\n    void " << (is_public ? "*_Nullable " : "*") << "user_data)\n{\n";
     f << "    Tox_Events_State *state = tox_events_alloc(user_data);\n";
     f << "    Tox_Event_" << event_name << " *" << event_name_l << " = tox_event_" << event_name_l << "_alloc(state);\n\n";
     f << "    if (" << event_name_l << " == nullptr) {\n        return;\n    }\n\n";
@@ -988,11 +987,11 @@ int main(int argc, char** argv) {
 
     if (argc < 2) {
         for (const auto& [event, event_types] : event_defs) {
-            generate_event_impl(event, event_types);
+            generate_event_impl(event, event_types, event != "Dht_Nodes_Response");
         }
     } else {
         if (event_defs.count(argv[1])) {
-            generate_event_impl(argv[1], event_defs[argv[1]]);
+            generate_event_impl(argv[1], event_defs[argv[1]], std::string(argv[1]) != "Dht_Nodes_Response");
         } else {
             std::cerr << "error: unknown event " << argv[1] << "\n";
             return 1;

toxav/BUILD.bazel

@@ -11,6 +11,7 @@ exports_files(
 cc_library(
     name = "public_api",
     hdrs = ["toxav.h"],
+    deps = ["//c-toxcore/toxcore:attributes"],
 )
 
 cc_library(
@@ -129,6 +130,7 @@ cc_library(
     deps = [
         ":ring_buffer",
         ":rtp",
+        "//c-toxcore/toxcore:attributes",
         "//c-toxcore/toxcore:ccompat",
         "//c-toxcore/toxcore:logger",
         "//c-toxcore/toxcore:mono_time",
@@ -179,6 +181,7 @@ cc_library(
     deps = [
         ":ring_buffer",
         ":rtp",
+        "//c-toxcore/toxcore:attributes",
         "//c-toxcore/toxcore:ccompat",
         "//c-toxcore/toxcore:logger",
         "//c-toxcore/toxcore:mono_time",
@@ -295,6 +298,7 @@ cc_library(
         ":rtp",
         ":video",
         "//c-toxcore/toxcore:Messenger",
+        "//c-toxcore/toxcore:attributes",
         "//c-toxcore/toxcore:ccompat",
         "//c-toxcore/toxcore:group",
         "//c-toxcore/toxcore:logger",

toxav/audio.c

@@ -12,6 +12,7 @@
 
 #include "rtp.h"
 
+#include "../toxcore/attributes.h"
 #include "../toxcore/ccompat.h"
 #include "../toxcore/logger.h"
 #include "../toxcore/mono_time.h"
@@ -20,33 +21,33 @@
 
 
 struct ACSession {
-    Mono_Time *mono_time;
-    const Logger *log;
+    Mono_Time *_Nonnull mono_time;
+    const Logger *_Nonnull log;
 
     /* encoding */
-    OpusEncoder *encoder;
+    OpusEncoder *_Nullable encoder;
     uint32_t le_sample_rate; /* Last encoder sample rate */
     uint8_t le_channel_count; /* Last encoder channel count */
     uint32_t le_bit_rate; /* Last encoder bit rate */
 
     /* decoding */
-    OpusDecoder *decoder;
+    OpusDecoder *_Nullable decoder;
     uint8_t lp_channel_count; /* Last packet channel count */
     uint32_t lp_sampling_rate; /* Last packet sample rate */
     uint32_t lp_frame_duration; /* Last packet frame duration */
     uint32_t ld_sample_rate; /* Last decoder sample rate */
     uint8_t ld_channel_count; /* Last decoder channel count */
     uint64_t ldrts; /* Last decoder reconfiguration time stamp */
-    void *j_buf;
+    void *_Nullable j_buf;
 
     pthread_mutex_t queue_mutex[1];
 
-    int16_t *decode_buffer;
+    int16_t *_Nullable decode_buffer;
 
     uint32_t friend_number;
     /* Audio frame receive callback */
-    ac_audio_receive_frame_cb *acb;
-    void *user_data;
+    ac_audio_receive_frame_cb *_Nullable acb;
+    void *_Nullable user_data;
 };
 
 
@@ -327,7 +328,7 @@ int ac_encode(ACSession *ac, const int16_t *pcm, size_t sample_count, uint8_t *d
 }
 
 struct JitterBuffer {
-    struct RTPMessage **queue;
+    struct RTPMessage *_Nullable *_Nonnull queue;
     uint32_t size;
     uint32_t capacity;
     uint16_t bottom;

toxav/bwcontroller.c

@@ -33,23 +33,23 @@ typedef struct BWCCycle {
 
 typedef struct BWCRcvPkt {
     uint32_t packet_length_array[BWC_AVG_PKT_COUNT];
-    RingBuffer *rb;
+    RingBuffer *_Nonnull rb;
 } BWCRcvPkt;
 
 struct BWController {
-    bwc_loss_report_cb *mcb;
-    void *mcb_user_data;
-    bwc_send_packet_cb *send_packet;
-    void *send_packet_user_data;
-    const Logger *log;
+    bwc_loss_report_cb *_Nullable mcb;
+    void *_Nullable mcb_user_data;
+    bwc_send_packet_cb *_Nullable send_packet;
+    void *_Nullable send_packet_user_data;
+    const Logger *_Nonnull log;
     uint32_t friend_number;
 
     BWCCycle cycle;
 
     BWCRcvPkt rcvpkt; /* To calculate average received packet (this means split parts, not the full message!) */
 
     uint32_t packet_loss_counted_cycles;
-    Mono_Time *bwc_mono_time;
+    Mono_Time *_Nonnull bwc_mono_time;
     bool bwc_receive_active; /* if this is set to false then incoming bwc packets will not be processed by bwc_handle_data() */
 };
 

toxav/groupav.c

@@ -19,11 +19,11 @@
 typedef struct Group_Audio_Packet {
     uint16_t sequnum;
     uint16_t length;
-    uint8_t *data;
+    uint8_t *_Nonnull data;
 } Group_Audio_Packet;
 
 typedef struct Group_JitterBuffer {
-    Group_Audio_Packet **queue;
+    Group_Audio_Packet *_Nullable *_Nonnull queue;
     uint32_t size;
     uint32_t capacity;
     uint16_t bottom;
@@ -161,26 +161,26 @@ static Group_Audio_Packet *_Nullable dequeue(Group_JitterBuffer *_Nonnull q, int
 }
 
 typedef struct Group_AV {
-    const Logger *log;
-    Tox *tox;
-    Group_Chats *g_c;
-    OpusEncoder *audio_encoder;
+    const Logger *_Nonnull log;
+    Tox *_Nonnull tox;
+    Group_Chats *_Nonnull g_c;
+    OpusEncoder *_Nullable audio_encoder;
 
     unsigned int audio_channels;
     unsigned int audio_sample_rate;
     unsigned int audio_bitrate;
 
     uint16_t audio_sequnum;
 
-    audio_data_cb *audio_data;
-    void *userdata;
+    audio_data_cb *_Nullable audio_data;
+    void *_Nullable userdata;
 } Group_AV;
 
 typedef struct Group_Peer_AV {
-    const Mono_Time *mono_time;
-    Group_JitterBuffer *buffer;
+    const Mono_Time *_Nonnull mono_time;
+    Group_JitterBuffer *_Nonnull buffer;
 
-    OpusDecoder *audio_decoder;
+    OpusDecoder *_Nullable audio_decoder;
     int decoder_channels;
     unsigned int last_packet_samples;
 } Group_Peer_AV;

toxav/ring_buffer.c

@@ -13,7 +13,7 @@ struct RingBuffer {
     uint16_t size; /* Max size */
     uint16_t start;
     uint16_t end;
-    void   **data;
+    void *_Nullable *_Nonnull data;
 };
 
 bool rb_full(const RingBuffer *b)

toxav/rtp.c

@@ -104,7 +104,7 @@ struct RTPWorkBuffer {
     /**
      * The message currently being assembled.
      */
-    struct RTPMessage *buf;
+    struct RTPMessage *_Nullable buf;
 };
 
 struct RTPWorkBufferList {
@@ -121,22 +121,22 @@ struct RTPSession {
     uint16_t rsequnum;     /* Receiving sequence number */
     uint32_t rtimestamp;
     uint32_t ssrc; //  this seems to be unused!?
-    struct RTPMessage *mp; /* Expected parted message */
-    struct RTPWorkBufferList *work_buffer_list;
+    struct RTPMessage *_Nullable mp; /* Expected parted message */
+    struct RTPWorkBufferList *_Nonnull work_buffer_list;
     uint8_t  first_packets_counter; /* dismiss first few lost video packets */
-    const Logger *log;
-    Mono_Time *mono_time;
+    const Logger *_Nonnull log;
+    Mono_Time *_Nonnull mono_time;
     bool rtp_receive_active; /* if this is set to false then incoming rtp packets will not be processed by rtp_receive_packet() */
 
-    rtp_send_packet_cb *send_packet;
-    void *send_packet_user_data;
+    rtp_send_packet_cb *_Nullable send_packet;
+    void *_Nullable send_packet_user_data;
 
-    rtp_add_recv_cb *add_recv;
-    rtp_add_lost_cb *add_lost;
-    void *bwc_user_data;
+    rtp_add_recv_cb *_Nullable add_recv;
+    rtp_add_lost_cb *_Nullable add_lost;
+    void *_Nullable bwc_user_data;
 
-    void *cs;
-    rtp_m_cb *mcb;
+    void *_Nonnull cs;
+    rtp_m_cb *_Nonnull mcb;
 };
 
 const uint8_t *rtp_message_data(const RTPMessage *msg)