/* Sysroff object format dumper.
- Copyright (C) 1994, 95, 98, 99, 2000 Free Software Foundation, Inc.
+ Copyright 1994, 1995, 1998, 1999, 2000, 2001, 2002
+ Free Software Foundation, Inc.
This file is part of GNU Binutils.
/* Written by Steve Chamberlain <sac@cygnus.com>.
This program reads a SYSROFF object file and prints it in an
- almost human readable form to stdout. */
+ almost human readable form to stdout. */
#include "bfd.h"
#include "bucomm.h"
+#include "safe-ctype.h"
#include <stdio.h>
-#include <ctype.h>
-#include <libiberty.h>
-#include <getopt.h>
+#include "libiberty.h"
+#include "getopt.h"
#include "sysroff.h"
-#define PROGRAM_VERSION "1.0"
-
static int dump = 1;
static int segmented_p;
static int code;
static int addrsize = 4;
static FILE *file;
+static void dh PARAMS ((unsigned char *, int));
+static void itheader PARAMS ((char *, int));
+static void p PARAMS ((void));
+static void tabout PARAMS ((void));
+static void pbarray PARAMS ((barray *));
+static int getone PARAMS ((int));
+static int opt PARAMS ((int));
+static void must PARAMS ((int));
+static void tab PARAMS ((int, char *));
+static void dump_symbol_info PARAMS ((void));
+static void derived_type PARAMS ((void));
+static void module PARAMS ((void));
+static void show_usage PARAMS ((FILE *, int));
+
+extern char *getCHARS PARAMS ((unsigned char *, int *, int, int));
+extern int fillup PARAMS ((char *));
+extern barray getBARRAY PARAMS ((unsigned char *, int *, int, int));
+extern int getINT PARAMS ((unsigned char *, int *, int, int));
+extern int getBITS PARAMS ((char *, int *, int, int));
+extern void sysroff_swap_tr_in PARAMS ((void));
+extern void sysroff_print_tr_out PARAMS ((void));
+extern int main PARAMS ((int, char **));
+
char *
getCHARS (ptr, idx, size, max)
unsigned char *ptr;
int oc = *idx / 8;
char *r;
int b = size;
+
if (b >= max)
- {
- return "*undefined*";
- }
+ return "*undefined*";
if (b == 0)
{
- /* Got to work out the length of the string from self */
+ /* Got to work out the length of the string from self. */
b = ptr[oc++];
(*idx) += 8;
}
r = xcalloc (b + 1, 1);
memcpy (r, ptr + oc, b);
r[b] = 0;
+
return r;
}
{
for (j = 0; j < span; j++)
{
- if (j + i < size)
+ if (j + i < size)
printf ("%02x ", ptr[i + j]);
- else
- printf (" ");
+ else
+ printf (" ");
}
for (j = 0; j < span && j + i < size; j++)
{
int c = ptr[i + j];
+
if (c < 32 || c > 127)
c = '.';
printf ("%c", c);
}
+
printf ("\n");
}
}
int size;
int sum;
int i;
+
size = getc (file) - 2;
fread (ptr, 1, size, file);
sum = code + size + 2;
+
for (i = 0; i < size; i++)
- {
- sum += ptr[i];
- }
+ sum += ptr[i];
if ((sum & 0xff) != 0xff)
- {
- printf ("SUM IS %x\n", sum);
- }
+ printf ("SUM IS %x\n", sum);
+
if (dump)
dh (ptr, size);
int i;
int byte = *idx / 8;
int size = ptr[byte++];
+
res.len = size;
res.data = (unsigned char *) xmalloc (size);
+
for (i = 0; i < size; i++)
- {
- res.data[i] = ptr[byte++];
- }
+ res.data[i] = ptr[byte++];
+
return res;
}
int byte = *idx / 8;
if (byte >= max)
- {
- return 0;
- }
+ return 0;
+
if (size == -2)
size = addrsize;
+
if (size == -1)
size = 0;
+
switch (size)
{
case 0:
default:
abort ();
}
+
*idx += size * 8;
return n;
}
}
static int indent;
+
static void
p ()
{
int i;
+
for (i = 0; i < indent; i++)
- {
- printf ("| ");
- }
+ printf ("| ");
+
printf ("> ");
}
barray *y;
{
int x;
+
printf ("%d (", y->len);
+
for (x = 0; x < y->len; x++)
- {
- printf ("(%02x %c)", y->data[x], isprint (y->data[x]) ? y->data[x] : '.');
- }
+ printf ("(%02x %c)", y->data[x],
+ ISPRINT (y->data[x]) ? y->data[x] : '.');
+
printf (")\n");
}
#include "sysroff.c"
-/*
- * FIXME: sysinfo, which generates sysroff.[ch] from sysroff.info, can't
- * hack the special case of the tr block, which has no contents. So we
- * implement our own functions for reading in and printing out the tr
- * block.
- */
+/* FIXME: sysinfo, which generates sysroff.[ch] from sysroff.info, can't
+ hack the special case of the tr block, which has no contents. So we
+ implement our own functions for reading in and printing out the tr
+ block. */
#define IT_tr_CODE 0x7f
+
void
sysroff_swap_tr_in()
{
- char raw[255];
+ char raw[255];
- memset(raw, 0, 255);
- fillup(raw);
+ memset (raw, 0, 255);
+ fillup (raw);
}
void
sysroff_print_tr_out()
{
- itheader("tr", IT_tr_CODE);
+ itheader ("tr", IT_tr_CODE);
}
static int
int type;
{
int c = getc (file);
+
code = c;
if ((c & 0x7f) != type)
sysroff_print_cs_out (&dummy);
}
break;
+
case IT_dln_CODE:
{
struct IT_dln dummy;
sysroff_print_dln_out (&dummy);
}
break;
+
case IT_hd_CODE:
{
struct IT_hd dummy;
sysroff_print_hd_out (&dummy);
}
break;
+
case IT_dar_CODE:
{
struct IT_dar dummy;
sysroff_print_dar_out (&dummy);
}
break;
+
case IT_dsy_CODE:
{
struct IT_dsy dummy;
sysroff_print_dsy_out (&dummy);
}
break;
+
case IT_dfp_CODE:
{
struct IT_dfp dummy;
sysroff_print_dfp_out (&dummy);
}
break;
+
case IT_dso_CODE:
{
struct IT_dso dummy;
sysroff_print_dso_out (&dummy);
}
break;
+
case IT_dpt_CODE:
{
struct IT_dpt dummy;
sysroff_print_dpt_out (&dummy);
}
break;
+
case IT_den_CODE:
{
struct IT_den dummy;
sysroff_print_den_out (&dummy);
}
break;
+
case IT_dbt_CODE:
{
struct IT_dbt dummy;
sysroff_print_dbt_out (&dummy);
}
break;
+
case IT_dty_CODE:
{
struct IT_dty dummy;
sysroff_print_dty_out (&dummy);
}
break;
+
case IT_un_CODE:
{
struct IT_un dummy;
sysroff_print_un_out (&dummy);
}
break;
+
case IT_sc_CODE:
{
struct IT_sc dummy;
sysroff_print_sc_out (&dummy);
}
break;
+
case IT_er_CODE:
{
struct IT_er dummy;
sysroff_print_er_out (&dummy);
}
break;
+
case IT_ed_CODE:
{
struct IT_ed dummy;
sysroff_print_ed_out (&dummy);
}
break;
+
case IT_sh_CODE:
{
struct IT_sh dummy;
sysroff_print_sh_out (&dummy);
}
break;
+
case IT_ob_CODE:
{
struct IT_ob dummy;
sysroff_print_ob_out (&dummy);
}
break;
+
case IT_rl_CODE:
{
struct IT_rl dummy;
sysroff_print_rl_out (&dummy);
}
break;
+
case IT_du_CODE:
{
struct IT_du dummy;
sysroff_print_du_out (&dummy);
}
break;
+
case IT_dus_CODE:
{
struct IT_dus dummy;
sysroff_print_dus_out (&dummy);
}
break;
+
case IT_dul_CODE:
{
struct IT_dul dummy;
sysroff_print_dul_out (&dummy);
}
break;
+
case IT_dss_CODE:
{
struct IT_dss dummy;
sysroff_print_dss_out (&dummy);
}
break;
+
case IT_hs_CODE:
{
struct IT_hs dummy;
sysroff_print_hs_out (&dummy);
}
break;
+
case IT_dps_CODE:
{
struct IT_dps dummy;
sysroff_print_dps_out (&dummy);
}
break;
+
case IT_tr_CODE:
- {
- sysroff_swap_tr_in ();
- sysroff_print_tr_out ();
- }
+ sysroff_swap_tr_in ();
+ sysroff_print_tr_out ();
break;
+
case IT_dds_CODE:
{
struct IT_dds dummy;
+
sysroff_swap_dds_in (&dummy);
sysroff_print_dds_out (&dummy);
}
break;
+
default:
printf ("GOT A %x\n", c);
return 0;
break;
}
+
return 1;
}
int x;
{
if (!getone (x))
- {
- printf ("WANTED %x!!\n", x);
- }
+ printf ("WANTED %x!!\n", x);
}
static void
char *s;
{
indent += i;
+
if (s)
{
p ();
}
}
-static void derived_type ();
-
static void
dump_symbol_info ()
{
tab (1, "SYMBOL INFO");
+
while (opt (IT_dsy_CODE))
{
if (opt (IT_dty_CODE))
must (IT_dty_CODE);
}
}
+
tab (-1, "");
}
derived_type ()
{
tab (1, "DERIVED TYPE");
+
while (1)
{
if (opt (IT_dpp_CODE))
FILE *file;
int status;
{
- fprintf (file, _("Usage: %s [-hV] in-file\n"), program_name);
+ fprintf (file, _("Usage: %s [option(s)] in-file\n"), program_name);
+ fprintf (file, _("Print a human readable interpretation of a SYSROFF object file\n"));
+ fprintf (file, _(" The options are:\n\
+ -h --help Display this information\n\
+ -v --version Print the program's version number\n"));
+
+ if (status == 0)
+ fprintf (file, _("Report bugs to %s\n"), REPORT_BUGS_TO);
exit (status);
}
-static void
-show_help ()
-{
- printf (_("%s: Print a human readable interpretation of a SYSROFF object file\n"),
- program_name);
- show_usage (stdout, 0);
-}
-
int
main (ac, av)
int ac;
#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
setlocale (LC_MESSAGES, "");
+#endif
+#if defined (HAVE_SETLOCALE)
+ setlocale (LC_CTYPE, "");
#endif
bindtextdomain (PACKAGE, LOCALEDIR);
textdomain (PACKAGE);
program_name = av[0];
xmalloc_set_program_name (program_name);
- while ((opt = getopt_long (ac, av, "hV", long_options, (int *) NULL)) != EOF)
+ while ((opt = getopt_long (ac, av, "HhVv", long_options, (int *) NULL)) != EOF)
{
switch (opt)
{
+ case 'H':
case 'h':
- show_help ();
+ show_usage (stdout, 0);
/*NOTREACHED*/
+ case 'v':
case 'V':
- printf (_("GNU %s version %s\n"), program_name, PROGRAM_VERSION);
+ print_version ("sysdump");
exit (0);
/*NOTREACHED*/
case 0:
/* The input and output files may be named on the command line. */
if (optind < ac)
- {
- input_file = av[optind];
- }
+ input_file = av[optind];
if (!input_file)
- {
- fatal (_("no input file specified"));
- }
+ fatal (_("no input file specified"));
file = fopen (input_file, FOPEN_RB);
+
if (!file)
- {
- fatal (_("cannot open input file %s"), input_file);
- }
+ fatal (_("cannot open input file %s"), input_file);
module ();
return 0;
projects / deliverable / binutils-gdb.git / blobdiff