Resync

Author: LibretroAdmin

dynamic/dylib.c

@@ -53,19 +53,19 @@
 #endif
 
 #ifdef _WIN32
-static char last_dyn_error[512];
+static char last_dyn_err[512];
 
-static void set_dl_error(void)
+static void set_dl_err(void)
 {
    DWORD err = GetLastError();
    if (FormatMessage(
               FORMAT_MESSAGE_IGNORE_INSERTS
             | FORMAT_MESSAGE_FROM_SYSTEM,
             NULL, err,
             MAKELANGID(LANG_ENGLISH, SUBLANG_DEFAULT),
-            last_dyn_error, sizeof(last_dyn_error) - 1,
+            last_dyn_err, sizeof(last_dyn_err) - 1,
             NULL) == 0)
-      snprintf(last_dyn_error, sizeof(last_dyn_error) - 1,
+      snprintf(last_dyn_err, sizeof(last_dyn_err) - 1,
             "unknown error %lu", err);
 }
 #endif
@@ -121,10 +121,10 @@ dylib_t dylib_load(const char *path)
 
    if (!lib)
    {
-      set_dl_error();
+      set_dl_err();
       return NULL;
    }
-   last_dyn_error[0] = 0;
+   last_dyn_err[0] = 0;
 #elif defined(ORBIS)
    int res;
    dylib_t lib = (dylib_t)sceKernelLoadStartModule(path, 0, NULL, 0, NULL, &res);
@@ -153,8 +153,8 @@ dylib_t dylib_load(const char *path)
 char *dylib_error(void)
 {
 #ifdef _WIN32
-   if (last_dyn_error[0])
-      return last_dyn_error;
+   if (last_dyn_err[0])
+      return last_dyn_err;
    return NULL;
 #else
    return (char*)dlerror();
@@ -181,10 +181,10 @@ function_t dylib_proc(dylib_t lib, const char *proc)
    }
    if (!(sym = (function_t)GetProcAddress(mod, proc)))
    {
-      set_dl_error();
+      set_dl_err();
       return NULL;
    }
-   last_dyn_error[0] = 0;
+   last_dyn_err[0] = 0;
 #elif defined(ORBIS)
    void *ptr_sym = NULL;
    sym = NULL;
@@ -227,8 +227,8 @@ void dylib_close(dylib_t lib)
 {
 #ifdef _WIN32
    if (!FreeLibrary((HMODULE)lib))
-      set_dl_error();
-   last_dyn_error[0] = 0;
+      set_dl_err();
+   last_dyn_err[0] = 0;
 #elif defined(ORBIS)
    int res;
    sceKernelStopUnloadModule((SceKernelModule)lib, 0, NULL, 0, NULL, &res);

formats/png/rpng.c

@@ -753,7 +753,7 @@ static int rpng_load_image_argb_process_inflate_init(
       rpng_t *rpng, uint32_t **data)
 {
    bool zstatus;
-   enum trans_stream_error terror;
+   enum trans_stream_error err;
    uint32_t rd, wn;
    struct rpng_process *process = (struct rpng_process*)rpng->process;
    bool to_continue        = (process->avail_in > 0
@@ -762,16 +762,16 @@ static int rpng_load_image_argb_process_inflate_init(
    if (!to_continue)
       goto end;
 
-   zstatus = process->stream_backend->trans(process->stream, false, &rd, &wn, &terror);
+   zstatus = process->stream_backend->trans(process->stream, false, &rd, &wn, &err);
 
-   if (!zstatus && terror != TRANS_STREAM_ERROR_BUFFER_FULL)
+   if (!zstatus && err != TRANS_STREAM_ERROR_BUFFER_FULL)
       goto error;
 
    process->avail_in -= rd;
    process->avail_out -= wn;
    process->total_out += wn;
 
-   if (terror)
+   if (err)
       return 0;
 
 end:

formats/xml/rxml.c

@@ -257,9 +257,12 @@ rxml_document_t *rxml_load_document_string(const char *str)
                   node->attrib = attr;
             }
 
-            if (attr->attrib)
-               free(attr->attrib);
-            attr->attrib = strdup(x.attr);
+            if (attr)
+            {
+               if (attr->attrib)
+                  free(attr->attrib);
+               attr->attrib = strdup(x.attr);
+            }
 
             valptr       = buf->val;
             break;

gfx/gl_capabilities.c

@@ -78,27 +78,27 @@ bool gl_query_extension(const char *ext)
    return ret;
 }
 
-bool gl_check_error(char **error_string)
+bool gl_check_error(char **err_string)
 {
-   int error = glGetError();
-   switch (error)
+   int err = glGetError();
+   switch (err)
    {
       case GL_INVALID_ENUM:
-         *error_string = strdup("GL: Invalid enum.");
+         *err_string = strdup("GL: Invalid enum.");
          break;
       case GL_INVALID_VALUE:
-         *error_string = strdup("GL: Invalid value.");
+         *err_string = strdup("GL: Invalid value.");
          break;
       case GL_INVALID_OPERATION:
-         *error_string = strdup("GL: Invalid operation.");
+         *err_string = strdup("GL: Invalid operation.");
          break;
       case GL_OUT_OF_MEMORY:
-         *error_string = strdup("GL: Out of memory.");
+         *err_string = strdup("GL: Out of memory.");
          break;
       case GL_NO_ERROR:
          return true;
       default:
-         *error_string = strdup("Non specified GL error.");
+         *err_string = strdup("Non specified GL error.");
          break;
    }
 

lists/string_list.c

@@ -102,6 +102,10 @@ struct string_list *string_list_new(void)
    if (!list)
       return NULL;
 
+   list->cap                = 0;
+   list->size               = 0;
+   list->elems              = NULL;
+
    if (!(elems = (struct string_list_elem*)
       calloc(32, sizeof(*elems))))
    {
@@ -110,7 +114,6 @@ struct string_list *string_list_new(void)
    }
 
    list->elems              = elems;
-   list->size               = 0;
    list->cap                = 32;
 
    return list;

net/net_http.c

@@ -82,7 +82,7 @@ static slock_t *conn_pool_lock = NULL;
 
 struct http_t
 {
-   bool error;
+   bool err;
 
    struct conn_pool_entry *conn;
    bool ssl;
@@ -700,15 +700,15 @@ static void net_http_conn_pool_remove_expired(void)
       if (!entry->in_use && FD_ISSET(entry->fd, &fds))
       {
          char buf[4096];
-         bool error = false;
+         bool err = false;
 #ifdef HAVE_SSL
          if (entry->ssl && entry->ssl_ctx)
-            ssl_socket_receive_all_nonblocking(entry->ssl_ctx, &error, buf, sizeof(buf));
+            ssl_socket_receive_all_nonblocking(entry->ssl_ctx, &err, buf, sizeof(buf));
          else
 #endif
-            socket_receive_all_nonblocking(entry->fd, &error, buf, sizeof(buf));
+            socket_receive_all_nonblocking(entry->fd, &err, buf, sizeof(buf));
 
-         if (!error)
+         if (!err)
             continue;
 
          if (prev)
@@ -993,10 +993,10 @@ static bool net_http_connect(struct http_t *state)
             return true;
          }
       }
-      conn->fd = -1; /* already closed */
+      conn->fd    = -1; /* already closed */
       net_http_conn_pool_remove(conn);
       state->conn = NULL;
-      state->error = true;
+      state->err  = true;
       return false;
    }
    else
@@ -1012,32 +1012,32 @@ static bool net_http_connect(struct http_t *state)
 
          socket_close(conn->fd);
       }
-      conn->fd = -1; /* already closed */
+      conn->fd    = -1; /* already closed */
       net_http_conn_pool_remove(conn);
       state->conn = NULL;
-      state->error = true;
+      state->err  = true;
       return false;
    }
 }
 
 static void net_http_send_str(
       struct http_t *state, const char *text, size_t text_size)
 {
-   if (state->error)
+   if (state->err)
       return;
 #ifdef HAVE_SSL
    if (state->ssl)
    {
       if (!ssl_socket_send_all_blocking(
                   state->conn->ssl_ctx, text, text_size, true))
-         state->error = true;
+         state->err = true;
    }
    else
 #endif
    {
       if (!socket_send_all_blocking(
                   state->conn->fd, text, text_size, true))
-         state->error = true;
+         state->err = true;
    }
 }
 
