diff --git a/libretro-common/compat/compat_fnmatch.c b/libretro-common/compat/compat_fnmatch.c
index 5d409a3da4..a379420c46 100644
--- a/libretro-common/compat/compat_fnmatch.c
+++ b/libretro-common/compat/compat_fnmatch.c
@@ -23,6 +23,7 @@
 #if __TEST_FNMATCH__
 #include <assert.h>
 #endif
+#include <stddef.h>
 
 #include <compat/fnmatch.h>
 
@@ -34,9 +35,10 @@
 
 int rl_fnmatch(const char *pattern, const char *string, int flags)
 {
-   const char *c;
-   int charmatch = 0;
    int rv;
+   const char *c = NULL;
+   int charmatch = 0;
+
    for (c = pattern; *c != '\0'; c++)
    {
       /* String ended before pattern */
diff --git a/libretro-common/compat/compat_ifaddrs.c b/libretro-common/compat/compat_ifaddrs.c
index e06802689a..40f4da077b 100644
--- a/libretro-common/compat/compat_ifaddrs.c
+++ b/libretro-common/compat/compat_ifaddrs.c
@@ -45,617 +45,575 @@ typedef struct NetlinkList
 
 static int netlink_socket(void)
 {
-    int l_socket = socket(PF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
-    if(l_socket < 0)
-    {
-        return -1;
-    }
-    
-    struct sockaddr_nl l_addr;
-    memset(&l_addr, 0, sizeof(l_addr));
-    l_addr.nl_family = AF_NETLINK;
-    if(bind(l_socket, (struct sockaddr *)&l_addr, sizeof(l_addr)) < 0)
-    {
-        close(l_socket);
-        return -1;
-    }
-    
-    return l_socket;
+   struct sockaddr_nl l_addr;
+   int l_socket = socket(PF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
+
+   if(l_socket < 0)
+      return -1;
+
+   memset(&l_addr, 0, sizeof(l_addr));
+   l_addr.nl_family = AF_NETLINK;
+   if(bind(l_socket, (struct sockaddr *)&l_addr, sizeof(l_addr)) < 0)
+   {
+      close(l_socket);
+      return -1;
+   }
+
+   return l_socket;
 }
 
 static int netlink_send(int p_socket, int p_request)
 {
-    struct
-    {
-        struct nlmsghdr m_hdr;
-        struct rtgenmsg m_msg;
-    } l_data;
+   struct
+   {
+      struct nlmsghdr m_hdr;
+      struct rtgenmsg m_msg;
+   } l_data;
+   struct sockaddr_nl l_addr;
 
-    memset(&l_data, 0, sizeof(l_data));
-    
-    l_data.m_hdr.nlmsg_len = NLMSG_LENGTH(sizeof(struct rtgenmsg));
-    l_data.m_hdr.nlmsg_type = p_request;
-    l_data.m_hdr.nlmsg_flags = NLM_F_ROOT | NLM_F_MATCH | NLM_F_REQUEST;
-    l_data.m_hdr.nlmsg_pid = 0;
-    l_data.m_hdr.nlmsg_seq = p_socket;
-    l_data.m_msg.rtgen_family = AF_UNSPEC;
-    
-    struct sockaddr_nl l_addr;
-    memset(&l_addr, 0, sizeof(l_addr));
-    l_addr.nl_family = AF_NETLINK;
-    return (sendto(p_socket, &l_data.m_hdr, l_data.m_hdr.nlmsg_len, 0, (struct sockaddr *)&l_addr, sizeof(l_addr)));
+   memset(&l_data, 0, sizeof(l_data));
+
+   l_data.m_hdr.nlmsg_len = NLMSG_LENGTH(sizeof(struct rtgenmsg));
+   l_data.m_hdr.nlmsg_type = p_request;
+   l_data.m_hdr.nlmsg_flags = NLM_F_ROOT | NLM_F_MATCH | NLM_F_REQUEST;
+   l_data.m_hdr.nlmsg_pid = 0;
+   l_data.m_hdr.nlmsg_seq = p_socket;
+   l_data.m_msg.rtgen_family = AF_UNSPEC;
+
+   memset(&l_addr, 0, sizeof(l_addr));
+   l_addr.nl_family = AF_NETLINK;
+   return (sendto(p_socket, &l_data.m_hdr, l_data.m_hdr.nlmsg_len, 0, (struct sockaddr *)&l_addr, sizeof(l_addr)));
 }
 
 static int netlink_recv(int p_socket, void *p_buffer, size_t p_len)
 {
-    struct msghdr l_msg;
-    struct iovec l_iov = { p_buffer, p_len };
-    struct sockaddr_nl l_addr;
+   struct msghdr l_msg;
+   struct iovec l_iov = { p_buffer, p_len };
+   struct sockaddr_nl l_addr;
 
-    for(;;)
-    {
-        l_msg.msg_name = (void *)&l_addr;
-        l_msg.msg_namelen = sizeof(l_addr);
-        l_msg.msg_iov = &l_iov;
-        l_msg.msg_iovlen = 1;
-        l_msg.msg_control = NULL;
-        l_msg.msg_controllen = 0;
-        l_msg.msg_flags = 0;
-        int l_result = recvmsg(p_socket, &l_msg, 0);
-        
-        if(l_result < 0)
-        {
-            if(errno == EINTR)
-            {
-                continue;
-            }
-            return -2;
-        }
-        
-        if(l_msg.msg_flags & MSG_TRUNC)
-        { // buffer was too small
-            return -1;
-        }
-        return l_result;
-    }
+   for(;;)
+   {
+      l_msg.msg_name = (void *)&l_addr;
+      l_msg.msg_namelen = sizeof(l_addr);
+      l_msg.msg_iov = &l_iov;
+      l_msg.msg_iovlen = 1;
+      l_msg.msg_control = NULL;
+      l_msg.msg_controllen = 0;
+      l_msg.msg_flags = 0;
+      int l_result = recvmsg(p_socket, &l_msg, 0);
+
+      if(l_result < 0)
+      {
+         if(errno == EINTR)
+            continue;
+         return -2;
+      }
+
+      if(l_msg.msg_flags & MSG_TRUNC) /* buffer too small */
+         return -1;
+      return l_result;
+   }
 }
 
 static struct nlmsghdr *getNetlinkResponse(int p_socket, int *p_size, int *p_done)
 {
-    size_t l_size = 4096;
-    void *l_buffer = NULL;
-    
-    for(;;)
-    {
-        free(l_buffer);
-        l_buffer = malloc(l_size);
-        if (l_buffer == NULL)
-        {
-            return NULL;
-        }
-        
-        int l_read = netlink_recv(p_socket, l_buffer, l_size);
-        *p_size = l_read;
-        if(l_read == -2)
-        {
-            free(l_buffer);
-            return NULL;
-        }
-        if(l_read >= 0)
-        {
-            pid_t l_pid = getpid();
-            struct nlmsghdr *l_hdr;
-            for(l_hdr = (struct nlmsghdr *)l_buffer; NLMSG_OK(l_hdr, (unsigned int)l_read); l_hdr = (struct nlmsghdr *)NLMSG_NEXT(l_hdr, l_read))
+   size_t l_size = 4096;
+   void *l_buffer = NULL;
+
+   for(;;)
+   {
+      free(l_buffer);
+      l_buffer = malloc(l_size);
+      if (l_buffer == NULL)
+         return NULL;
+
+      int l_read = netlink_recv(p_socket, l_buffer, l_size);
+      *p_size = l_read;
+
+      if(l_read == -2)
+      {
+         free(l_buffer);
+         return NULL;
+      }
+
+      if(l_read >= 0)
+      {
+         pid_t l_pid = getpid();
+         struct nlmsghdr *l_hdr;
+         for(l_hdr = (struct nlmsghdr *)l_buffer; NLMSG_OK(l_hdr, (unsigned int)l_read); l_hdr = (struct nlmsghdr *)NLMSG_NEXT(l_hdr, l_read))
+         {
+            if((pid_t)l_hdr->nlmsg_pid != l_pid || (int)l_hdr->nlmsg_seq != p_socket)
+               continue;
+
+            if(l_hdr->nlmsg_type == NLMSG_DONE)
             {
-                if((pid_t)l_hdr->nlmsg_pid != l_pid || (int)l_hdr->nlmsg_seq != p_socket)
-                {
-                    continue;
-                }
-                
-                if(l_hdr->nlmsg_type == NLMSG_DONE)
-                {
-                    *p_done = 1;
-                    break;
-                }
-                
-                if(l_hdr->nlmsg_type == NLMSG_ERROR)
-                {
-                    free(l_buffer);
-                    return NULL;
-                }
+               *p_done = 1;
+               break;
             }
-            return l_buffer;
-        }
-        
-        l_size *= 2;
-    }
+
+            if(l_hdr->nlmsg_type == NLMSG_ERROR)
+            {
+               free(l_buffer);
+               return NULL;
+            }
+         }
+         return l_buffer;
+      }
+
+      l_size *= 2;
+   }
 }
 
 static NetlinkList *newListItem(struct nlmsghdr *p_data, unsigned int p_size)
 {
-    NetlinkList *l_item = malloc(sizeof(NetlinkList));
-    if (l_item == NULL)
-    {
-        return NULL;
-    }
+   NetlinkList *l_item = malloc(sizeof(NetlinkList));
+   if (l_item == NULL)
+      return NULL;
 
-    l_item->m_next = NULL;
-    l_item->m_data = p_data;
-    l_item->m_size = p_size;
-    return l_item;
+   l_item->m_next = NULL;
+   l_item->m_data = p_data;
+   l_item->m_size = p_size;
+   return l_item;
 }
 
 static void freeResultList(NetlinkList *p_list)
 {
-    NetlinkList *l_cur;
-    while(p_list)
-    {
-        l_cur = p_list;
-        p_list = p_list->m_next;
-        free(l_cur->m_data);
-        free(l_cur);
-    }
+   NetlinkList *l_cur;
+   while(p_list)
+   {
+      l_cur = p_list;
+      p_list = p_list->m_next;
+      free(l_cur->m_data);
+      free(l_cur);
+   }
 }
 
 static NetlinkList *getResultList(int p_socket, int p_request)
 {
-    if(netlink_send(p_socket, p_request) < 0)
-    {
-        return NULL;
-    }
+   if(netlink_send(p_socket, p_request) < 0)
+      return NULL;
 
-    NetlinkList *l_list = NULL;
-    NetlinkList *l_end = NULL;
-    int l_size;
-    int l_done = 0;
-    while(!l_done)
-    {
-        struct nlmsghdr *l_hdr = getNetlinkResponse(p_socket, &l_size, &l_done);
-        if(!l_hdr)
-        { // error
-            freeResultList(l_list);
-            return NULL;
-        }
-        
-        NetlinkList *l_item = newListItem(l_hdr, l_size);
-        if (!l_item)
-        {
-            freeResultList(l_list);
-            return NULL;
-        }
-        if(!l_list)
-        {
-            l_list = l_item;
-        }
-        else
-        {
-            l_end->m_next = l_item;
-        }
-        l_end = l_item;
-    }
-    return l_list;
+   NetlinkList *l_list = NULL;
+   NetlinkList *l_end = NULL;
+   int l_size;
+   int l_done = 0;
+   while(!l_done)
+   {
+      NetlinkList *l_item    = NULL;
+      struct nlmsghdr *l_hdr = getNetlinkResponse(p_socket, &l_size, &l_done);
+      if(!l_hdr)
+         goto error;
+
+      l_item = newListItem(l_hdr, l_size);
+      if (!l_item)
+         goto error;
+
+      if(!l_list)
+         l_list = l_item;
+      else
+         l_end->m_next = l_item;
+      l_end = l_item;
+   }
+
+   return l_list;
+
+error:
+   freeResultList(l_list);
+   return NULL;
 }
 
 static size_t maxSize(size_t a, size_t b)
 {
-    return (a > b ? a : b);
+   return (a > b ? a : b);
 }
 
 static size_t calcAddrLen(sa_family_t p_family, int p_dataSize)
 {
-    switch(p_family)
-    {
-        case AF_INET:
-            return sizeof(struct sockaddr_in);
-        case AF_INET6:
-            return sizeof(struct sockaddr_in6);
-        case AF_PACKET:
-            return maxSize(sizeof(struct sockaddr_ll), offsetof(struct sockaddr_ll, sll_addr) + p_dataSize);
-        default:
-            return maxSize(sizeof(struct sockaddr), offsetof(struct sockaddr, sa_data) + p_dataSize);
-    }
+   switch(p_family)
+   {
+      case AF_INET:
+         return sizeof(struct sockaddr_in);
+      case AF_INET6:
+         return sizeof(struct sockaddr_in6);
+      case AF_PACKET:
+         return maxSize(sizeof(struct sockaddr_ll), offsetof(struct sockaddr_ll, sll_addr) + p_dataSize);
+      default:
+         break;
+   }
+
+   return maxSize(sizeof(struct sockaddr), offsetof(struct sockaddr, sa_data) + p_dataSize);
 }
 
 static void makeSockaddr(sa_family_t p_family, struct sockaddr *p_dest, void *p_data, size_t p_size)
 {
-    switch(p_family)
-    {
-        case AF_INET:
-            memcpy(&((struct sockaddr_in*)p_dest)->sin_addr, p_data, p_size);
-            break;
-        case AF_INET6:
-            memcpy(&((struct sockaddr_in6*)p_dest)->sin6_addr, p_data, p_size);
-            break;
-        case AF_PACKET:
-            memcpy(((struct sockaddr_ll*)p_dest)->sll_addr, p_data, p_size);
-            ((struct sockaddr_ll*)p_dest)->sll_halen = p_size;
-            break;
-        default:
-            memcpy(p_dest->sa_data, p_data, p_size);
-            break;
-    }
-    p_dest->sa_family = p_family;
+   switch(p_family)
+   {
+      case AF_INET:
+         memcpy(&((struct sockaddr_in*)p_dest)->sin_addr, p_data, p_size);
+         break;
+      case AF_INET6:
+         memcpy(&((struct sockaddr_in6*)p_dest)->sin6_addr, p_data, p_size);
+         break;
+      case AF_PACKET:
+         memcpy(((struct sockaddr_ll*)p_dest)->sll_addr, p_data, p_size);
+         ((struct sockaddr_ll*)p_dest)->sll_halen = p_size;
+         break;
+      default:
+         memcpy(p_dest->sa_data, p_data, p_size);
+         break;
+   }
+   p_dest->sa_family = p_family;
 }
 
 static void addToEnd(struct ifaddrs **p_resultList, struct ifaddrs *p_entry)
 {
-    if(!*p_resultList)
-    {
-        *p_resultList = p_entry;
-    }
-    else
-    {
-        struct ifaddrs *l_cur = *p_resultList;
-        while(l_cur->ifa_next)
-        {
-            l_cur = l_cur->ifa_next;
-        }
-        l_cur->ifa_next = p_entry;
-    }
+   if(!*p_resultList)
+      *p_resultList = p_entry;
+   else
+   {
+      struct ifaddrs *l_cur = *p_resultList;
+      while(l_cur->ifa_next)
+         l_cur = l_cur->ifa_next;
+      l_cur->ifa_next = p_entry;
+   }
 }
 
 static int interpretLink(struct nlmsghdr *p_hdr, struct ifaddrs **p_resultList)
 {
-    struct ifinfomsg *l_info = (struct ifinfomsg *)NLMSG_DATA(p_hdr);
+   struct ifaddrs *l_entry  = NULL;
+   struct rtattr *l_rta     = NULL;
+   struct ifinfomsg *l_info = (struct ifinfomsg *)NLMSG_DATA(p_hdr);
+   size_t l_nameSize        = 0;
+   size_t l_addrSize        = 0;
+   size_t l_dataSize        = 0;
+   size_t l_rtaSize         = NLMSG_PAYLOAD(p_hdr, sizeof(struct ifinfomsg));
 
-    size_t l_nameSize = 0;
-    size_t l_addrSize = 0;
-    size_t l_dataSize = 0;
-    
-    size_t l_rtaSize = NLMSG_PAYLOAD(p_hdr, sizeof(struct ifinfomsg));
-    struct rtattr *l_rta;
-    for(l_rta = IFLA_RTA(l_info); RTA_OK(l_rta, l_rtaSize); l_rta = RTA_NEXT(l_rta, l_rtaSize))
-    {
-        size_t l_rtaDataSize = RTA_PAYLOAD(l_rta);
-        switch(l_rta->rta_type)
-        {
-            case IFLA_ADDRESS:
-            case IFLA_BROADCAST:
-                l_addrSize += NLMSG_ALIGN(calcAddrLen(AF_PACKET, l_rtaDataSize));
-                break;
-            case IFLA_IFNAME:
-                l_nameSize += NLMSG_ALIGN(l_rtaSize + 1);
-                break;
-            case IFLA_STATS:
-                l_dataSize += NLMSG_ALIGN(l_rtaSize);
-                break;
-            default:
-                break;
-        }
-    }
-    
-    struct ifaddrs *l_entry = malloc(sizeof(struct ifaddrs) + sizeof(int) + l_nameSize + l_addrSize + l_dataSize);
-    if (l_entry == NULL)
-    {
-        return -1;
-    }
-    memset(l_entry, 0, sizeof(struct ifaddrs));
-    l_entry->ifa_name = "";
-    
-    char *l_index = ((char *)l_entry) + sizeof(struct ifaddrs);
-    char *l_name = l_index + sizeof(int);
-    char *l_addr = l_name + l_nameSize;
-    char *l_data = l_addr + l_addrSize;
-    
-    // save the interface index so we can look it up when handling the addresses.
-    memcpy(l_index, &l_info->ifi_index, sizeof(int));
-    
-    l_entry->ifa_flags = l_info->ifi_flags;
-    
-    l_rtaSize = NLMSG_PAYLOAD(p_hdr, sizeof(struct ifinfomsg));
-    for(l_rta = IFLA_RTA(l_info); RTA_OK(l_rta, l_rtaSize); l_rta = RTA_NEXT(l_rta, l_rtaSize))
-    {
-        void *l_rtaData = RTA_DATA(l_rta);
-        size_t l_rtaDataSize = RTA_PAYLOAD(l_rta);
-        switch(l_rta->rta_type)
-        {
-            case IFLA_ADDRESS:
-            case IFLA_BROADCAST:
+   for(l_rta = IFLA_RTA(l_info); RTA_OK(l_rta, l_rtaSize); l_rta = RTA_NEXT(l_rta, l_rtaSize))
+   {
+      size_t l_rtaDataSize = RTA_PAYLOAD(l_rta);
+      switch(l_rta->rta_type)
+      {
+         case IFLA_ADDRESS:
+         case IFLA_BROADCAST:
+            l_addrSize += NLMSG_ALIGN(calcAddrLen(AF_PACKET, l_rtaDataSize));
+            break;
+         case IFLA_IFNAME:
+            l_nameSize += NLMSG_ALIGN(l_rtaSize + 1);
+            break;
+         case IFLA_STATS:
+            l_dataSize += NLMSG_ALIGN(l_rtaSize);
+            break;
+         default:
+            break;
+      }
+   }
+
+   l_entry = malloc(sizeof(struct ifaddrs) + sizeof(int) + l_nameSize + l_addrSize + l_dataSize);
+   if (l_entry == NULL)
+      return -1;
+
+   memset(l_entry, 0, sizeof(struct ifaddrs));
+   l_entry->ifa_name = "";
+
+   char *l_index = ((char *)l_entry) + sizeof(struct ifaddrs);
+   char *l_name = l_index + sizeof(int);
+   char *l_addr = l_name + l_nameSize;
+   char *l_data = l_addr + l_addrSize;
+
+   // save the interface index so we can look it up when handling the addresses.
+   memcpy(l_index, &l_info->ifi_index, sizeof(int));
+
+   l_entry->ifa_flags = l_info->ifi_flags;
+
+   l_rtaSize = NLMSG_PAYLOAD(p_hdr, sizeof(struct ifinfomsg));
+   for(l_rta = IFLA_RTA(l_info); RTA_OK(l_rta, l_rtaSize); l_rta = RTA_NEXT(l_rta, l_rtaSize))
+   {
+      void *l_rtaData = RTA_DATA(l_rta);
+      size_t l_rtaDataSize = RTA_PAYLOAD(l_rta);
+      switch(l_rta->rta_type)
+      {
+         case IFLA_ADDRESS:
+         case IFLA_BROADCAST:
             {
-                size_t l_addrLen = calcAddrLen(AF_PACKET, l_rtaDataSize);
-                makeSockaddr(AF_PACKET, (struct sockaddr *)l_addr, l_rtaData, l_rtaDataSize);
-                ((struct sockaddr_ll *)l_addr)->sll_ifindex = l_info->ifi_index;
-                ((struct sockaddr_ll *)l_addr)->sll_hatype = l_info->ifi_type;
-                if(l_rta->rta_type == IFLA_ADDRESS)
-                {
-                    l_entry->ifa_addr = (struct sockaddr *)l_addr;
-                }
-                else
-                {
-                    l_entry->ifa_broadaddr = (struct sockaddr *)l_addr;
-                }
-                l_addr += NLMSG_ALIGN(l_addrLen);
-                break;
+               size_t l_addrLen = calcAddrLen(AF_PACKET, l_rtaDataSize);
+               makeSockaddr(AF_PACKET, (struct sockaddr *)l_addr, l_rtaData, l_rtaDataSize);
+               ((struct sockaddr_ll *)l_addr)->sll_ifindex = l_info->ifi_index;
+               ((struct sockaddr_ll *)l_addr)->sll_hatype = l_info->ifi_type;
+               if(l_rta->rta_type == IFLA_ADDRESS)
+                  l_entry->ifa_addr = (struct sockaddr *)l_addr;
+               else
+                  l_entry->ifa_broadaddr = (struct sockaddr *)l_addr;
+               l_addr += NLMSG_ALIGN(l_addrLen);
+               break;
             }
-            case IFLA_IFNAME:
-                strncpy(l_name, l_rtaData, l_rtaDataSize);
-                l_name[l_rtaDataSize] = '\0';
-                l_entry->ifa_name = l_name;
-                break;
-            case IFLA_STATS:
-                memcpy(l_data, l_rtaData, l_rtaDataSize);
-                l_entry->ifa_data = l_data;
-                break;
-            default:
-                break;
-        }
-    }
-    
-    addToEnd(p_resultList, l_entry);
-    return 0;
+         case IFLA_IFNAME:
+            strncpy(l_name, l_rtaData, l_rtaDataSize);
+            l_name[l_rtaDataSize] = '\0';
+            l_entry->ifa_name = l_name;
+            break;
+         case IFLA_STATS:
+            memcpy(l_data, l_rtaData, l_rtaDataSize);
+            l_entry->ifa_data = l_data;
+            break;
+         default:
+            break;
+      }
+   }
+
+   addToEnd(p_resultList, l_entry);
+   return 0;
 }
 
 static struct ifaddrs *findInterface(int p_index, struct ifaddrs **p_links, int p_numLinks)
 {
-    int l_num = 0;
-    struct ifaddrs *l_cur = *p_links;
-    while(l_cur && l_num < p_numLinks)
-    {
-        char *l_indexPtr = ((char *)l_cur) + sizeof(struct ifaddrs);
-        int l_index;
-        memcpy(&l_index, l_indexPtr, sizeof(int));
-        if(l_index == p_index)
-        {
-            return l_cur;
-        }
-        
-        l_cur = l_cur->ifa_next;
-        ++l_num;
-    }
-    return NULL;
+   int l_num = 0;
+   struct ifaddrs *l_cur = *p_links;
+   while(l_cur && l_num < p_numLinks)
+   {
+      int l_index;
+      char *l_indexPtr = ((char *)l_cur) + sizeof(struct ifaddrs);
+
+      memcpy(&l_index, l_indexPtr, sizeof(int));
+      if(l_index == p_index)
+         return l_cur;
+
+      l_cur = l_cur->ifa_next;
+      ++l_num;
+   }
+   return NULL;
 }
 
 static int interpretAddr(struct nlmsghdr *p_hdr, struct ifaddrs **p_resultList, int p_numLinks)
 {
-    struct ifaddrmsg *l_info = (struct ifaddrmsg *)NLMSG_DATA(p_hdr);
-    struct ifaddrs *l_interface = findInterface(l_info->ifa_index, p_resultList, p_numLinks);
-    
-    if(l_info->ifa_family == AF_PACKET)
-    {
-        return 0;
-    }
+   size_t l_nameSize = 0;
+   size_t l_addrSize = 0;
+   int l_addedNetmask = 0;
+   struct ifaddrmsg *l_info = (struct ifaddrmsg *)NLMSG_DATA(p_hdr);
+   struct ifaddrs *l_interface = findInterface(l_info->ifa_index, p_resultList, p_numLinks);
 
-    size_t l_nameSize = 0;
-    size_t l_addrSize = 0;
-    
-    int l_addedNetmask = 0;
-    
-    size_t l_rtaSize = NLMSG_PAYLOAD(p_hdr, sizeof(struct ifaddrmsg));
-    struct rtattr *l_rta;
-    for(l_rta = IFA_RTA(l_info); RTA_OK(l_rta, l_rtaSize); l_rta = RTA_NEXT(l_rta, l_rtaSize))
-    {
-        size_t l_rtaDataSize = RTA_PAYLOAD(l_rta);
-        
-        switch(l_rta->rta_type)
-        {
-            case IFA_ADDRESS:
-            case IFA_LOCAL:
-                if((l_info->ifa_family == AF_INET || l_info->ifa_family == AF_INET6) && !l_addedNetmask)
-                { // make room for netmask
-                    l_addrSize += NLMSG_ALIGN(calcAddrLen(l_info->ifa_family, l_rtaDataSize));
-                    l_addedNetmask = 1;
-                }
-            case IFA_BROADCAST:
-                l_addrSize += NLMSG_ALIGN(calcAddrLen(l_info->ifa_family, l_rtaDataSize));
-                break;
-            case IFA_LABEL:
-                l_nameSize += NLMSG_ALIGN(l_rtaSize + 1);
-                break;
-            default:
-                break;
-        }
-    }
-    
-    struct ifaddrs *l_entry = malloc(sizeof(struct ifaddrs) + l_nameSize + l_addrSize);
-    if (l_entry == NULL)
-    {
-        return -1;
-    }
-    memset(l_entry, 0, sizeof(struct ifaddrs));
-    l_entry->ifa_name = (l_interface ? l_interface->ifa_name : "");
-    
-    char *l_name = ((char *)l_entry) + sizeof(struct ifaddrs);
-    char *l_addr = l_name + l_nameSize;
-    
-    l_entry->ifa_flags = l_info->ifa_flags;
-    if(l_interface)
-    {
-        l_entry->ifa_flags |= l_interface->ifa_flags;
-    }
-    
-    l_rtaSize = NLMSG_PAYLOAD(p_hdr, sizeof(struct ifaddrmsg));
-    for(l_rta = IFA_RTA(l_info); RTA_OK(l_rta, l_rtaSize); l_rta = RTA_NEXT(l_rta, l_rtaSize))
-    {
-        void *l_rtaData = RTA_DATA(l_rta);
-        size_t l_rtaDataSize = RTA_PAYLOAD(l_rta);
-        switch(l_rta->rta_type)
-        {
-            case IFA_ADDRESS:
-            case IFA_BROADCAST:
-            case IFA_LOCAL:
+   if(l_info->ifa_family == AF_PACKET)
+      return 0;
+
+   size_t l_rtaSize = NLMSG_PAYLOAD(p_hdr, sizeof(struct ifaddrmsg));
+   struct rtattr *l_rta;
+
+   for(l_rta = IFA_RTA(l_info); RTA_OK(l_rta, l_rtaSize); l_rta = RTA_NEXT(l_rta, l_rtaSize))
+   {
+      size_t l_rtaDataSize = RTA_PAYLOAD(l_rta);
+
+      switch(l_rta->rta_type)
+      {
+         case IFA_ADDRESS:
+         case IFA_LOCAL:
+            if((l_info->ifa_family == AF_INET || l_info->ifa_family == AF_INET6) && !l_addedNetmask)
             {
-                size_t l_addrLen = calcAddrLen(l_info->ifa_family, l_rtaDataSize);
-                makeSockaddr(l_info->ifa_family, (struct sockaddr *)l_addr, l_rtaData, l_rtaDataSize);
-                if(l_info->ifa_family == AF_INET6)
-                {
-                    if(IN6_IS_ADDR_LINKLOCAL((struct in6_addr *)l_rtaData) || IN6_IS_ADDR_MC_LINKLOCAL((struct in6_addr *)l_rtaData))
-                    {
-                        ((struct sockaddr_in6 *)l_addr)->sin6_scope_id = l_info->ifa_index;
-                    }
-                }
-                
-                if(l_rta->rta_type == IFA_ADDRESS)
-                { // apparently in a point-to-point network IFA_ADDRESS contains the dest address and IFA_LOCAL contains the local address
-                    if(l_entry->ifa_addr)
-                    {
-                        l_entry->ifa_dstaddr = (struct sockaddr *)l_addr;
-                    }
-                    else
-                    {
-                        l_entry->ifa_addr = (struct sockaddr *)l_addr;
-                    }
-                }
-                else if(l_rta->rta_type == IFA_LOCAL)
-                {
-                    if(l_entry->ifa_addr)
-                    {
-                        l_entry->ifa_dstaddr = l_entry->ifa_addr;
-                    }
-                    l_entry->ifa_addr = (struct sockaddr *)l_addr;
-                }
-                else
-                {
-                    l_entry->ifa_broadaddr = (struct sockaddr *)l_addr;
-                }
-                l_addr += NLMSG_ALIGN(l_addrLen);
-                break;
+               /* make room for netmask */
+               l_addrSize += NLMSG_ALIGN(calcAddrLen(l_info->ifa_family, l_rtaDataSize));
+               l_addedNetmask = 1;
             }
-            case IFA_LABEL:
-                strncpy(l_name, l_rtaData, l_rtaDataSize);
-                l_name[l_rtaDataSize] = '\0';
-                l_entry->ifa_name = l_name;
-                break;
-            default:
-                break;
-        }
-    }
-    
-    if(l_entry->ifa_addr && (l_entry->ifa_addr->sa_family == AF_INET || l_entry->ifa_addr->sa_family == AF_INET6))
-    {
-        unsigned l_maxPrefix = (l_entry->ifa_addr->sa_family == AF_INET ? 32 : 128);
-        unsigned l_prefix = (l_info->ifa_prefixlen > l_maxPrefix ? l_maxPrefix : l_info->ifa_prefixlen);
-        char l_mask[16] = {0};
-        unsigned i;
-        for(i=0; i<(l_prefix/8); ++i)
-        {
-            l_mask[i] = 0xff;
-        }
-        if(l_prefix % 8)
-        {
-            l_mask[i] = 0xff << (8 - (l_prefix % 8));
-        }
-        
-        makeSockaddr(l_entry->ifa_addr->sa_family, (struct sockaddr *)l_addr, l_mask, l_maxPrefix / 8);
-        l_entry->ifa_netmask = (struct sockaddr *)l_addr;
-    }
-    
-    addToEnd(p_resultList, l_entry);
-    return 0;
+         case IFA_BROADCAST:
+            l_addrSize += NLMSG_ALIGN(calcAddrLen(l_info->ifa_family, l_rtaDataSize));
+            break;
+         case IFA_LABEL:
+            l_nameSize += NLMSG_ALIGN(l_rtaSize + 1);
+            break;
+         default:
+            break;
+      }
+   }
+
+   struct ifaddrs *l_entry = malloc(sizeof(struct ifaddrs) + l_nameSize + l_addrSize);
+   if (l_entry == NULL)
+      return -1;
+
+   memset(l_entry, 0, sizeof(struct ifaddrs));
+   l_entry->ifa_name = (l_interface ? l_interface->ifa_name : "");
+
+   char *l_name = ((char *)l_entry) + sizeof(struct ifaddrs);
+   char *l_addr = l_name + l_nameSize;
+
+   l_entry->ifa_flags = l_info->ifa_flags;
+   if(l_interface)
+      l_entry->ifa_flags |= l_interface->ifa_flags;
+
+   l_rtaSize = NLMSG_PAYLOAD(p_hdr, sizeof(struct ifaddrmsg));
+   for(l_rta = IFA_RTA(l_info); RTA_OK(l_rta, l_rtaSize); l_rta = RTA_NEXT(l_rta, l_rtaSize))
+   {
+      void *l_rtaData = RTA_DATA(l_rta);
+      size_t l_rtaDataSize = RTA_PAYLOAD(l_rta);
+      switch(l_rta->rta_type)
+      {
+         case IFA_ADDRESS:
+         case IFA_BROADCAST:
+         case IFA_LOCAL:
+            {
+               size_t l_addrLen = calcAddrLen(l_info->ifa_family, l_rtaDataSize);
+               makeSockaddr(l_info->ifa_family, (struct sockaddr *)l_addr, l_rtaData, l_rtaDataSize);
+               if(l_info->ifa_family == AF_INET6)
+               {
+                  if(IN6_IS_ADDR_LINKLOCAL((struct in6_addr *)l_rtaData) || IN6_IS_ADDR_MC_LINKLOCAL((struct in6_addr *)l_rtaData))
+                     ((struct sockaddr_in6 *)l_addr)->sin6_scope_id = l_info->ifa_index;
+               }
+
+               if(l_rta->rta_type == IFA_ADDRESS)
+               {
+                  /* apparently in a point-to-point network IFA_ADDRESS 
+                   * contains the dest address and IFA_LOCAL contains the local address */
+                  if(l_entry->ifa_addr)
+                     l_entry->ifa_dstaddr = (struct sockaddr *)l_addr;
+                  else
+                     l_entry->ifa_addr = (struct sockaddr *)l_addr;
+               }
+               else if(l_rta->rta_type == IFA_LOCAL)
+               {
+                  if(l_entry->ifa_addr)
+                     l_entry->ifa_dstaddr = l_entry->ifa_addr;
+                  l_entry->ifa_addr = (struct sockaddr *)l_addr;
+               }
+               else
+                  l_entry->ifa_broadaddr = (struct sockaddr *)l_addr;
+               l_addr += NLMSG_ALIGN(l_addrLen);
+               break;
+            }
+         case IFA_LABEL:
+            strncpy(l_name, l_rtaData, l_rtaDataSize);
+            l_name[l_rtaDataSize] = '\0';
+            l_entry->ifa_name = l_name;
+            break;
+         default:
+            break;
+      }
+   }
+
+   if(l_entry->ifa_addr && 
+         (   l_entry->ifa_addr->sa_family == AF_INET 
+          || l_entry->ifa_addr->sa_family == AF_INET6))
+   {
+      unsigned i;
+      char l_mask[16];
+      unsigned l_maxPrefix = (l_entry->ifa_addr->sa_family == AF_INET 
+            ? 32 : 128);
+      unsigned l_prefix    = (l_info->ifa_prefixlen > l_maxPrefix 
+            ? l_maxPrefix : l_info->ifa_prefixlen);
+
+      l_mask[0] = '\0';
+
+      for(i=0; i<(l_prefix/8); ++i)
+         l_mask[i] = 0xff;
+      if(l_prefix % 8)
+         l_mask[i] = 0xff << (8 - (l_prefix % 8));
+
+      makeSockaddr(l_entry->ifa_addr->sa_family,
+            (struct sockaddr *)l_addr, l_mask, l_maxPrefix / 8);
+      l_entry->ifa_netmask = (struct sockaddr *)l_addr;
+   }
+
+   addToEnd(p_resultList, l_entry);
+   return 0;
 }
 
-static int interpretLinks(int p_socket, NetlinkList *p_netlinkList, struct ifaddrs **p_resultList)
+static int interpretLinks(int p_socket, NetlinkList *p_netlinkList,
+      struct ifaddrs **p_resultList)
 {
-    int l_numLinks = 0;
-    pid_t l_pid = getpid();
-    for(; p_netlinkList; p_netlinkList = p_netlinkList->m_next)
-    {
-        unsigned int l_nlsize = p_netlinkList->m_size;
-        struct nlmsghdr *l_hdr;
-        for(l_hdr = p_netlinkList->m_data; NLMSG_OK(l_hdr, l_nlsize); l_hdr = NLMSG_NEXT(l_hdr, l_nlsize))
-        {
-            if((pid_t)l_hdr->nlmsg_pid != l_pid || (int)l_hdr->nlmsg_seq != p_socket)
-            {
-                continue;
-            }
-            
-            if(l_hdr->nlmsg_type == NLMSG_DONE)
-            {
-                break;
-            }
-            
-            if(l_hdr->nlmsg_type == RTM_NEWLINK)
-            {
-                if(interpretLink(l_hdr, p_resultList) == -1)
-                {
-                    return -1;
-                }
-                ++l_numLinks;
-            }
-        }
-    }
-    return l_numLinks;
+   int l_numLinks = 0;
+   pid_t l_pid = getpid();
+   for(; p_netlinkList; p_netlinkList = p_netlinkList->m_next)
+   {
+      struct nlmsghdr *l_hdr = NULL;
+      unsigned int l_nlsize  = p_netlinkList->m_size;
+
+      for(l_hdr = p_netlinkList->m_data; NLMSG_OK(l_hdr, l_nlsize); l_hdr = NLMSG_NEXT(l_hdr, l_nlsize))
+      {
+         if((pid_t)l_hdr->nlmsg_pid != l_pid || (int)l_hdr->nlmsg_seq != p_socket)
+            continue;
+
+         if(l_hdr->nlmsg_type == NLMSG_DONE)
+            break;
+
+         if(l_hdr->nlmsg_type == RTM_NEWLINK)
+         {
+            if(interpretLink(l_hdr, p_resultList) == -1)
+               return -1;
+            ++l_numLinks;
+         }
+      }
+   }
+   return l_numLinks;
 }
 
-static int interpretAddrs(int p_socket, NetlinkList *p_netlinkList, struct ifaddrs **p_resultList, int p_numLinks)
+static int interpretAddrs(int p_socket, NetlinkList *p_netlinkList,
+      struct ifaddrs **p_resultList, int p_numLinks)
 {
-    pid_t l_pid = getpid();
-    for(; p_netlinkList; p_netlinkList = p_netlinkList->m_next)
-    {
-        unsigned int l_nlsize = p_netlinkList->m_size;
-        struct nlmsghdr *l_hdr;
-        for(l_hdr = p_netlinkList->m_data; NLMSG_OK(l_hdr, l_nlsize); l_hdr = NLMSG_NEXT(l_hdr, l_nlsize))
-        {
-            if((pid_t)l_hdr->nlmsg_pid != l_pid || (int)l_hdr->nlmsg_seq != p_socket)
-            {
-                continue;
-            }
-            
-            if(l_hdr->nlmsg_type == NLMSG_DONE)
-            {
-                break;
-            }
-            
-            if(l_hdr->nlmsg_type == RTM_NEWADDR)
-            {
-                if (interpretAddr(l_hdr, p_resultList, p_numLinks) == -1)
-                {
-                    return -1;
-                }
-            }
-        }
-    }
-    return 0;
+   pid_t l_pid = getpid();
+   for(; p_netlinkList; p_netlinkList = p_netlinkList->m_next)
+   {
+      struct nlmsghdr *l_hdr = NULL;
+      unsigned int l_nlsize  = p_netlinkList->m_size;
+
+      for(l_hdr = p_netlinkList->m_data; NLMSG_OK(l_hdr, l_nlsize); l_hdr = NLMSG_NEXT(l_hdr, l_nlsize))
+      {
+         if((pid_t)l_hdr->nlmsg_pid != l_pid || (int)l_hdr->nlmsg_seq != p_socket)
+            continue;
+
+         if(l_hdr->nlmsg_type == NLMSG_DONE)
+            break;
+
+         if(l_hdr->nlmsg_type == RTM_NEWADDR)
+         {
+            if (interpretAddr(l_hdr, p_resultList, p_numLinks) == -1)
+               return -1;
+         }
+      }
+   }
+   return 0;
 }
 
 int getifaddrs(struct ifaddrs **ifap)
 {
-    if(!ifap)
-    {
-        return -1;
-    }
-    *ifap = NULL;
-    
-    int l_socket = netlink_socket();
-    if(l_socket < 0)
-    {
-        return -1;
-    }
-    
-    NetlinkList *l_linkResults = getResultList(l_socket, RTM_GETLINK);
-    if(!l_linkResults)
-    {
-        close(l_socket);
-        return -1;
-    }
-    
-    NetlinkList *l_addrResults = getResultList(l_socket, RTM_GETADDR);
-    if(!l_addrResults)
-    {
-        close(l_socket);
-        freeResultList(l_linkResults);
-        return -1;
-    }
-    
-    int l_result = 0;
-    int l_numLinks = interpretLinks(l_socket, l_linkResults, ifap);
-    if(l_numLinks == -1 || interpretAddrs(l_socket, l_addrResults, ifap, l_numLinks) == -1)
-    {
-        l_result = -1;
-    }
-    
-    freeResultList(l_linkResults);
-    freeResultList(l_addrResults);
-    close(l_socket);
-    return l_result;
+   int l_socket = 0;
+   int l_result = 0;
+   if(!ifap)
+      return -1;
+   *ifap = NULL;
+
+   l_socket = netlink_socket();
+   if(l_socket < 0)
+      return -1;
+
+   NetlinkList *l_linkResults = getResultList(l_socket, RTM_GETLINK);
+   if(!l_linkResults)
+   {
+      close(l_socket);
+      return -1;
+   }
+
+   NetlinkList *l_addrResults = getResultList(l_socket, RTM_GETADDR);
+   if(!l_addrResults)
+   {
+      close(l_socket);
+      freeResultList(l_linkResults);
+      return -1;
+   }
+
+   int l_numLinks = interpretLinks(l_socket, l_linkResults, ifap);
+
+   if(l_numLinks == -1 || interpretAddrs(l_socket, l_addrResults, ifap, l_numLinks) == -1)
+      l_result = -1;
+
+   freeResultList(l_linkResults);
+   freeResultList(l_addrResults);
+   close(l_socket);
+   return l_result;
 }
 
 void freeifaddrs(struct ifaddrs *ifa)
 {
-    struct ifaddrs *l_cur;
-    while(ifa)
-    {
-        l_cur = ifa;
-        ifa = ifa->ifa_next;
-        free(l_cur);
-    }
+   struct ifaddrs *l_cur = NULL;
+
+   while(ifa)
+   {
+      l_cur = ifa;
+      ifa = ifa->ifa_next;
+      free(l_cur);
+   }
 }
diff --git a/libretro-common/compat/compat_strcasestr.c b/libretro-common/compat/compat_strcasestr.c
index 5cefe08f5e..44bd8b2183 100644
--- a/libretro-common/compat/compat_strcasestr.c
+++ b/libretro-common/compat/compat_strcasestr.c
@@ -43,10 +43,10 @@ static int casencmp(const char *a, const char *b, size_t n)
 
 char *strcasestr_retro__(const char *haystack, const char *needle)
 {
-   size_t i, hay_len, needle_len, search_off;
+   size_t i, search_off;
+   size_t hay_len    = strlen(haystack);
+   size_t needle_len = strlen(needle);
 
-   hay_len = strlen(haystack);
-   needle_len = strlen(needle);
    if (needle_len > hay_len)
       return NULL;
 
diff --git a/libretro-common/compat/compat_strl.c b/libretro-common/compat/compat_strl.c
index a16df87fb0..d3e4c7a63b 100644
--- a/libretro-common/compat/compat_strl.c
+++ b/libretro-common/compat/compat_strl.c
@@ -34,7 +34,7 @@
 size_t strlcpy(char *dest, const char *source, size_t size)
 {
    size_t src_size = 0;
-   size_t n = size;
+   size_t        n = size;
 
    if (n)
       while (--n && (*dest++ = *source++)) src_size++;
diff --git a/libretro-common/features/features_cpu.c b/libretro-common/features/features_cpu.c
index c5e4b3007e..7ad8e7d394 100644
--- a/libretro-common/features/features_cpu.c
+++ b/libretro-common/features/features_cpu.c
@@ -520,7 +520,7 @@ uint64_t cpu_features_get(void)
 {
    int flags[4];
    int vendor_shuffle[3];
-   char vendor[13]     = {0};
+   char vendor[13];
    size_t len          = 0;
    uint64_t cpu_flags  = 0;
    uint64_t cpu        = 0;
@@ -606,6 +606,8 @@ uint64_t cpu_features_get(void)
    vendor_shuffle[0] = flags[1];
    vendor_shuffle[1] = flags[3];
    vendor_shuffle[2] = flags[2];
+
+   vendor[0]         = '\0';
    memcpy(vendor, vendor_shuffle, sizeof(vendor_shuffle));
 
    /* printf("[CPUID]: Vendor: %s\n", vendor); */
diff --git a/libretro-common/file/archive_file_7z.c b/libretro-common/file/archive_file_7z.c
index 18bfb17ee9..e864bae715 100644
--- a/libretro-common/file/archive_file_7z.c
+++ b/libretro-common/file/archive_file_7z.c
@@ -139,7 +139,7 @@ static int sevenzip_file_read(
       for (i = 0; i < db.db.NumFiles; i++)
       {
          size_t len;
-         char infile[PATH_MAX_LENGTH] = {0};
+         char infile[PATH_MAX_LENGTH];
          size_t offset                = 0;
          size_t outSizeProcessed      = 0;
          const CSzFileItem    *f      = db.db.Files + i;
@@ -166,7 +166,9 @@ static int sevenzip_file_read(
          }
 
          SzArEx_GetFileNameUtf16(&db, i, temp);
-         res = SZ_ERROR_FAIL;
+         res       = SZ_ERROR_FAIL;
+         infile[0] = '\0';
+
          if (temp)
             res = utf16_to_char_string(temp, infile, sizeof(infile))
                ? SZ_OK : SZ_ERROR_FAIL;
@@ -340,13 +342,15 @@ static int sevenzip_parse_file_iterate_step_internal(
 
       if (len < PATH_MAX_LENGTH && !file->IsDir)
       {
+         char infile[PATH_MAX_LENGTH];
          SRes res                     = SZ_ERROR_FAIL;
-         char infile[PATH_MAX_LENGTH] = {0};
          uint16_t *temp               = (uint16_t*)malloc(len * sizeof(uint16_t));
 
          if (!temp)
             return -1;
 
+         infile[0] = '\0';
+
          SzArEx_GetFileNameUtf16(&sevenzip_context->db, sevenzip_context->index,
                temp);
 
@@ -375,8 +379,10 @@ static int sevenzip_parse_file_iterate_step_internal(
 }
 
 static int sevenzip_parse_file_iterate_step(file_archive_transfer_t *state,
-      const char *valid_exts, struct archive_extract_userdata *userdata, file_archive_file_cb file_cb)
+      const char *valid_exts,
+      struct archive_extract_userdata *userdata, file_archive_file_cb file_cb)
 {
+   char filename[PATH_MAX_LENGTH];
    const uint8_t *cdata = NULL;
    uint32_t checksum    = 0;
    uint32_t size        = 0;
@@ -384,7 +390,6 @@ static int sevenzip_parse_file_iterate_step(file_archive_transfer_t *state,
    unsigned cmode       = 0;
    unsigned payload     = 0;
    struct sevenzip_context_t *sevenzip_context = NULL;
-   char filename[PATH_MAX_LENGTH] = {0};
    int ret = sevenzip_parse_file_iterate_step_internal(state, filename,
          &cdata, &cmode, &size, &csize,
          &checksum, &payload, userdata);
@@ -392,8 +397,9 @@ static int sevenzip_parse_file_iterate_step(file_archive_transfer_t *state,
    if (ret != 1)
       return ret;
 
+   filename[0]                   = '\0';
    userdata->extracted_file_path = filename;
-   userdata->crc = checksum;
+   userdata->crc                 = checksum;
 
    if (file_cb && !file_cb(filename, valid_exts, cdata, cmode,
             csize, size, checksum, userdata))
diff --git a/libretro-common/file/config_file.c b/libretro-common/file/config_file.c
index 452b735619..b7de3ee1fc 100644
--- a/libretro-common/file/config_file.c
+++ b/libretro-common/file/config_file.c
@@ -258,7 +258,7 @@ static void add_child_list(config_file_t *parent, config_file_t *child)
 
 static void add_sub_conf(config_file_t *conf, char *line)
 {
-   char real_path[PATH_MAX_LENGTH] = {0};
+   char real_path[PATH_MAX_LENGTH];
    config_file_t         *sub_conf = NULL;
    char                      *path = extract_value(line, false);
 
@@ -267,6 +267,8 @@ static void add_sub_conf(config_file_t *conf, char *line)
 
    add_include_list(conf, path);
 
+   real_path[0] = '\0';
+
 #ifdef _WIN32
    fill_pathname_resolve_relative(real_path, conf->path,
          path, sizeof(real_path));
@@ -802,7 +804,9 @@ void config_set_path(config_file_t *conf, const char *entry, const char *val)
 #if defined(RARCH_CONSOLE)
    config_set_string(conf, entry, val);
 #else
-   char buf[PATH_MAX_LENGTH] = {0};
+   char buf[PATH_MAX_LENGTH];
+
+   buf[0] = '\0';
    fill_pathname_abbreviate_special(buf, val, sizeof(buf));
    config_set_string(conf, entry, buf);
 #endif
@@ -810,7 +814,9 @@ void config_set_path(config_file_t *conf, const char *entry, const char *val)
 
 void config_set_double(config_file_t *conf, const char *key, double val)
 {
-   char buf[128] = {0};
+   char buf[128];
+
+   buf[0] = '\0';
 #ifdef __cplusplus
    snprintf(buf, sizeof(buf), "%f", (float)val);
 #elif defined(__STDC_VERSION__) && __STDC_VERSION__>=199901L
@@ -823,28 +829,36 @@ void config_set_double(config_file_t *conf, const char *key, double val)
 
 void config_set_float(config_file_t *conf, const char *key, float val)
 {
-   char buf[128] = {0};
+   char buf[128];
+
+   buf[0] = '\0';
    snprintf(buf, sizeof(buf), "%f", val);
    config_set_string(conf, key, buf);
 }
 
 void config_set_int(config_file_t *conf, const char *key, int val)
 {
-   char buf[128] = {0};
+   char buf[128];
+
+   buf[0] = '\0';
    snprintf(buf, sizeof(buf), "%d", val);
    config_set_string(conf, key, buf);
 }
 
 void config_set_hex(config_file_t *conf, const char *key, unsigned val)
 {
-   char buf[128] = {0};
+   char buf[128];
+
+   buf[0] = '\0';
    snprintf(buf, sizeof(buf), "%x", val);
    config_set_string(conf, key, buf);
 }
 
 void config_set_uint64(config_file_t *conf, const char *key, uint64_t val)
 {
-   char buf[128] = {0};
+   char buf[128];
+
+   buf[0] = '\0';
 #ifdef _WIN32
    snprintf(buf, sizeof(buf), "%I64u", val);
 #else
@@ -855,7 +869,9 @@ void config_set_uint64(config_file_t *conf, const char *key, uint64_t val)
 
 void config_set_char(config_file_t *conf, const char *key, char val)
 {
-   char buf[2] = {0};
+   char buf[2];
+
+   buf[0] = '\0';
    snprintf(buf, sizeof(buf), "%c", val);
    config_set_string(conf, key, buf);
 }
diff --git a/libretro-common/file/file_path.c b/libretro-common/file/file_path.c
index 6b0c5e12a4..e4b6eb37c4 100644
--- a/libretro-common/file/file_path.c
+++ b/libretro-common/file/file_path.c
@@ -467,9 +467,11 @@ void fill_dated_filename(char *out_filename,
 void fill_str_dated_filename(char *out_filename,
       const char *in_str, const char *ext, size_t size)
 {
-   char format[256] = {0};
+   char format[256];
    time_t cur_time = time(NULL);
 
+   format[0] = '\0';
+
    strftime(format, sizeof(format), "-%y%m%d-%H%M%S.", localtime(&cur_time));
    strlcpy(out_filename, in_str, size);
    strlcat(out_filename, format, size);
diff --git a/libretro-common/hash/rhash.c b/libretro-common/hash/rhash.c
index a36c27d698..1c22efeef9 100644
--- a/libretro-common/hash/rhash.c
+++ b/libretro-common/hash/rhash.c
@@ -508,14 +508,16 @@ static void SHA1Input(SHA1Context *context,
 
 int sha1_calculate(const char *path, char *result)
 {
-   unsigned char buff[4096] = {0};
    SHA1Context sha;
-   int rv = 1;
+   unsigned char buff[4096];
+   int rv    = 1;
    RFILE *fd = filestream_open(path, RFILE_MODE_READ, -1);
 
    if (!fd)
       goto error;
 
+   buff[0] = '\0';
+
    SHA1Reset(&sha);
 
    do
diff --git a/libretro-common/lists/file_list.c b/libretro-common/lists/file_list.c
index cc59978faf..a4f36964a1 100644
--- a/libretro-common/lists/file_list.c
+++ b/libretro-common/lists/file_list.c
@@ -437,15 +437,16 @@ void file_list_get_last(const file_list_t *list,
 bool file_list_search(const file_list_t *list, const char *needle, size_t *idx)
 {
    size_t i;
-   const char *alt;
-   bool ret = false;
+   const char *alt = NULL;
+   bool ret        = false;
 
    if (!list)
       return false;
 
    for (i = 0; i < list->size; i++)
    {
-      const char *str;
+      const char *str = NULL;
+
       file_list_get_alt_at_offset(list, i, &alt);
       if (!alt)
       {
diff --git a/libretro-common/lists/string_list.c b/libretro-common/lists/string_list.c
index ae65eb0e20..3ba8e7d956 100644
--- a/libretro-common/lists/string_list.c
+++ b/libretro-common/lists/string_list.c
@@ -290,11 +290,13 @@ bool string_list_find_elem_prefix(const struct string_list *list,
       const char *prefix, const char *elem)
 {
    size_t i;
-   char prefixed[PATH_MAX_LENGTH] = {0};
+   char prefixed[PATH_MAX_LENGTH];
 
    if (!list)
       return false;
 
+   prefixed[0] = '\0';
+
    strlcpy(prefixed, prefix, sizeof(prefixed));
    strlcat(prefixed, elem,   sizeof(prefixed));
 
diff --git a/libretro-common/net/net_http.c b/libretro-common/net/net_http.c
index 0f99dccf10..51ce3ce541 100644
--- a/libretro-common/net/net_http.c
+++ b/libretro-common/net/net_http.c
@@ -254,7 +254,9 @@ struct http_t *net_http_new(struct http_connection_t *conn)
 
    if (conn->port != 80)
    {
-      char portstr[16] = {0};
+      char portstr[16];
+
+      portstr[0] = '\0';
 
       snprintf(portstr, sizeof(portstr), ":%i", conn->port);
       net_http_send_str(fd, &error, portstr);
diff --git a/libretro-common/queues/task_queue.c b/libretro-common/queues/task_queue.c
index 6390ae1c59..f83d98d66a 100644
--- a/libretro-common/queues/task_queue.c
+++ b/libretro-common/queues/task_queue.c
@@ -62,6 +62,8 @@ static void task_queue_msg_push(unsigned prio, unsigned duration,
    char buf[1024];
    va_list ap;
 
+   buf[0] = '\0';
+
    va_start(ap, fmt);
    vsnprintf(buf, sizeof(buf), fmt, ap);
    va_end(ap);
diff --git a/libretro-common/string/stdstring.c b/libretro-common/string/stdstring.c
index c114f1ed16..c99c775fa5 100644
--- a/libretro-common/string/stdstring.c
+++ b/libretro-common/string/stdstring.c
@@ -79,9 +79,10 @@ char *string_replace_substring(const char *in,
       const char *pattern, const char *replacement)
 {
    size_t numhits, pattern_len, replacement_len, outlen;
-   const char *inat;
-   const char *inprev;
-   char *out, *outat;
+   const char *inat   = NULL;
+   const char *inprev = NULL;
+   char          *out = NULL;
+   char        *outat = NULL;
    
    /* if either pattern or replacement is NULL,
     * duplicate in and let caller handle it. */
diff --git a/tasks/task_content.c b/tasks/task_content.c
index eb53814ffe..92ae717cac 100644
--- a/tasks/task_content.c
+++ b/tasks/task_content.c
@@ -356,8 +356,8 @@ static bool load_content_from_compressed_archive(
       bool need_fullpath, const char *path)
 {
    union string_list_elem_attr attributes;
-   char new_path[PATH_MAX_LENGTH]    = {0};
-   char new_basedir[PATH_MAX_LENGTH] = {0};
+   char new_path[PATH_MAX_LENGTH];
+   char new_basedir[PATH_MAX_LENGTH];
    ssize_t new_path_len              = 0;
    bool ret                          = false;
    rarch_system_info_t      *sys_info= NULL;
@@ -386,7 +386,10 @@ static bool load_content_from_compressed_archive(
             sizeof(new_basedir));
    }
 
-   attributes.i = 0;
+   new_path[0]    = '\0';
+   new_basedir[0] = '\0';
+   attributes.i   = 0;
+
    fill_pathname_join(new_path, new_basedir,
          path_basename(path), sizeof(new_path));
 
@@ -425,8 +428,8 @@ static bool init_content_file_extract(
 
    for (i = 0; i < content->size; i++)
    {
-      char temp_content[PATH_MAX_LENGTH] = {0};
-      char new_path[PATH_MAX_LENGTH]     = {0};
+      char temp_content[PATH_MAX_LENGTH];
+      char new_path[PATH_MAX_LENGTH];
       bool contains_compressed           = NULL;
       bool block_extract                 = content->elems[i].attr.i & 1;
       const char *valid_ext              = system->info.valid_extensions;
@@ -447,6 +450,8 @@ static bool init_content_file_extract(
             continue;
       }
 
+      temp_content[0] = new_path[0] = '\0';
+
       strlcpy(temp_content, content->elems[i].data,
             sizeof(temp_content));
 
@@ -867,8 +872,10 @@ static bool task_load_content(content_ctx_info_t *content_info,
       bool launched_from_menu,
       enum content_mode_load mode)
 {
-   char name[PATH_MAX_LENGTH]                 = {0};
-   char msg[PATH_MAX_LENGTH]                  = {0};
+   char name[PATH_MAX_LENGTH];
+   char msg[PATH_MAX_LENGTH];
+
+   name[0] = msg[0] = '\0';
 
    if (launched_from_menu)
    {
@@ -897,10 +904,12 @@ static bool task_load_content(content_ctx_info_t *content_info,
    /* Push entry to top of history playlist */
    if (content_is_inited() || content_does_not_need_content())
    {
-      char tmp[PATH_MAX_LENGTH]      = {0};
+      char tmp[PATH_MAX_LENGTH];
       struct retro_system_info *info = NULL;
       rarch_system_info_t *system    = NULL;
 
+      tmp[0] = '\0';
+
       runloop_ctl(RUNLOOP_CTL_SYSTEM_INFO_GET, &system);
       if (system)
          info = &system->info;
diff --git a/tasks/task_database.c b/tasks/task_database.c
index 034b9cfb48..187fb18b22 100644
--- a/tasks/task_database.c
+++ b/tasks/task_database.c
@@ -51,7 +51,9 @@ typedef struct db_handle
 static int task_database_iterate_start(database_info_handle_t *db,
       const char *name)
 {
-   char msg[128] = {0};
+   char msg[128];
+
+   msg[0] = '\0';
 
    snprintf(msg, sizeof(msg),
          STRING_REP_ULONG "/" STRING_REP_ULONG ": %s %s...\n",
@@ -107,9 +109,13 @@ static int iso_get_serial(database_state_handle_t *db_state,
 static int cue_get_serial(database_state_handle_t *db_state,
       database_info_handle_t *db, const char *name, char* serial)
 {
+   char track_path[PATH_MAX_LENGTH];
    int32_t offset                   = 0;
-   char track_path[PATH_MAX_LENGTH] = {0};
-   int rv                           = find_first_data_track(name,
+   int rv                           = 0;
+
+   track_path[0]                    = '\0';
+   
+   rv = find_first_data_track(name,
          &offset, track_path, PATH_MAX_LENGTH);
 
    if (rv < 0)
@@ -329,7 +335,9 @@ static int task_database_iterate_crc_lookup(
 
    if (db_state->entry_index == 0)
    {
-      char query[50] = {0};
+      char query[50];
+
+      query[0] = '\0';
 
       if (!core_info_database_supports_content_path(db_state->list->elems[db_state->list_index].data, name) &&
           !core_info_unsupported_content_path(name))
@@ -450,13 +458,15 @@ static int task_database_iterate_serial_lookup(
 
    if (db_state->entry_index == 0)
    {
-      char query[50]   = {0};
+      char query[50];
       char *serial_buf =
          bin_to_hex_alloc((uint8_t*)db_state->serial, 10 * sizeof(uint8_t));
 
       if (!serial_buf)
          return 1;
 
+      query[0] = '\0';
+
       snprintf(query, sizeof(query), "{'serial': b'%s'}", serial_buf);
       database_info_list_iterate_new(db_state, query);
 
diff --git a/tasks/task_database_cue.c b/tasks/task_database_cue.c
index e3125efdfa..246377b52c 100644
--- a/tasks/task_database_cue.c
+++ b/tasks/task_database_cue.c
@@ -382,7 +382,7 @@ int find_first_data_track(const char *cue_path,
       int32_t *offset, char *track_path, size_t max_len)
 {
    int rv;
-   char tmp_token[MAX_TOKEN_LEN] = {0};
+   char tmp_token[MAX_TOKEN_LEN];
    RFILE *fd                     = 
       filestream_open(cue_path, RFILE_MODE_READ, -1);
 
@@ -395,6 +395,8 @@ int find_first_data_track(const char *cue_path,
 
    RARCH_LOG("Parsing CUE file '%s'...\n", cue_path);
 
+   tmp_token[0] = '\0';
+
    while (get_token(fd, tmp_token, MAX_TOKEN_LEN) > 0)
    {
       if (string_is_equal(tmp_token, "FILE"))