summaryrefslogtreecommitdiffstats
path: root/src/sed/lib/utils.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/sed/lib/utils.c')
-rw-r--r--src/sed/lib/utils.c529
1 files changed, 529 insertions, 0 deletions
diff --git a/src/sed/lib/utils.c b/src/sed/lib/utils.c
new file mode 100644
index 0000000..41c61aa
--- /dev/null
+++ b/src/sed/lib/utils.c
@@ -0,0 +1,529 @@
+/* Functions from hack's utils library.
+ Copyright (C) 1989, 1990, 1991, 1998, 1999, 2003
+ Free Software Foundation, Inc.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2, or (at your option)
+ any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */
+
+#include "config.h"
+
+#include <stdio.h>
+
+#include <errno.h>
+#ifndef errno
+ extern int errno;
+#endif
+
+#ifdef HAVE_STRINGS_H
+# include <strings.h>
+#else
+# include <string.h>
+#endif /* HAVE_STRINGS_H */
+
+#ifdef HAVE_STDLIB_H
+# include <stdlib.h>
+#endif /* HAVE_STDLIB_H */
+
+#ifdef HAVE_UNISTD_H /* bird: for unlink on darwin */
+# include <unistd.h>
+#endif
+
+#include "utils.h"
+
+#ifdef KBUILD_OS_WINDOWS /* bird: Way faster console output! */
+# include "console.h"
+# define fwrite maybe_con_fwrite
+#endif
+
+const char *myname;
+
+/* Store information about files opened with ck_fopen
+ so that error messages from ck_fread, ck_fwrite, etc. can print the
+ name of the file that had the error */
+
+struct open_file
+ {
+ FILE *fp;
+ char *name;
+ struct open_file *link;
+ unsigned temp : 1;
+ };
+
+static struct open_file *open_files = NULL;
+static void do_ck_fclose P_((FILE *fp));
+
+/* Print an error message and exit */
+#if !defined __STDC__ || !(__STDC__-0)
+# include <varargs.h>
+# define VSTART(l,a) va_start(l)
+void
+panic(str, va_alist)
+ char *str;
+ va_dcl
+#else /*__STDC__*/
+# include <stdarg.h>
+# define VSTART(l,a) va_start(l, a)
+void
+panic(const char *str, ...)
+#endif /* __STDC__ */
+{
+ va_list iggy;
+
+ fprintf(stderr, "%s: ", myname);
+ VSTART(iggy, str);
+#ifndef HAVE_VPRINTF
+# ifndef HAVE_DOPRNT
+ fputs(str, stderr); /* not great, but perhaps better than nothing... */
+# else /* HAVE_DOPRNT */
+ _doprnt(str, &iggy, stderr);
+# endif /* HAVE_DOPRNT */
+#else /* HAVE_VFPRINTF */
+ vfprintf(stderr, str, iggy);
+#endif /* HAVE_VFPRINTF */
+ va_end(iggy);
+ putc('\n', stderr);
+
+ /* Unlink the temporary files. */
+ while (open_files)
+ {
+ if (open_files->temp)
+ {
+ int fd = fileno (open_files->fp);
+ fclose (open_files->fp);
+ errno = 0;
+ unlink (open_files->name);
+ if (errno != 0)
+ fprintf (stderr, _("cannot remove %s: %s"), open_files->name, strerror (errno));
+ }
+
+ open_files = open_files->link;
+ }
+
+ exit(4);
+}
+
+
+/* Internal routine to get a filename from open_files */
+static const char *utils_fp_name P_((FILE *fp));
+static const char *
+utils_fp_name(fp)
+ FILE *fp;
+{
+ struct open_file *p;
+
+ for (p=open_files; p; p=p->link)
+ if (p->fp == fp)
+ return p->name;
+ if (fp == stdin)
+ return "stdin";
+ else if (fp == stdout)
+ return "stdout";
+ else if (fp == stderr)
+ return "stderr";
+
+ return "<unknown>";
+}
+
+/* Panic on failing fopen */
+FILE *
+ck_fopen(name, mode, fail)
+ const char *name;
+ const char *mode;
+ bool fail;
+{
+ FILE *fp;
+ struct open_file *p;
+
+ fp = fopen (name, mode);
+ if (!fp)
+ {
+ if (fail)
+ panic(_("couldn't open file %s: %s"), name, strerror(errno));
+
+ return NULL;
+ }
+
+ for (p=open_files; p; p=p->link)
+ {
+ if (fp == p->fp)
+ {
+ FREE(p->name);
+ break;
+ }
+ }
+ if (!p)
+ {
+ p = MALLOC(1, struct open_file);
+ p->link = open_files;
+ open_files = p;
+ }
+ p->name = ck_strdup(name);
+ p->fp = fp;
+ p->temp = false;
+ return fp;
+}
+
+FILE *
+ck_mkstemp (p_filename, tmpdir, base)
+ char **p_filename;
+ char *base, *tmpdir;
+{
+ char *template;
+ FILE *fp;
+ int fd;
+ struct open_file *p;
+
+ if (tmpdir == NULL)
+ tmpdir = getenv("TMPDIR");
+ if (tmpdir == NULL)
+ {
+ tmpdir = getenv("TMP");
+ if (tmpdir == NULL)
+#ifdef P_tmpdir
+ tmpdir = P_tmpdir;
+#else
+ tmpdir = "/tmp";
+#endif
+ }
+
+ template = xmalloc (strlen (tmpdir) + strlen (base) + 8);
+ sprintf (template, "%s/%sXXXXXX", tmpdir, base);
+
+ fd = mkstemp (template);
+ if (fd == -1)
+ panic(_("couldn't open temporary file %s: %s"), template, strerror(errno));
+
+ *p_filename = template;
+ fp = fdopen (fd, "w");
+
+ p = MALLOC(1, struct open_file);
+ p->name = ck_strdup (template);
+ p->fp = fp;
+ p->temp = true;
+ p->link = open_files;
+ open_files = p;
+ return fp;
+}
+
+/* Panic on failing fwrite */
+void
+ck_fwrite(ptr, size, nmemb, stream)
+ const VOID *ptr;
+ size_t size;
+ size_t nmemb;
+ FILE *stream;
+{
+ clearerr(stream);
+ if (size && fwrite(ptr, size, nmemb, stream) != nmemb)
+ panic(ngettext("couldn't write %d item to %s: %s",
+ "couldn't write %d items to %s: %s", nmemb),
+ nmemb, utils_fp_name(stream), strerror(errno));
+}
+
+/* Panic on failing fread */
+size_t
+ck_fread(ptr, size, nmemb, stream)
+ VOID *ptr;
+ size_t size;
+ size_t nmemb;
+ FILE *stream;
+{
+ clearerr(stream);
+ if (size && (nmemb=fread(ptr, size, nmemb, stream)) <= 0 && ferror(stream))
+ panic(_("read error on %s: %s"), utils_fp_name(stream), strerror(errno));
+
+ return nmemb;
+}
+
+size_t
+ck_getline(text, buflen, stream)
+ char **text;
+ size_t *buflen;
+ FILE *stream;
+{
+ int result;
+ if (!ferror (stream))
+ result = getline (text, buflen, stream);
+
+ if (ferror (stream))
+ panic (_("read error on %s: %s"), utils_fp_name(stream), strerror(errno));
+
+ return result;
+}
+
+/* Panic on failing fflush */
+void
+ck_fflush(stream)
+ FILE *stream;
+{
+ clearerr(stream);
+ if (fflush(stream) == EOF && errno != EBADF)
+ panic("couldn't flush %s: %s", utils_fp_name(stream), strerror(errno));
+}
+
+/* Panic on failing fclose */
+void
+ck_fclose(stream)
+ FILE *stream;
+{
+ struct open_file r;
+ struct open_file *prev;
+ struct open_file *cur;
+
+ /* a NULL stream means to close all files */
+ r.link = open_files;
+ prev = &r;
+ while ( (cur = prev->link) )
+ {
+ if (!stream || stream == cur->fp)
+ {
+ do_ck_fclose (cur->fp);
+ prev->link = cur->link;
+ FREE(cur->name);
+ FREE(cur);
+ }
+ else
+ prev = cur;
+ }
+
+ open_files = r.link;
+
+ /* Also care about stdout, because if it is redirected the
+ last output operations might fail and it is important
+ to signal this as an error (perhaps to make). */
+ if (!stream)
+ {
+ do_ck_fclose (stdout);
+ do_ck_fclose (stderr);
+ }
+}
+
+/* Close a single file. */
+void
+do_ck_fclose(fp)
+ FILE *fp;
+{
+ int fd;
+ ck_fflush(fp);
+ clearerr(fp);
+
+ /* We want to execute both arms, so use | not ||. */
+ if (fclose(fp) == EOF)
+ panic("couldn't close %s: %s", utils_fp_name(fp), strerror(errno));
+}
+
+
+/* Panic on failing rename */
+void
+ck_rename (from, to, unlink_if_fail)
+ const char *from, *to;
+ const char *unlink_if_fail;
+{
+ int rd = rename (from, to);
+ if (rd != -1)
+ return;
+
+ if (unlink_if_fail)
+ {
+ int save_errno = errno;
+ errno = 0;
+ unlink (unlink_if_fail);
+
+ /* Failure to remove the temporary file is more severe, so trigger it first. */
+ if (errno != 0)
+ panic (_("cannot remove %s: %s"), unlink_if_fail, strerror (errno));
+
+ errno = save_errno;
+ }
+
+ panic (_("cannot rename %s: %s"), from, strerror (errno));
+}
+
+
+
+
+/* Panic on failing malloc */
+VOID *
+ck_malloc(size)
+ size_t size;
+{
+ VOID *ret = calloc(1, size ? size : 1);
+ if (!ret)
+ panic("couldn't allocate memory");
+ return ret;
+}
+
+/* Panic on failing malloc */
+VOID *
+xmalloc(size)
+ size_t size;
+{
+ return ck_malloc(size);
+}
+
+/* Panic on failing realloc */
+VOID *
+ck_realloc(ptr, size)
+ VOID *ptr;
+ size_t size;
+{
+ VOID *ret;
+
+ if (size == 0)
+ {
+ FREE(ptr);
+ return NULL;
+ }
+ if (!ptr)
+ return ck_malloc(size);
+ ret = realloc(ptr, size);
+ if (!ret)
+ panic("couldn't re-allocate memory");
+ return ret;
+}
+
+/* Return a malloc()'d copy of a string */
+char *
+ck_strdup(str)
+ const char *str;
+{
+ char *ret = MALLOC(strlen(str)+1, char);
+ return strcpy(ret, str);
+}
+
+/* Return a malloc()'d copy of a block of memory */
+VOID *
+ck_memdup(buf, len)
+ const VOID *buf;
+ size_t len;
+{
+ VOID *ret = ck_malloc(len);
+ return memcpy(ret, buf, len);
+}
+
+/* Release a malloc'd block of memory */
+void
+ck_free(ptr)
+ VOID *ptr;
+{
+ if (ptr)
+ free(ptr);
+}
+
+
+/* Implement a variable sized buffer of `stuff'. We don't know what it is,
+nor do we care, as long as it doesn't mind being aligned by malloc. */
+
+struct buffer
+ {
+ size_t allocated;
+ size_t length;
+ char *b;
+ };
+
+#define MIN_ALLOCATE 50
+
+struct buffer *
+init_buffer()
+{
+ struct buffer *b = MALLOC(1, struct buffer);
+ b->b = MALLOC(MIN_ALLOCATE, char);
+ b->allocated = MIN_ALLOCATE;
+ b->length = 0;
+ return b;
+}
+
+char *
+get_buffer(b)
+ struct buffer *b;
+{
+ return b->b;
+}
+
+size_t
+size_buffer(b)
+ struct buffer *b;
+{
+ return b->length;
+}
+
+static void resize_buffer P_((struct buffer *b, size_t newlen));
+static void
+resize_buffer(b, newlen)
+ struct buffer *b;
+ size_t newlen;
+{
+ char *try = NULL;
+ size_t alen = b->allocated;
+
+ if (newlen <= alen)
+ return;
+ alen *= 2;
+ if (newlen < alen)
+ try = realloc(b->b, alen); /* Note: *not* the REALLOC() macro! */
+ if (!try)
+ {
+ alen = newlen;
+ try = REALLOC(b->b, alen, char);
+ }
+ b->allocated = alen;
+ b->b = try;
+}
+
+char *
+add_buffer(b, p, n)
+ struct buffer *b;
+ const char *p;
+ size_t n;
+{
+ char *result;
+ if (b->allocated - b->length < n)
+ resize_buffer(b, b->length+n);
+ result = memcpy(b->b + b->length, p, n);
+ b->length += n;
+ return result;
+}
+
+char *
+add1_buffer(b, c)
+ struct buffer *b;
+ int c;
+{
+ /* This special case should be kept cheap;
+ * don't make it just a mere convenience
+ * wrapper for add_buffer() -- even "builtin"
+ * versions of memcpy(a, b, 1) can become
+ * expensive when called too often.
+ */
+ if (c != EOF)
+ {
+ char *result;
+ if (b->allocated - b->length < 1)
+ resize_buffer(b, b->length+1);
+ result = b->b + b->length++;
+ *result = c;
+ return result;
+ }
+
+ return NULL;
+}
+
+void
+free_buffer(b)
+ struct buffer *b;
+{
+ if (b)
+ FREE(b->b);
+ FREE(b);
+}
generated by cgit v1.2.3 (git 2.39.1) at 2024-05-20 15:22:26 +0000