Consistently save errno immediately after the operation setting it

Prevent the situation where errno is set by function A, then function B
is called (which is typically _(), but could be anything else) and it
overwrites errno, then errno is checked by the caller.

errno is a horrific API, and we need to be careful to save its value as
soon as a function call (which might set it) returns. i.e. Follow the
pattern:
  int errsv, ret;
  ret = some_call_which_might_set_errno ();
  errsv = errno;

  if (ret < 0)
    puts (strerror (errsv));

This patch implements that pattern throughout GLib. There might be a few
places in the test code which still use errno directly. They should be
ported as necessary. It doesn’t modify all the call sites like this:
  if (some_call_which_might_set_errno () && errno == ESOMETHING)
since the refactoring involved is probably more harmful than beneficial
there. It does, however, refactor other call sites regardless of whether
they were originally buggy.

https://bugzilla.gnome.org/show_bug.cgi?id=785577

tests/testglib.c

@@ -907,6 +907,7 @@ test_file_functions (void)
   char template[32];
   char *name_used, chars[62];
   gint fd, n;
+  int errsv;
   
   strcpy (template, "foobar");
   fd = g_mkstemp (template);
@@ -919,15 +920,17 @@ test_file_functions (void)
   if (fd == -1)
     g_error ("g_mkstemp didn't work for template %s\n", template);
   n = write (fd, hello, hellolen);
+  errsv = errno;
   if (n == -1)
-    g_error ("write() failed: %s\n", g_strerror (errno));
+    g_error ("write() failed: %s\n", g_strerror (errsv));
   else if (n != hellolen)
     g_error ("write() should have written %d bytes, wrote %d\n", hellolen, n);
 
   lseek (fd, 0, 0);
   n = read (fd, chars, sizeof (chars));
+  errsv = errno;
   if (n == -1)
-    g_error ("read() failed: %s\n", g_strerror (errno));
+    g_error ("read() failed: %s\n", g_strerror (errsv));
   else if (n != hellolen)
     g_error ("read() should have read %d bytes, got %d\n", hellolen, n);