Updates

Author: inactive123

compat/compat_ifaddrs.c

@@ -424,8 +424,7 @@ static void cpulist_parse(CpuList* list, char **buf, ssize_t length)
          q = end;
 
       /* Get first value */
-      p = parse_decimal(p, q, &start_value);
-      if (p == NULL)
+      if (!(p = parse_decimal(p, q, &start_value)))
          return;
 
       end_value = start_value;
@@ -435,8 +434,7 @@ static void cpulist_parse(CpuList* list, char **buf, ssize_t length)
        */
       if (p < q && *p == '-')
       {
-         p = parse_decimal(p+1, q, &end_value);
-         if (p == NULL)
+         if (!(p = parse_decimal(p+1, q, &end_value)))
             return;
       }
 

features/features_cpu.c

@@ -1162,7 +1162,7 @@ static void test_config_file_parse_contains(
    if (!val)
       return;
 
-   if (out == NULL)
+   if (!out)
       out = strdup("");
    if (strcmp(out, val) != 0)
       abort();

file/config_file.c

@@ -63,7 +63,10 @@ static void cdfs_determine_sector_size(cdfs_track_t* track)
 
 static void cdfs_seek_track_sector(cdfs_track_t* track, unsigned int sector)
 {
-   intfstream_seek(track->stream, sector * track->stream_sector_size + track->stream_sector_header_size + track->first_sector_offset, SEEK_SET);
+   intfstream_seek(track->stream,
+         sector * track->stream_sector_size + 
+         track->stream_sector_header_size   + 
+         track->first_sector_offset, SEEK_SET);
 }
 
 void cdfs_seek_sector(cdfs_file_t* file, unsigned int sector)
@@ -73,21 +76,21 @@ void cdfs_seek_sector(cdfs_file_t* file, unsigned int sector)
    {
       if (sector != file->current_sector)
       {
-         file->current_sector = sector;
+         file->current_sector      = sector;
          file->sector_buffer_valid = 0;
       }
 
-      file->pos = file->current_sector * 2048;
-      file->current_sector_offset = 0;
+      file->pos                    = file->current_sector * 2048;
+      file->current_sector_offset  = 0;
    }
 }
 
 static int cdfs_find_file(cdfs_file_t* file, const char* path)
 {
    uint8_t buffer[2048], *tmp;
    int sector, path_length;
-
    const char* slash = strrchr(path, '\\');
+
    if (slash)
    {
       /* navigate the path to the directory record for the file */
@@ -105,12 +108,13 @@ static int cdfs_find_file(cdfs_file_t* file, const char* path)
    {
       int offset;
 
-      /* find the cd information (always 16 frames in) */
+      /* find the CD information (always 16 frames in) */
       cdfs_seek_track_sector(file->track, 16);
       intfstream_read(file->track->stream, buffer, sizeof(buffer));
 
       /* the directory_record starts at 156 bytes into the sector.
-       * the sector containing the root directory contents is a 3 byte value that is 2 bytes into the directory_record. */
+       * the sector containing the root directory contents is a 
+       * 3 byte value that is 2 bytes into the directory_record. */
       offset = 156 + 2;
       sector = buffer[offset] | (buffer[offset + 1] << 8) | (buffer[offset + 2] << 16);
    }
@@ -120,21 +124,26 @@ static int cdfs_find_file(cdfs_file_t* file, const char* path)
    intfstream_read(file->track->stream, buffer, sizeof(buffer));
 
    path_length = strlen(path);
-   tmp = buffer;
+   tmp         = buffer;
+
    while (tmp < buffer + sizeof(buffer))
    {
-      /* the first byte of the record is the length of the record - if 0, we reached the end of the data */
+      /* The first byte of the record is the length of 
+       * the record - if 0, we reached the end of the data */
       if (!*tmp)
          break;
 
-      /* filename is 33 bytes into the record and the format is "FILENAME;version" or "DIRECTORY" */
+      /* filename is 33 bytes into the record and 
+       * the format is "FILENAME;version" or "DIRECTORY" */
       if ((tmp[33 + path_length] == ';' || tmp[33 + path_length] == '\0') &&
          strncasecmp((const char*)(tmp + 33), path, path_length) == 0)
       {
          /* the file size is in bytes 10-13 of the record */
-         file->size = tmp[10] | (tmp[11] << 8) | (tmp[12] << 16) | (tmp[13] << 24);
+         file->size = tmp[10] | (tmp[11] << 8) 
+            | (tmp[12] << 16) | (tmp[13] << 24);
 
-         /* the file contents are in the sector identified in bytes 2-4 of the record */
+         /* the file contents are in the sector identified 
+          * in bytes 2-4 of the record */
          sector = tmp[2] | (tmp[3] << 8) | (tmp[4] << 16);
          return sector;
       }
@@ -153,15 +162,17 @@ int cdfs_open_file(cdfs_file_t* file, cdfs_track_t* track, const char* path)
 
    memset(file, 0, sizeof(*file));
 
-   file->track = track;
-
+   file->track          = track;
    file->current_sector = -1;
+
    if (path)
       file->first_sector = cdfs_find_file(file, path);
    else if (file->track->stream_sector_size)
    {
       file->first_sector = 0;
-      file->size = (intfstream_get_size(file->track->stream) / file->track->stream_sector_size) * 2048;
+      file->size         = (intfstream_get_size(
+               file->track->stream) / file->track->stream_sector_size) 
+         * 2048;
    }
    else
       file->first_sector = -1;
@@ -189,12 +200,14 @@ int64_t cdfs_read_file(cdfs_file_t* file, void* buffer, uint64_t len)
       {
          if (remaining >= len)
          {
-            memcpy(buffer, &file->sector_buffer[file->current_sector_offset], len);
+            memcpy(buffer,
+                  &file->sector_buffer[file->current_sector_offset], len);
             file->current_sector_offset += len;
             return len;
          }
 
-         memcpy(buffer, &file->sector_buffer[file->current_sector_offset], remaining);
+         memcpy(buffer,
+               &file->sector_buffer[file->current_sector_offset], remaining);
          buffer = (char*)buffer + remaining;
          bytes_read += remaining;
          len -= remaining;
@@ -204,11 +217,11 @@ int64_t cdfs_read_file(cdfs_file_t* file, void* buffer, uint64_t len)
 
       ++file->current_sector;
       file->current_sector_offset = 0;
-      file->sector_buffer_valid = 0;
+      file->sector_buffer_valid   = 0;
    }
    else if (file->current_sector < file->first_sector)
    {
-      file->current_sector = file->first_sector;
+      file->current_sector        = file->first_sector;
       file->current_sector_offset = 0;
    }
 
@@ -217,8 +230,9 @@ int64_t cdfs_read_file(cdfs_file_t* file, void* buffer, uint64_t len)
       cdfs_seek_track_sector(file->track, file->current_sector);
       intfstream_read(file->track->stream, buffer, 2048);
 
-      buffer = (char*)buffer + 2048;
+      buffer      = (char*)buffer + 2048;
       bytes_read += 2048;
+
       ++file->current_sector;
 
       len -= 2048;
@@ -243,7 +257,8 @@ void cdfs_close_file(cdfs_file_t* file)
 {
    if (file)
    {
-      /* not really anything to do here, just clear out the first_sector so read() won't do anything */
+      /* not really anything to do here, just 
+       * clear out the first_sector so read() won't do anything */
       file->first_sector = -1;
    }
 }
@@ -314,21 +329,26 @@ static void cdfs_skip_spaces(const char** ptr)
       ++(*ptr);
 }
 
-static cdfs_track_t* cdfs_wrap_stream(intfstream_t* stream, unsigned first_sector_offset)
+static cdfs_track_t* cdfs_wrap_stream(
+      intfstream_t* stream, unsigned first_sector_offset)
 {
-   cdfs_track_t* track;
+   cdfs_track_t* track = NULL;
 
-   if (stream == NULL)
+   if (!stream)
       return NULL;
 
-   track = (cdfs_track_t*)calloc(1, sizeof(*track));
-   track->stream = stream;
+   track                      = (cdfs_track_t*)
+      calloc(1, sizeof(*track));
+   track->stream              = stream;
    track->first_sector_offset = first_sector_offset;
+
    cdfs_determine_sector_size(track);
+
    return track;
 }
 
-static cdfs_track_t* cdfs_open_cue_track(const char* path, unsigned int track_index)
+static cdfs_track_t* cdfs_open_cue_track(
+      const char* path, unsigned int track_index)
 {
    char* cue                                = NULL;
    const char* line                         = NULL;
@@ -442,10 +462,9 @@ static cdfs_track_t* cdfs_open_cue_track(const char* path, unsigned int track_in
 
          if (found_track && index_number == 1)
          {
-            if (strstr(current_track_path, "/") || strstr(current_track_path, "\\"))
-            {
+            if (  strstr(current_track_path, "/") || 
+                  strstr(current_track_path, "\\"))
                strncpy(track_path, current_track_path, sizeof(track_path));
-            }
             else
             {
                fill_pathname_basedir(track_path, path, sizeof(track_path));
@@ -462,7 +481,10 @@ static cdfs_track_t* cdfs_open_cue_track(const char* path, unsigned int track_in
    if (string_is_empty(track_path))
       return NULL;
 
-   track = cdfs_wrap_stream(intfstream_open_file(track_path, RETRO_VFS_FILE_ACCESS_READ, RETRO_VFS_FILE_ACCESS_HINT_NONE), track_offset);
+   track = cdfs_wrap_stream(intfstream_open_file(
+            track_path, RETRO_VFS_FILE_ACCESS_READ,
+            RETRO_VFS_FILE_ACCESS_HINT_NONE), track_offset);
+
    if (track && track->stream_sector_size == 0)
    {
       track->stream_sector_size = sector_size;
@@ -482,11 +504,14 @@ static cdfs_track_t* cdfs_open_chd_track(const char* path, int32_t track_index)
    intfstream_t* intf_stream;
    cdfs_track_t* track;
 
-   intf_stream = intfstream_open_chd_track(path, RETRO_VFS_FILE_ACCESS_READ, RETRO_VFS_FILE_ACCESS_HINT_NONE, track_index);
+   intf_stream = intfstream_open_chd_track(path,
+         RETRO_VFS_FILE_ACCESS_READ, RETRO_VFS_FILE_ACCESS_HINT_NONE,
+         track_index);
    if (!intf_stream)
       return NULL;
 
-   track = cdfs_wrap_stream(intf_stream, intfstream_get_offset_to_start(intf_stream));
+   track = cdfs_wrap_stream(intf_stream,
+         intfstream_get_offset_to_start(intf_stream));
 
    if (track && track->stream_sector_header_size == 0)
    {
@@ -502,7 +527,8 @@ static cdfs_track_t* cdfs_open_chd_track(const char* path, int32_t track_index)
 }
 #endif
 
-struct cdfs_track_t* cdfs_open_track(const char* path, unsigned int track_index)
+struct cdfs_track_t* cdfs_open_track(const char* path,
+      unsigned int track_index)
 {
    const char* ext = path_get_extension(path);
 
@@ -538,8 +564,11 @@ cdfs_track_t* cdfs_open_raw_track(const char* path)
 {
    const char* ext = path_get_extension(path);
 
-   if (string_is_equal_noncase(ext, "bin") || string_is_equal_noncase(ext, "iso"))
-      return cdfs_wrap_stream(intfstream_open_file(path, RETRO_VFS_FILE_ACCESS_READ, RETRO_VFS_FILE_ACCESS_HINT_NONE), 0);
+   if (  string_is_equal_noncase(ext, "bin") || 
+         string_is_equal_noncase(ext, "iso"))
+      return cdfs_wrap_stream(intfstream_open_file(path,
+               RETRO_VFS_FILE_ACCESS_READ,
+               RETRO_VFS_FILE_ACCESS_HINT_NONE), 0);
 
    /* unsupported file type */
    return NULL;

formats/cdfs/cdfs.c

@@ -100,7 +100,7 @@ enum rwav_state rwav_iterate(rwav_iterator_t *iter)
 
          samples = malloc(rwav->subchunk2size);
 
-         if (samples == NULL)
+         if (!samples)
             return RWAV_ITERATE_ERROR;
 
          rwav->numchannels = data[22] | data[23] << 8;

formats/wav/rwav.c

@@ -782,10 +782,12 @@ dg__dynarr_grow(void** arr, dg__dynarr_md* md, size_t itemsize, size_t min_neede
 DG_DYNARR_INLINE void
 dg__dynarr_init(void** p, dg__dynarr_md* md, void* buf, size_t buf_cap)
 {
-	*p = buf;
-	md->cnt = 0;
-	if(buf == NULL)  md->cap = 0;
-	else md->cap = (DG__DYNARR_SIZE_T_MSB | buf_cap);
+	*p         = buf;
+	md->cnt    = 0;
+	if(!buf)
+      md->cap = 0;
+	else
+      md->cap = (DG__DYNARR_SIZE_T_MSB | buf_cap);
 }
 
 DG_DYNARR_INLINE int
@@ -952,7 +954,7 @@ dg__dynarr_grow(void** arr, dg__dynarr_md* md, size_t itemsize, size_t min_neede
 		else
 		{
 			void* p = DG_DYNARR_REALLOC(*arr, itemsize, md->cnt, newcap);
-			if(p == NULL)  DG_DYNARR_FREE(*arr); /* realloc failed, at least don't leak memory */
+			if (!p) DG_DYNARR_FREE(*arr); /* realloc failed, at least don't leak memory */
 			*arr = p;
 		}
 

include/array/dynarray.h

@@ -189,7 +189,7 @@ int ssl_socket_receive_all_blocking(void *state_data, void *data_, size_t size)
 
    mbedtls_net_set_block(&state->net_ctx);
 
-   while (1)
+   for (;;)
    {
       /* mbedtls_ssl_read wants non-const data but it only reads it, so this cast is safe */
       int ret = mbedtls_ssl_read(&state->ctx, (unsigned char*)data, size);

net/net_socket_ssl.c

@@ -451,7 +451,7 @@ static void threaded_worker(void *userdata)
 
       /* Get first task to run */
       task = tasks_running.front;
-      if (task == NULL)
+      if (!task)
       {
          scond_wait(worker_cond, running_lock);
          slock_unlock(running_lock);

queues/task_queue.c

@@ -144,7 +144,7 @@ static void tpool_worker(void *arg)
        * Also, the working_cnt can't be changed (except the thread holding the lock).
        * At this point if there isn't any work processing and if there is no work
        * signal this is the case. */
-      if (!tp->stop && tp->working_cnt == 0 && tp->work_first == NULL)
+      if (!tp->stop && tp->working_cnt == 0 && !tp->work_first)
          scond_signal(tp->working_cond);
       slock_unlock(tp->work_mutex);
    }