@@ -1090,7 +1090,7 @@ static bool net_http_send_request(struct http_t *state)
 
       if (!request->postdata && !string_is_equal(request->method, "PUT"))
       {
-         state->error = true;
+         state->err = true;
          return true;
       }
 
@@ -1133,7 +1133,7 @@ static bool net_http_send_request(struct http_t *state)
       net_http_send_str(state, request->postdata, request->contentlength);
 
    state->request_sent = true;
-   return state->error;
+   return state->err;
 }
 
 /**
@@ -1175,7 +1175,7 @@ static ssize_t net_http_receive_header(struct http_t *state, ssize_t newlen)
          if (strncmp(response->data, "HTTP/1.", STRLEN_CONST("HTTP/1."))!=0)
          {
             response->part = P_DONE;
-            state->error = true;
+            state->err     = true;
             return -1;
          }
          response->status = (int)strtoul(response->data
@@ -1246,7 +1246,7 @@ static bool net_http_receive_body(struct http_t *state, ssize_t newlen)
 {
    struct response *response = &state->response;
 
-   if (newlen < 0 || state->error)
+   if (newlen < 0 || state->err)
    {
       if (response->bodytype != T_FULL)
          return false;
@@ -1412,7 +1412,7 @@ bool net_http_update(struct http_t *state, size_t* progress, size_t* total)
    if (!state)
       return true;
 
-   if (state->error)
+   if (state->err)
       return true;
 
    if (!state->conn)
@@ -1421,16 +1421,16 @@ bool net_http_update(struct http_t *state, size_t* progress, size_t* total)
       if (!state->conn)
       {
          if (!net_http_new_socket(state))
-            state->error = true;
-         return state->error;
+            state->err = true;
+         return state->err;
       }
    }
 
    if (!state->conn->connected)
    {
       if (!net_http_connect(state))
-         state->error = true;
-      return state->error;
+         state->err = true;
+      return state->err;
    }
 
    if (!state->request_sent)
@@ -1440,18 +1440,18 @@ bool net_http_update(struct http_t *state, size_t* progress, size_t* total)
 
 #ifdef HAVE_SSL
    if (state->ssl && state->conn->ssl_ctx)
-      newlen = ssl_socket_receive_all_nonblocking(state->conn->ssl_ctx, &state->error,
+      newlen = ssl_socket_receive_all_nonblocking(state->conn->ssl_ctx, &state->err,
             (uint8_t*)response->data + response->pos,
             response->buflen - response->pos);
    else
 #endif
-      newlen = socket_receive_all_nonblocking(state->conn->fd, &state->error,
+      newlen = socket_receive_all_nonblocking(state->conn->fd, &state->err,
             (uint8_t*)response->data + response->pos,
             response->buflen - response->pos);
 
    if (response->part < P_BODY)
    {
-      if (newlen < 0 || state->error)
+      if (newlen < 0 || state->err)
          goto error;
       newlen = net_http_receive_header(state, newlen);
    }
@@ -1505,7 +1505,7 @@ bool net_http_update(struct http_t *state, size_t* progress, size_t* total)
 
 error:
    net_http_conn_pool_remove(state->conn);
-   state->error     = true;
+   state->err       = true;
    response->part   = P_DONE;
    response->status = -1;
    return true;
@@ -1534,14 +1534,14 @@ int net_http_status(struct http_t *state)
  *
  * @return the response headers. The returned buffer is owned by the
  * caller of net_http_new; it is not freed by net_http_delete().
- * If the status is not 20x and accept_error is false, it returns NULL.
+ * If the status is not 20x and accept_err is false, it returns NULL.
  **/
 struct string_list *net_http_headers(struct http_t *state)
 {
    if (!state)
       return NULL;
 
-   if (state->error)
+   if (state->err)
       return NULL;
 
    return state->response.headers;
@@ -1554,14 +1554,14 @@ struct string_list *net_http_headers(struct http_t *state)
  *
  * @return the downloaded data. The returned buffer is owned by the
  * HTTP handler; it's freed by net_http_delete().
- * If the status is not 20x and accept_error is false, it returns NULL.
+ * If the status is not 20x and accept_err is false, it returns NULL.
  **/
-uint8_t* net_http_data(struct http_t *state, size_t* len, bool accept_error)
+uint8_t* net_http_data(struct http_t *state, size_t* len, bool accept_err)
 {
    if (!state)
       return NULL;
 
-   if (!accept_error && (state->error || state->response.status < 200 || state->response.status > 299))
+   if (!accept_err && (state->err || state->response.status < 200 || state->response.status > 299))
    {
       if (len)
          *len = 0;
@@ -1610,5 +1610,5 @@ void net_http_delete(struct http_t *state)
  **/
 bool net_http_error(struct http_t *state)
 {
-   return (state->error || state->response.status < 200 || state->response.status > 299);
+   return (state->err || state->response.status < 200 || state->response.status > 299);
 }