/* Sysroff object format dumper.
|
/* Sysroff object format dumper.
|
Copyright 1994, 1995, 1998, 1999, 2000, 2001, 2002, 2003, 2005, 2007
|
Copyright 1994, 1995, 1998, 1999, 2000, 2001, 2002, 2003, 2005, 2007
|
Free Software Foundation, Inc.
|
Free Software Foundation, Inc.
|
|
|
This file is part of GNU Binutils.
|
This file is part of GNU Binutils.
|
|
|
This program is free software; you can redistribute it and/or modify
|
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
|
it under the terms of the GNU General Public License as published by
|
the Free Software Foundation; either version 3 of the License, or
|
the Free Software Foundation; either version 3 of the License, or
|
(at your option) any later version.
|
(at your option) any later version.
|
|
|
This program is distributed in the hope that it will be useful,
|
This program is distributed in the hope that it will be useful,
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
GNU General Public License for more details.
|
GNU General Public License for more details.
|
|
|
You should have received a copy of the GNU General Public License
|
You should have received a copy of the GNU General Public License
|
along with this program; if not, write to the Free Software
|
along with this program; if not, write to the Free Software
|
Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
|
Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
|
02110-1301, USA. */
|
02110-1301, USA. */
|
|
|
|
|
/* Written by Steve Chamberlain <sac@cygnus.com>.
|
/* Written by Steve Chamberlain <sac@cygnus.com>.
|
|
|
This program reads a SYSROFF object file and prints it in an
|
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 "sysdep.h"
|
#include "sysdep.h"
|
#include "bfd.h"
|
#include "bfd.h"
|
#include "safe-ctype.h"
|
#include "safe-ctype.h"
|
#include "libiberty.h"
|
#include "libiberty.h"
|
#include "getopt.h"
|
#include "getopt.h"
|
#include "bucomm.h"
|
#include "bucomm.h"
|
#include "sysroff.h"
|
#include "sysroff.h"
|
|
|
static int dump = 1;
|
static int dump = 1;
|
static int segmented_p;
|
static int segmented_p;
|
static int code;
|
static int code;
|
static int addrsize = 4;
|
static int addrsize = 4;
|
static FILE *file;
|
static FILE *file;
|
|
|
static void dh (unsigned char *, int);
|
static void dh (unsigned char *, int);
|
static void itheader (char *, int);
|
static void itheader (char *, int);
|
static void p (void);
|
static void p (void);
|
static void tabout (void);
|
static void tabout (void);
|
static void pbarray (barray *);
|
static void pbarray (barray *);
|
static int getone (int);
|
static int getone (int);
|
static int opt (int);
|
static int opt (int);
|
static void must (int);
|
static void must (int);
|
static void tab (int, char *);
|
static void tab (int, char *);
|
static void dump_symbol_info (void);
|
static void dump_symbol_info (void);
|
static void derived_type (void);
|
static void derived_type (void);
|
static void module (void);
|
static void module (void);
|
static void show_usage (FILE *, int);
|
static void show_usage (FILE *, int);
|
|
|
extern int main (int, char **);
|
extern int main (int, char **);
|
|
|
static char *
|
static char *
|
getCHARS (unsigned char *ptr, int *idx, int size, int max)
|
getCHARS (unsigned char *ptr, int *idx, int size, int max)
|
{
|
{
|
int oc = *idx / 8;
|
int oc = *idx / 8;
|
char *r;
|
char *r;
|
int b = size;
|
int b = size;
|
|
|
if (b >= max)
|
if (b >= max)
|
return "*undefined*";
|
return "*undefined*";
|
|
|
if (b == 0)
|
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++];
|
b = ptr[oc++];
|
(*idx) += 8;
|
(*idx) += 8;
|
}
|
}
|
|
|
*idx += b * 8;
|
*idx += b * 8;
|
r = xcalloc (b + 1, 1);
|
r = xcalloc (b + 1, 1);
|
memcpy (r, ptr + oc, b);
|
memcpy (r, ptr + oc, b);
|
r[b] = 0;
|
r[b] = 0;
|
|
|
return r;
|
return r;
|
}
|
}
|
|
|
static void
|
static void
|
dh (unsigned char *ptr, int size)
|
dh (unsigned char *ptr, int size)
|
{
|
{
|
int i;
|
int i;
|
int j;
|
int j;
|
int span = 16;
|
int span = 16;
|
|
|
printf ("\n************************************************************\n");
|
printf ("\n************************************************************\n");
|
|
|
for (i = 0; i < size; i += span)
|
for (i = 0; i < size; i += span)
|
{
|
{
|
for (j = 0; j < span; j++)
|
for (j = 0; j < span; j++)
|
{
|
{
|
if (j + i < size)
|
if (j + i < size)
|
printf ("%02x ", ptr[i + j]);
|
printf ("%02x ", ptr[i + j]);
|
else
|
else
|
printf (" ");
|
printf (" ");
|
}
|
}
|
|
|
for (j = 0; j < span && j + i < size; j++)
|
for (j = 0; j < span && j + i < size; j++)
|
{
|
{
|
int c = ptr[i + j];
|
int c = ptr[i + j];
|
|
|
if (c < 32 || c > 127)
|
if (c < 32 || c > 127)
|
c = '.';
|
c = '.';
|
printf ("%c", c);
|
printf ("%c", c);
|
}
|
}
|
|
|
printf ("\n");
|
printf ("\n");
|
}
|
}
|
}
|
}
|
|
|
static int
|
static int
|
fillup (unsigned char *ptr)
|
fillup (unsigned char *ptr)
|
{
|
{
|
int size;
|
int size;
|
int sum;
|
int sum;
|
int i;
|
int i;
|
|
|
size = getc (file);
|
size = getc (file);
|
if (size == EOF
|
if (size == EOF
|
|| size <= 2)
|
|| size <= 2)
|
return 0;
|
return 0;
|
|
|
size -= 2;
|
size -= 2;
|
if (fread (ptr, size, 1, file) != 1)
|
if (fread (ptr, size, 1, file) != 1)
|
return 0;
|
return 0;
|
|
|
sum = code + size + 2;
|
sum = code + size + 2;
|
|
|
for (i = 0; i < size; i++)
|
for (i = 0; i < size; i++)
|
sum += ptr[i];
|
sum += ptr[i];
|
|
|
if ((sum & 0xff) != 0xff)
|
if ((sum & 0xff) != 0xff)
|
printf ("SUM IS %x\n", sum);
|
printf ("SUM IS %x\n", sum);
|
|
|
if (dump)
|
if (dump)
|
dh (ptr, size);
|
dh (ptr, size);
|
|
|
return size;
|
return size;
|
}
|
}
|
|
|
static barray
|
static barray
|
getBARRAY (unsigned char *ptr, int *idx, int dsize ATTRIBUTE_UNUSED,
|
getBARRAY (unsigned char *ptr, int *idx, int dsize ATTRIBUTE_UNUSED,
|
int max ATTRIBUTE_UNUSED)
|
int max ATTRIBUTE_UNUSED)
|
{
|
{
|
barray res;
|
barray res;
|
int i;
|
int i;
|
int byte = *idx / 8;
|
int byte = *idx / 8;
|
int size = ptr[byte++];
|
int size = ptr[byte++];
|
|
|
res.len = size;
|
res.len = size;
|
res.data = (unsigned char *) xmalloc (size);
|
res.data = (unsigned char *) xmalloc (size);
|
|
|
for (i = 0; i < size; i++)
|
for (i = 0; i < size; i++)
|
res.data[i] = ptr[byte++];
|
res.data[i] = ptr[byte++];
|
|
|
return res;
|
return res;
|
}
|
}
|
|
|
static int
|
static int
|
getINT (unsigned char *ptr, int *idx, int size, int max)
|
getINT (unsigned char *ptr, int *idx, int size, int max)
|
{
|
{
|
int n = 0;
|
int n = 0;
|
int byte = *idx / 8;
|
int byte = *idx / 8;
|
|
|
if (byte >= max)
|
if (byte >= max)
|
return 0;
|
return 0;
|
|
|
if (size == -2)
|
if (size == -2)
|
size = addrsize;
|
size = addrsize;
|
|
|
if (size == -1)
|
if (size == -1)
|
size = 0;
|
size = 0;
|
|
|
switch (size)
|
switch (size)
|
{
|
{
|
case 0:
|
case 0:
|
return 0;
|
return 0;
|
case 1:
|
case 1:
|
n = (ptr[byte]);
|
n = (ptr[byte]);
|
break;
|
break;
|
case 2:
|
case 2:
|
n = (ptr[byte + 0] << 8) + ptr[byte + 1];
|
n = (ptr[byte + 0] << 8) + ptr[byte + 1];
|
break;
|
break;
|
case 4:
|
case 4:
|
n = (ptr[byte + 0] << 24) + (ptr[byte + 1] << 16) + (ptr[byte + 2] << 8) + (ptr[byte + 3]);
|
n = (ptr[byte + 0] << 24) + (ptr[byte + 1] << 16) + (ptr[byte + 2] << 8) + (ptr[byte + 3]);
|
break;
|
break;
|
default:
|
default:
|
abort ();
|
abort ();
|
}
|
}
|
|
|
*idx += size * 8;
|
*idx += size * 8;
|
return n;
|
return n;
|
}
|
}
|
|
|
static int
|
static int
|
getBITS (unsigned char *ptr, int *idx, int size, int max)
|
getBITS (unsigned char *ptr, int *idx, int size, int max)
|
{
|
{
|
int byte = *idx / 8;
|
int byte = *idx / 8;
|
int bit = *idx % 8;
|
int bit = *idx % 8;
|
|
|
if (byte >= max)
|
if (byte >= max)
|
return 0;
|
return 0;
|
|
|
*idx += size;
|
*idx += size;
|
|
|
return (ptr[byte] >> (8 - bit - size)) & ((1 << size) - 1);
|
return (ptr[byte] >> (8 - bit - size)) & ((1 << size) - 1);
|
}
|
}
|
|
|
static void
|
static void
|
itheader (char *name, int code)
|
itheader (char *name, int code)
|
{
|
{
|
printf ("\n%s 0x%02x\n", name, code);
|
printf ("\n%s 0x%02x\n", name, code);
|
}
|
}
|
|
|
static int indent;
|
static int indent;
|
|
|
static void
|
static void
|
p (void)
|
p (void)
|
{
|
{
|
int i;
|
int i;
|
|
|
for (i = 0; i < indent; i++)
|
for (i = 0; i < indent; i++)
|
printf ("| ");
|
printf ("| ");
|
|
|
printf ("> ");
|
printf ("> ");
|
}
|
}
|
|
|
static void
|
static void
|
tabout (void)
|
tabout (void)
|
{
|
{
|
p ();
|
p ();
|
}
|
}
|
|
|
static void
|
static void
|
pbarray (barray *y)
|
pbarray (barray *y)
|
{
|
{
|
int x;
|
int x;
|
|
|
printf ("%d (", y->len);
|
printf ("%d (", y->len);
|
|
|
for (x = 0; x < y->len; x++)
|
for (x = 0; x < y->len; x++)
|
printf ("(%02x %c)", y->data[x],
|
printf ("(%02x %c)", y->data[x],
|
ISPRINT (y->data[x]) ? y->data[x] : '.');
|
ISPRINT (y->data[x]) ? y->data[x] : '.');
|
|
|
printf (")\n");
|
printf (")\n");
|
}
|
}
|
|
|
#define SYSROFF_PRINT
|
#define SYSROFF_PRINT
|
#define SYSROFF_SWAP_IN
|
#define SYSROFF_SWAP_IN
|
|
|
#include "sysroff.c"
|
#include "sysroff.c"
|
|
|
/* FIXME: sysinfo, which generates sysroff.[ch] from sysroff.info, can't
|
/* 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
|
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
|
implement our own functions for reading in and printing out the tr
|
block. */
|
block. */
|
|
|
#define IT_tr_CODE 0x7f
|
#define IT_tr_CODE 0x7f
|
|
|
static void
|
static void
|
sysroff_swap_tr_in (void)
|
sysroff_swap_tr_in (void)
|
{
|
{
|
unsigned char raw[255];
|
unsigned char raw[255];
|
|
|
memset (raw, 0, 255);
|
memset (raw, 0, 255);
|
fillup (raw);
|
fillup (raw);
|
}
|
}
|
|
|
static void
|
static void
|
sysroff_print_tr_out (void)
|
sysroff_print_tr_out (void)
|
{
|
{
|
itheader ("tr", IT_tr_CODE);
|
itheader ("tr", IT_tr_CODE);
|
}
|
}
|
|
|
static int
|
static int
|
getone (int type)
|
getone (int type)
|
{
|
{
|
int c = getc (file);
|
int c = getc (file);
|
|
|
code = c;
|
code = c;
|
|
|
if ((c & 0x7f) != type)
|
if ((c & 0x7f) != type)
|
{
|
{
|
ungetc (c, file);
|
ungetc (c, file);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
switch (c & 0x7f)
|
switch (c & 0x7f)
|
{
|
{
|
case IT_cs_CODE:
|
case IT_cs_CODE:
|
{
|
{
|
struct IT_cs dummy;
|
struct IT_cs dummy;
|
sysroff_swap_cs_in (&dummy);
|
sysroff_swap_cs_in (&dummy);
|
sysroff_print_cs_out (&dummy);
|
sysroff_print_cs_out (&dummy);
|
}
|
}
|
break;
|
break;
|
|
|
case IT_dln_CODE:
|
case IT_dln_CODE:
|
{
|
{
|
struct IT_dln dummy;
|
struct IT_dln dummy;
|
sysroff_swap_dln_in (&dummy);
|
sysroff_swap_dln_in (&dummy);
|
sysroff_print_dln_out (&dummy);
|
sysroff_print_dln_out (&dummy);
|
}
|
}
|
break;
|
break;
|
|
|
case IT_hd_CODE:
|
case IT_hd_CODE:
|
{
|
{
|
struct IT_hd dummy;
|
struct IT_hd dummy;
|
sysroff_swap_hd_in (&dummy);
|
sysroff_swap_hd_in (&dummy);
|
addrsize = dummy.afl;
|
addrsize = dummy.afl;
|
sysroff_print_hd_out (&dummy);
|
sysroff_print_hd_out (&dummy);
|
}
|
}
|
break;
|
break;
|
|
|
case IT_dar_CODE:
|
case IT_dar_CODE:
|
{
|
{
|
struct IT_dar dummy;
|
struct IT_dar dummy;
|
sysroff_swap_dar_in (&dummy);
|
sysroff_swap_dar_in (&dummy);
|
sysroff_print_dar_out (&dummy);
|
sysroff_print_dar_out (&dummy);
|
}
|
}
|
break;
|
break;
|
|
|
case IT_dsy_CODE:
|
case IT_dsy_CODE:
|
{
|
{
|
struct IT_dsy dummy;
|
struct IT_dsy dummy;
|
sysroff_swap_dsy_in (&dummy);
|
sysroff_swap_dsy_in (&dummy);
|
sysroff_print_dsy_out (&dummy);
|
sysroff_print_dsy_out (&dummy);
|
}
|
}
|
break;
|
break;
|
|
|
case IT_dfp_CODE:
|
case IT_dfp_CODE:
|
{
|
{
|
struct IT_dfp dummy;
|
struct IT_dfp dummy;
|
sysroff_swap_dfp_in (&dummy);
|
sysroff_swap_dfp_in (&dummy);
|
sysroff_print_dfp_out (&dummy);
|
sysroff_print_dfp_out (&dummy);
|
}
|
}
|
break;
|
break;
|
|
|
case IT_dso_CODE:
|
case IT_dso_CODE:
|
{
|
{
|
struct IT_dso dummy;
|
struct IT_dso dummy;
|
sysroff_swap_dso_in (&dummy);
|
sysroff_swap_dso_in (&dummy);
|
sysroff_print_dso_out (&dummy);
|
sysroff_print_dso_out (&dummy);
|
}
|
}
|
break;
|
break;
|
|
|
case IT_dpt_CODE:
|
case IT_dpt_CODE:
|
{
|
{
|
struct IT_dpt dummy;
|
struct IT_dpt dummy;
|
sysroff_swap_dpt_in (&dummy);
|
sysroff_swap_dpt_in (&dummy);
|
sysroff_print_dpt_out (&dummy);
|
sysroff_print_dpt_out (&dummy);
|
}
|
}
|
break;
|
break;
|
|
|
case IT_den_CODE:
|
case IT_den_CODE:
|
{
|
{
|
struct IT_den dummy;
|
struct IT_den dummy;
|
sysroff_swap_den_in (&dummy);
|
sysroff_swap_den_in (&dummy);
|
sysroff_print_den_out (&dummy);
|
sysroff_print_den_out (&dummy);
|
}
|
}
|
break;
|
break;
|
|
|
case IT_dbt_CODE:
|
case IT_dbt_CODE:
|
{
|
{
|
struct IT_dbt dummy;
|
struct IT_dbt dummy;
|
sysroff_swap_dbt_in (&dummy);
|
sysroff_swap_dbt_in (&dummy);
|
sysroff_print_dbt_out (&dummy);
|
sysroff_print_dbt_out (&dummy);
|
}
|
}
|
break;
|
break;
|
|
|
case IT_dty_CODE:
|
case IT_dty_CODE:
|
{
|
{
|
struct IT_dty dummy;
|
struct IT_dty dummy;
|
sysroff_swap_dty_in (&dummy);
|
sysroff_swap_dty_in (&dummy);
|
sysroff_print_dty_out (&dummy);
|
sysroff_print_dty_out (&dummy);
|
}
|
}
|
break;
|
break;
|
|
|
case IT_un_CODE:
|
case IT_un_CODE:
|
{
|
{
|
struct IT_un dummy;
|
struct IT_un dummy;
|
sysroff_swap_un_in (&dummy);
|
sysroff_swap_un_in (&dummy);
|
sysroff_print_un_out (&dummy);
|
sysroff_print_un_out (&dummy);
|
}
|
}
|
break;
|
break;
|
|
|
case IT_sc_CODE:
|
case IT_sc_CODE:
|
{
|
{
|
struct IT_sc dummy;
|
struct IT_sc dummy;
|
sysroff_swap_sc_in (&dummy);
|
sysroff_swap_sc_in (&dummy);
|
sysroff_print_sc_out (&dummy);
|
sysroff_print_sc_out (&dummy);
|
}
|
}
|
break;
|
break;
|
|
|
case IT_er_CODE:
|
case IT_er_CODE:
|
{
|
{
|
struct IT_er dummy;
|
struct IT_er dummy;
|
sysroff_swap_er_in (&dummy);
|
sysroff_swap_er_in (&dummy);
|
sysroff_print_er_out (&dummy);
|
sysroff_print_er_out (&dummy);
|
}
|
}
|
break;
|
break;
|
|
|
case IT_ed_CODE:
|
case IT_ed_CODE:
|
{
|
{
|
struct IT_ed dummy;
|
struct IT_ed dummy;
|
sysroff_swap_ed_in (&dummy);
|
sysroff_swap_ed_in (&dummy);
|
sysroff_print_ed_out (&dummy);
|
sysroff_print_ed_out (&dummy);
|
}
|
}
|
break;
|
break;
|
|
|
case IT_sh_CODE:
|
case IT_sh_CODE:
|
{
|
{
|
struct IT_sh dummy;
|
struct IT_sh dummy;
|
sysroff_swap_sh_in (&dummy);
|
sysroff_swap_sh_in (&dummy);
|
sysroff_print_sh_out (&dummy);
|
sysroff_print_sh_out (&dummy);
|
}
|
}
|
break;
|
break;
|
|
|
case IT_ob_CODE:
|
case IT_ob_CODE:
|
{
|
{
|
struct IT_ob dummy;
|
struct IT_ob dummy;
|
sysroff_swap_ob_in (&dummy);
|
sysroff_swap_ob_in (&dummy);
|
sysroff_print_ob_out (&dummy);
|
sysroff_print_ob_out (&dummy);
|
}
|
}
|
break;
|
break;
|
|
|
case IT_rl_CODE:
|
case IT_rl_CODE:
|
{
|
{
|
struct IT_rl dummy;
|
struct IT_rl dummy;
|
sysroff_swap_rl_in (&dummy);
|
sysroff_swap_rl_in (&dummy);
|
sysroff_print_rl_out (&dummy);
|
sysroff_print_rl_out (&dummy);
|
}
|
}
|
break;
|
break;
|
|
|
case IT_du_CODE:
|
case IT_du_CODE:
|
{
|
{
|
struct IT_du dummy;
|
struct IT_du dummy;
|
sysroff_swap_du_in (&dummy);
|
sysroff_swap_du_in (&dummy);
|
|
|
sysroff_print_du_out (&dummy);
|
sysroff_print_du_out (&dummy);
|
}
|
}
|
break;
|
break;
|
|
|
case IT_dus_CODE:
|
case IT_dus_CODE:
|
{
|
{
|
struct IT_dus dummy;
|
struct IT_dus dummy;
|
sysroff_swap_dus_in (&dummy);
|
sysroff_swap_dus_in (&dummy);
|
sysroff_print_dus_out (&dummy);
|
sysroff_print_dus_out (&dummy);
|
}
|
}
|
break;
|
break;
|
|
|
case IT_dul_CODE:
|
case IT_dul_CODE:
|
{
|
{
|
struct IT_dul dummy;
|
struct IT_dul dummy;
|
sysroff_swap_dul_in (&dummy);
|
sysroff_swap_dul_in (&dummy);
|
sysroff_print_dul_out (&dummy);
|
sysroff_print_dul_out (&dummy);
|
}
|
}
|
break;
|
break;
|
|
|
case IT_dss_CODE:
|
case IT_dss_CODE:
|
{
|
{
|
struct IT_dss dummy;
|
struct IT_dss dummy;
|
sysroff_swap_dss_in (&dummy);
|
sysroff_swap_dss_in (&dummy);
|
sysroff_print_dss_out (&dummy);
|
sysroff_print_dss_out (&dummy);
|
}
|
}
|
break;
|
break;
|
|
|
case IT_hs_CODE:
|
case IT_hs_CODE:
|
{
|
{
|
struct IT_hs dummy;
|
struct IT_hs dummy;
|
sysroff_swap_hs_in (&dummy);
|
sysroff_swap_hs_in (&dummy);
|
sysroff_print_hs_out (&dummy);
|
sysroff_print_hs_out (&dummy);
|
}
|
}
|
break;
|
break;
|
|
|
case IT_dps_CODE:
|
case IT_dps_CODE:
|
{
|
{
|
struct IT_dps dummy;
|
struct IT_dps dummy;
|
sysroff_swap_dps_in (&dummy);
|
sysroff_swap_dps_in (&dummy);
|
sysroff_print_dps_out (&dummy);
|
sysroff_print_dps_out (&dummy);
|
}
|
}
|
break;
|
break;
|
|
|
case IT_tr_CODE:
|
case IT_tr_CODE:
|
sysroff_swap_tr_in ();
|
sysroff_swap_tr_in ();
|
sysroff_print_tr_out ();
|
sysroff_print_tr_out ();
|
break;
|
break;
|
|
|
case IT_dds_CODE:
|
case IT_dds_CODE:
|
{
|
{
|
struct IT_dds dummy;
|
struct IT_dds dummy;
|
|
|
sysroff_swap_dds_in (&dummy);
|
sysroff_swap_dds_in (&dummy);
|
sysroff_print_dds_out (&dummy);
|
sysroff_print_dds_out (&dummy);
|
}
|
}
|
break;
|
break;
|
|
|
default:
|
default:
|
printf ("GOT A %x\n", c);
|
printf ("GOT A %x\n", c);
|
return 0;
|
return 0;
|
break;
|
break;
|
}
|
}
|
|
|
return 1;
|
return 1;
|
}
|
}
|
|
|
static int
|
static int
|
opt (int x)
|
opt (int x)
|
{
|
{
|
return getone (x);
|
return getone (x);
|
}
|
}
|
|
|
static void
|
static void
|
must (int x)
|
must (int x)
|
{
|
{
|
if (!getone (x))
|
if (!getone (x))
|
printf ("WANTED %x!!\n", x);
|
printf ("WANTED %x!!\n", x);
|
}
|
}
|
|
|
static void
|
static void
|
tab (int i, char *s)
|
tab (int i, char *s)
|
{
|
{
|
indent += i;
|
indent += i;
|
|
|
if (s)
|
if (s)
|
{
|
{
|
p ();
|
p ();
|
printf (s);
|
printf (s);
|
printf ("\n");
|
printf ("\n");
|
}
|
}
|
}
|
}
|
|
|
static void
|
static void
|
dump_symbol_info (void)
|
dump_symbol_info (void)
|
{
|
{
|
tab (1, "SYMBOL INFO");
|
tab (1, "SYMBOL INFO");
|
|
|
while (opt (IT_dsy_CODE))
|
while (opt (IT_dsy_CODE))
|
{
|
{
|
if (opt (IT_dty_CODE))
|
if (opt (IT_dty_CODE))
|
{
|
{
|
must (IT_dbt_CODE);
|
must (IT_dbt_CODE);
|
derived_type ();
|
derived_type ();
|
must (IT_dty_CODE);
|
must (IT_dty_CODE);
|
}
|
}
|
}
|
}
|
|
|
tab (-1, "");
|
tab (-1, "");
|
}
|
}
|
|
|
static void
|
static void
|
derived_type (void)
|
derived_type (void)
|
{
|
{
|
tab (1, "DERIVED TYPE");
|
tab (1, "DERIVED TYPE");
|
|
|
while (1)
|
while (1)
|
{
|
{
|
if (opt (IT_dpp_CODE))
|
if (opt (IT_dpp_CODE))
|
{
|
{
|
dump_symbol_info ();
|
dump_symbol_info ();
|
must (IT_dpp_CODE);
|
must (IT_dpp_CODE);
|
}
|
}
|
else if (opt (IT_dfp_CODE))
|
else if (opt (IT_dfp_CODE))
|
{
|
{
|
dump_symbol_info ();
|
dump_symbol_info ();
|
must (IT_dfp_CODE);
|
must (IT_dfp_CODE);
|
}
|
}
|
else if (opt (IT_den_CODE))
|
else if (opt (IT_den_CODE))
|
{
|
{
|
dump_symbol_info ();
|
dump_symbol_info ();
|
must (IT_den_CODE);
|
must (IT_den_CODE);
|
}
|
}
|
else if (opt (IT_den_CODE))
|
else if (opt (IT_den_CODE))
|
{
|
{
|
dump_symbol_info ();
|
dump_symbol_info ();
|
must (IT_den_CODE);
|
must (IT_den_CODE);
|
}
|
}
|
else if (opt (IT_dds_CODE))
|
else if (opt (IT_dds_CODE))
|
{
|
{
|
dump_symbol_info ();
|
dump_symbol_info ();
|
must (IT_dds_CODE);
|
must (IT_dds_CODE);
|
}
|
}
|
else if (opt (IT_dar_CODE))
|
else if (opt (IT_dar_CODE))
|
{
|
{
|
}
|
}
|
else if (opt (IT_dpt_CODE))
|
else if (opt (IT_dpt_CODE))
|
{
|
{
|
}
|
}
|
else if (opt (IT_dul_CODE))
|
else if (opt (IT_dul_CODE))
|
{
|
{
|
}
|
}
|
else if (opt (IT_dse_CODE))
|
else if (opt (IT_dse_CODE))
|
{
|
{
|
}
|
}
|
else if (opt (IT_dot_CODE))
|
else if (opt (IT_dot_CODE))
|
{
|
{
|
}
|
}
|
else
|
else
|
break;
|
break;
|
}
|
}
|
|
|
tab (-1, "");
|
tab (-1, "");
|
}
|
}
|
|
|
static void
|
static void
|
module (void)
|
module (void)
|
{
|
{
|
int c = 0;
|
int c = 0;
|
int l = 0;
|
int l = 0;
|
|
|
tab (1, "MODULE***\n");
|
tab (1, "MODULE***\n");
|
|
|
do
|
do
|
{
|
{
|
c = getc (file);
|
c = getc (file);
|
ungetc (c, file);
|
ungetc (c, file);
|
|
|
c &= 0x7f;
|
c &= 0x7f;
|
}
|
}
|
while (getone (c) && c != IT_tr_CODE);
|
while (getone (c) && c != IT_tr_CODE);
|
|
|
tab (-1, "");
|
tab (-1, "");
|
|
|
c = getc (file);
|
c = getc (file);
|
while (c != EOF)
|
while (c != EOF)
|
{
|
{
|
printf ("%02x ", c);
|
printf ("%02x ", c);
|
l++;
|
l++;
|
if (l == 32)
|
if (l == 32)
|
{
|
{
|
printf ("\n");
|
printf ("\n");
|
l = 0;
|
l = 0;
|
}
|
}
|
c = getc (file);
|
c = getc (file);
|
}
|
}
|
}
|
}
|
|
|
char *program_name;
|
char *program_name;
|
|
|
static void
|
static void
|
show_usage (FILE *file, int status)
|
show_usage (FILE *file, int status)
|
{
|
{
|
fprintf (file, _("Usage: %s [option(s)] 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, _("Print a human readable interpretation of a SYSROFF object file\n"));
|
fprintf (file, _(" The options are:\n\
|
fprintf (file, _(" The options are:\n\
|
-h --help Display this information\n\
|
-h --help Display this information\n\
|
-v --version Print the program's version number\n"));
|
-v --version Print the program's version number\n"));
|
|
|
if (REPORT_BUGS_TO[0] && status == 0)
|
if (REPORT_BUGS_TO[0] && status == 0)
|
fprintf (file, _("Report bugs to %s\n"), REPORT_BUGS_TO);
|
fprintf (file, _("Report bugs to %s\n"), REPORT_BUGS_TO);
|
exit (status);
|
exit (status);
|
}
|
}
|
|
|
int
|
int
|
main (int ac, char **av)
|
main (int ac, char **av)
|
{
|
{
|
char *input_file = NULL;
|
char *input_file = NULL;
|
int opt;
|
int opt;
|
static struct option long_options[] =
|
static struct option long_options[] =
|
{
|
{
|
{"help", no_argument, 0, 'h'},
|
{"help", no_argument, 0, 'h'},
|
{"version", no_argument, 0, 'V'},
|
{"version", no_argument, 0, 'V'},
|
{NULL, no_argument, 0, 0}
|
{NULL, no_argument, 0, 0}
|
};
|
};
|
|
|
#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
|
#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
|
setlocale (LC_MESSAGES, "");
|
setlocale (LC_MESSAGES, "");
|
#endif
|
#endif
|
#if defined (HAVE_SETLOCALE)
|
#if defined (HAVE_SETLOCALE)
|
setlocale (LC_CTYPE, "");
|
setlocale (LC_CTYPE, "");
|
#endif
|
#endif
|
bindtextdomain (PACKAGE, LOCALEDIR);
|
bindtextdomain (PACKAGE, LOCALEDIR);
|
textdomain (PACKAGE);
|
textdomain (PACKAGE);
|
|
|
program_name = av[0];
|
program_name = av[0];
|
xmalloc_set_program_name (program_name);
|
xmalloc_set_program_name (program_name);
|
|
|
expandargv (&ac, &av);
|
expandargv (&ac, &av);
|
|
|
while ((opt = getopt_long (ac, av, "HhVv", long_options, (int *) NULL)) != EOF)
|
while ((opt = getopt_long (ac, av, "HhVv", long_options, (int *) NULL)) != EOF)
|
{
|
{
|
switch (opt)
|
switch (opt)
|
{
|
{
|
case 'H':
|
case 'H':
|
case 'h':
|
case 'h':
|
show_usage (stdout, 0);
|
show_usage (stdout, 0);
|
/*NOTREACHED*/
|
/*NOTREACHED*/
|
case 'v':
|
case 'v':
|
case 'V':
|
case 'V':
|
print_version ("sysdump");
|
print_version ("sysdump");
|
exit (0);
|
exit (0);
|
/*NOTREACHED*/
|
/*NOTREACHED*/
|
case 0:
|
case 0:
|
break;
|
break;
|
default:
|
default:
|
show_usage (stderr, 1);
|
show_usage (stderr, 1);
|
/*NOTREACHED*/
|
/*NOTREACHED*/
|
}
|
}
|
}
|
}
|
|
|
/* The input and output files may be named on the command line. */
|
/* The input and output files may be named on the command line. */
|
|
|
if (optind < ac)
|
if (optind < ac)
|
input_file = av[optind];
|
input_file = av[optind];
|
|
|
if (!input_file)
|
if (!input_file)
|
fatal (_("no input file specified"));
|
fatal (_("no input file specified"));
|
|
|
file = fopen (input_file, FOPEN_RB);
|
file = fopen (input_file, FOPEN_RB);
|
|
|
if (!file)
|
if (!file)
|
fatal (_("cannot open input file %s"), input_file);
|
fatal (_("cannot open input file %s"), input_file);
|
|
|
module ();
|
module ();
|
return 0;
|
return 0;
|
}
|
}
|
|
|
