#else /* not HAVE_STRING_H */
# include <strings.h>
#endif /* not HAVE_STRING_H */
-#include <ctype.h>
#include <sys/types.h>
#ifdef HAVE_UNISTD_H
# include <unistd.h>
If memory debugging is not turned on, wget.h defines these:
#define xmalloc xmalloc_real
- #define xfree xfree_real
#define xrealloc xrealloc_real
#define xstrdup xstrdup_real
+ #define xfree free
In case of memory debugging, the definitions are a bit more
complex, because we want to provide more information, *and* we want
Each of the *_debug function does its magic and calls the real one. */
-void *
+#ifdef DEBUG_MALLOC
+# define STATIC_IF_DEBUG static
+#else
+# define STATIC_IF_DEBUG
+#endif
+
+STATIC_IF_DEBUG void *
xmalloc_real (size_t size)
{
void *ptr = malloc (size);
return ptr;
}
-void
-xfree_real (void *ptr)
-{
- free (ptr);
-}
-
-void *
+STATIC_IF_DEBUG void *
xrealloc_real (void *ptr, size_t newsize)
{
void *newptr;
return newptr;
}
-char *
+STATIC_IF_DEBUG char *
xstrdup_real (const char *s)
{
char *copy;
assert (ptr != NULL);
++free_count;
unregister_ptr (ptr);
- xfree_real (ptr);
+ free (ptr);
}
void *
++malloc_count;
register_ptr (newptr, source_file, source_line);
}
- else
+ else if (newptr != ptr)
{
unregister_ptr (ptr);
register_ptr (newptr, source_file, source_line);
}
\f
/* Return pointer to a static char[] buffer in which zero-terminated
- string-representation of TM (in form hh:mm:ss) is printed. It is
- shamelessly non-reentrant, but it doesn't matter, really.
+ string-representation of TM (in form hh:mm:ss) is printed.
+
+ If TM is non-NULL, the current time-in-seconds will be stored
+ there.
+
+ (#### This is misleading: one would expect TM would be used instead
+ of the current time in that case. This design was probably
+ influenced by the design time(2), and should be changed at some
+ points. No callers use non-NULL TM anyway.) */
- If TM is non-NULL, the time_t of the current time will be stored
- there. */
char *
time_str (time_t *tm)
{
- static char tms[15];
+ static char output[15];
struct tm *ptm;
- time_t tim;
-
- *tms = '\0';
- tim = time (tm);
- if (tim == -1)
- return tms;
- ptm = localtime (&tim);
- sprintf (tms, "%02d:%02d:%02d", ptm->tm_hour, ptm->tm_min, ptm->tm_sec);
- return tms;
+ time_t secs = time (tm);
+
+ if (secs == -1)
+ {
+ /* In case of error, return the empty string. Maybe we should
+ just abort if this happens? */
+ *output = '\0';
+ return output;
+ }
+ ptm = localtime (&secs);
+ sprintf (output, "%02d:%02d:%02d", ptm->tm_hour, ptm->tm_min, ptm->tm_sec);
+ return output;
+}
+
+/* Like the above, but include the date: YYYY-MM-DD hh:mm:ss. */
+
+char *
+datetime_str (time_t *tm)
+{
+ static char output[20]; /* "YYYY-MM-DD hh:mm:ss" + \0 */
+ struct tm *ptm;
+ time_t secs = time (tm);
+
+ if (secs == -1)
+ {
+ /* In case of error, return the empty string. Maybe we should
+ just abort if this happens? */
+ *output = '\0';
+ return output;
+ }
+ ptm = localtime (&secs);
+ sprintf (output, "%04d-%02d-%02d %02d:%02d:%02d",
+ ptm->tm_year + 1900, ptm->tm_mon + 1, ptm->tm_mday,
+ ptm->tm_hour, ptm->tm_min, ptm->tm_sec);
+ return output;
}
/* Returns an error message for ERRNUM. #### This requires more work.
efficiency, but at some cost to generality. */
fm->content = mmap (NULL, fm->length, PROT_READ | PROT_WRITE,
MAP_PRIVATE, fd, 0);
- if (fm->content == MAP_FAILED)
+ if (fm->content == (char *)MAP_FAILED)
goto mmap_lose;
if (!inhibit_close)
close (fd);
return legible_1 (inbuf);
}
+/* Write a string representation of NUMBER into the provided buffer.
+ We cannot use sprintf() because we cannot be sure whether the
+ platform supports printing of what we chose for VERY_LONG_TYPE.
+
+ Example: Gcc supports `long long' under many platforms, but on many
+ of those the native libc knows nothing of it and therefore cannot
+ print it.
+
+ How long BUFFER needs to be depends on the platform and the content
+ of NUMBER. For 64-bit VERY_LONG_TYPE (the most common case), 24
+ bytes are sufficient. Using more might be a good idea.
+
+ This function does not go through the hoops that long_to_string
+ goes to because it doesn't need to be fast. (It's called perhaps
+ once in a Wget run.) */
+
+static void
+very_long_to_string (char *buffer, VERY_LONG_TYPE number)
+{
+ int i = 0;
+ int j;
+
+ /* Print the number backwards... */
+ do
+ {
+ buffer[i++] = '0' + number % 10;
+ number /= 10;
+ }
+ while (number);
+
+ /* ...and reverse the order of the digits. */
+ for (j = 0; j < i / 2; j++)
+ {
+ char c = buffer[j];
+ buffer[j] = buffer[i - 1 - j];
+ buffer[i - 1 - j] = c;
+ }
+ buffer[i] = '\0';
+}
+
/* The same as legible(), but works on VERY_LONG_TYPE. See sysdep.h. */
char *
legible_very_long (VERY_LONG_TYPE l)
{
char inbuf[128];
/* Print the number into the buffer. */
- sprintf (inbuf, VERY_LONG_FORMAT, l);
+ very_long_to_string (inbuf, l);
return legible_1 (inbuf);
}
projects / wget / blobdiff