summaryrefslogtreecommitdiffstats
path: root/c/src/lib/libbsp/hppa1.1/simhppa/tools/print_dump.c
diff options
context:
space:
mode:
Diffstat (limited to 'c/src/lib/libbsp/hppa1.1/simhppa/tools/print_dump.c')
-rw-r--r--c/src/lib/libbsp/hppa1.1/simhppa/tools/print_dump.c332
1 files changed, 332 insertions, 0 deletions
diff --git a/c/src/lib/libbsp/hppa1.1/simhppa/tools/print_dump.c b/c/src/lib/libbsp/hppa1.1/simhppa/tools/print_dump.c
new file mode 100644
index 0000000000..8b4313166a
--- /dev/null
+++ b/c/src/lib/libbsp/hppa1.1/simhppa/tools/print_dump.c
@@ -0,0 +1,332 @@
+/*
+ * print_dump
+ *
+ * $Id$
+ *
+ * COPYRIGHT (c) 1994 by Division Incorporated
+ *
+ * To anyone who acknowledges that this file is provided "AS IS"
+ * without any express or implied warranty:
+ * permission to use, copy, modify, and distribute this file
+ * for any purpose is hereby granted without fee, provided that
+ * the above copyright notice and this notice appears in all
+ * copies, and that the name of Division Incorporated not be
+ * used in advertising or publicity pertaining to distribution
+ * of the software without specific, written prior permission.
+ * Division Incorporated makes no representations about the
+ * suitability of this software for any purpose.
+ */
+
+#define GETOPTARGS "v"
+
+char *USAGE = "\
+usage: print_dump [ -v ] \n\
+ -v -- verbose\n\
+ Reads HP simulator 'memdump' output of 'print_buffer' structure
+ on stdin. Dumps it out in vanilla ASCII.
+";
+
+#include <stdio.h>
+#include <fcntl.h>
+#include <ctype.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <memory.h>
+#include <stdarg.h>
+
+#define Failed(x) (((int) (x)) == -1)
+#define TRUE 1
+#define FALSE 0
+#define STREQ(a,b) (strcmp(a,b) == 0)
+#define NUMELEMS(arr) (sizeof(arr) / sizeof(arr[0]))
+
+/*
+ * Definitions for unsigned "ints"; especially for use in data structures
+ * that will be shared among (potentially) different cpu's (we punt on
+ * byte ordering problems tho)
+ */
+
+typedef unsigned char u8;
+typedef unsigned short u16;
+typedef unsigned int u32;
+
+typedef union uval {
+ u8 uv_chars[4];
+ u16 uv_words[2];
+ u32 uv_long;
+ void *uv_ptr[sizeof(long) / sizeof(void *)];
+} uval_t;
+
+
+/*
+ * vars controlled by command line options
+ */
+
+int verbose = FALSE; /* be verbose */
+
+extern char *optarg; /* getopt(3) control vars */
+extern int optind, opterr;
+extern int errno;
+
+char *progname; /* for error() */
+
+void error(int errn, ...);
+
+#define ERR_ERRNO (1<<((sizeof(int) * 8) - 2)) /* hi bit; use 'errno' */
+#define ERR_FATAL (ERR_ERRNO / 2) /* error is fatal; no return */
+#define ERR_ABORT (ERR_ERRNO / 4) /* error is fatal; abort */
+#define ERR_MASK (ERR_ERRNO | ERR_FATAL | ERR_ABORT) /* all */
+
+int process(void);
+void prchar(unsigned int ch);
+
+
+int
+main(int argc, char **argv, char **env)
+{
+ register int c;
+ int showusage = FALSE; /* usage error? */
+
+ /*
+ * figure out invocation leaf-name
+ */
+
+ if ((progname = strrchr(argv[0], '/')) == (char *) NULL)
+ progname = argv[0];
+ else
+ progname++;
+
+ argv[0] = progname; /* for getopt err reporting */
+
+ /*
+ * Check options and arguments.
+ */
+
+ opterr = 0; /* we'll report all errors */
+ while ((c = getopt(argc, argv, GETOPTARGS)) != EOF)
+ switch (c)
+ {
+ case 'v': /* toggle verbose */
+ verbose = ! verbose;
+ break;
+
+ case '?':
+ showusage = TRUE;
+ }
+
+ if (showusage)
+ {
+ (void) fprintf(stderr, "%s", USAGE);
+ exit(1);
+ }
+
+ return process();
+}
+
+
+/*
+ * process(arg)
+ *
+ * Input looks like this
+ *
+ * Starting address: 00000001.480035a0
+ * -----------------------------------
+
++0000 / 0d0a0d0a 2a2a2a20 53454d20 54455354 202d2d20 4e4f4445 2032202a 2a2a0d0a
++0020 / 73703a20 30783433 30303030 31300d0a 30783438 30613161 38383a20 676f7420
+ ....
++0b40 / xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx
+
+ *
+ * The 'xxxxxxxxx' shows up if the page has not been allocated.
+ */
+
+int
+process(void)
+{
+ uval_t b[8];
+ u32 ignore;
+ char *p;
+ int i;
+ int failed_once;
+
+ char line[1024];
+
+#define PRINT_BUFFER_SIZE (16 * 1024)
+ struct {
+ int index;
+ int size;
+ u8 buffer[PRINT_BUFFER_SIZE];
+ } print_buffer;
+
+ /* we stuff the data into print_buffer using memcpy() */
+ p = (char *) &print_buffer;
+
+ failed_once = 0;
+
+ while (gets(line))
+ {
+ char *cp;
+
+ /* hack; deal with the 'xxxxxxxx' problem noted above */
+ for (cp=line; *cp; cp++)
+ if (*cp == 'x')
+ *cp = '0';
+
+ if (*line != '+')
+ continue;
+ if (sscanf(line, "+%x / %x %x %x %x %x %x %x %x\n",
+ &ignore,
+ &b[0].uv_long,
+ &b[1].uv_long,
+ &b[2].uv_long,
+ &b[3].uv_long,
+ &b[4].uv_long,
+ &b[5].uv_long,
+ &b[6].uv_long,
+ &b[7].uv_long) != 9)
+ {
+ if (failed_once)
+ error(ERR_FATAL, "2nd format problem; giving up");
+ error(0, "format problem in line: `%s`", line);
+ failed_once = 1;
+ }
+
+ memcpy((void *) p, (void *) b, sizeof(b));
+ p += sizeof(b);
+ }
+
+ if (verbose)
+ printf("buffer size: %d\n", print_buffer.size);
+
+ if (print_buffer.size < 0)
+ error(ERR_FATAL, "size is too small");
+
+ if (print_buffer.size != sizeof(print_buffer.buffer))
+ {
+ error(ERR_FATAL, "buffer size mismatch, expected %d",
+ sizeof(print_buffer.buffer));
+ /* XXX we really should just dynamically allocate the buffer */
+ }
+
+ i = print_buffer.index + 1;
+ while (i != print_buffer.index)
+ {
+ unsigned int c;
+ c = print_buffer.buffer[i++];
+ if (c && (c != '\r'))
+ prchar(c);
+ i %= print_buffer.size;
+ }
+ printf("\n");
+ return 0;
+}
+
+/* de-controlify */
+char *de_control[] = {
+ "^@", "^A", "^B", "^C", "^D", "^E", "^F", "^G", "^H", "^I", "^J", "^K",
+ "^L", "^M", "^N", "^O", "^P", "^Q", "^R", "^S", "^T", "^U", "^V", "^W",
+ "^X", "^Y", "^Z", "^[", "^\\", "^]", "^~", "^_",
+ " ", "!", "\"", "#", "$", "%", "&", "'", "(", ")", "*", "+", ",", "-",
+ ".", "/", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", ":", ";",
+ "<", "=", ">", "?", "@", "A", "B", "C", "D", "E", "F", "G", "H", "I",
+ "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W",
+ "X", "Y", "Z", "[", "\\", "]", "^", "_", "`", "a", "b", "c", "d", "e",
+ "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s",
+ "t", "u", "v", "w", "x", "y", "z", "{", "|", "}", "~", "^?",
+ "M-^@", "M-^A", "M-^B", "M-^C", "M-^D", "M-^E", "M-^F", "M-^G",
+ "M-^H", "M-^I", "M-^J", "M-^K", "M-^L", "M-^M", "M-^N", "M-^O",
+ "M-^P", "M-^Q", "M-^R", "M-^S", "M-^T", "M-^U", "M-^V", "M-^W",
+ "M-^X", "M-^Y", "M-^Z", "M-^[", "M-^\\", "M-^]", "M-^~", "M-^_",
+ "M- ", "M-!", "M-\"", "M-#", "M-$", "M-%", "M-&", "M-'",
+ "M-(", "M-)", "M-*", "M-+", "M-,", "M--", "M-.", "M-/",
+ "M-0", "M-1", "M-2", "M-3", "M-4", "M-5", "M-6", "M-7",
+ "M-8", "M-9", "M-:", "M-;", "M-<", "M-=", "M->", "M-?",
+ "M-@", "M-A", "M-B", "M-C", "M-D", "M-E", "M-F", "M-G",
+ "M-H", "M-I", "M-J", "M-K", "M-L", "M-M", "M-N", "M-O",
+ "M-P", "M-Q", "M-R", "M-S", "M-T", "M-U", "M-V", "M-W",
+ "M-X", "M-Y", "M-Z", "M-[", "M-\\", "M-]", "M-^", "M-_",
+ "M-`", "M-a", "M-b", "M-c", "M-d", "M-e", "M-f", "M-g",
+ "M-h", "M-i", "M-j", "M-k", "M-l", "M-m", "M-n", "M-o",
+ "M-p", "M-q", "M-r", "M-s", "M-t", "M-u", "M-v", "M-w",
+ "M-x", "M-y", "M-z", "M-{", "M-|", "M-}", "M-~", "M-^?"
+};
+
+/*
+ * prchar(ch); print ch in a readable format, ie ^X or X or ~^X or DEL, etc.
+ */
+
+void
+prchar(unsigned int ch)
+{
+ if (isprint(ch) || isspace(ch))
+ putchar(ch);
+ else
+ printf("%s", de_control[ch]);
+}
+
+
+/*
+ * error(errn, arglist)
+ * report an error to stderr using printf(3) conventions.
+ * Any output is preceded by '<progname>: '
+ *
+ * Uses ERR_EXIT bit to request exit(errn)
+ * ERR_ABORT to request abort()
+ * ERR_ERRNO to indicate use of errno instead of argument.
+ *
+ * If resulting 'errn' is non-zero, it is assumed to be an 'errno' and its
+ * associated error message is appended to the output.
+ */
+
+/*VARARGS*/
+
+void
+error(int error_flag, ...)
+{
+ va_list arglist;
+ register char *format;
+ extern char *sys_errlist[];
+ extern int sys_nerr;
+ int local_errno;
+
+ extern int errno;
+
+ (void) fflush(stdout); /* in case stdout/stderr same */
+
+ local_errno = error_flag & ~ERR_MASK;
+ if (error_flag & ERR_ERRNO) /* use errno? */
+ local_errno = errno;
+
+ va_start(arglist, error_flag);
+ format = va_arg(arglist, char *);
+ (void) fprintf(stderr, "%s: ", progname);
+ (void) vfprintf(stderr, format, arglist);
+ va_end(arglist);
+
+ if (local_errno)
+ if ((local_errno > 0) && (local_errno < sys_nerr))
+ (void) fprintf(stderr, " (%s)\n", sys_errlist[local_errno]);
+ else
+ (void) fprintf(stderr, " (unknown errno=%d)\n", local_errno);
+ else
+ (void) fprintf(stderr, "\n");
+
+ (void) fflush(stderr);
+
+ if (error_flag & (ERR_FATAL | ERR_ABORT))
+ {
+ if (error_flag & ERR_FATAL)
+ {
+ error(0, local_errno ? "fatal error, exiting" : "exiting");
+ exit(local_errno);
+ }
+ else
+ {
+ error(0, "fatal error, aborting");
+ abort();
+ }
+ }
+}
+
generated by cgit v1.2.3 (git 2.25.1) at 2024-04-25 04:04:30 +0000