home *** CD-ROM | disk | FTP | other *** search
/ C/C++ Interactive Reference Guide / C-C++ Interactive Reference Guide.iso / c_ref / csource5 / 303_01 / prin.c < prev    next >
Encoding:
C/C++ Source or Header  |  1990-05-16  |  9.9 KB  |  498 lines
  1. /*
  2.  *    SCCS:    %W%    %G%    %U%
  3.  *    Print stuff.
  4.  *
  5.  *EMACS_MODES:c
  6.  */
  7.  
  8. #include <stdio.h>
  9. #include <a.out.h>
  10. #ifdef    COFF
  11. #include <ldfcn.h>
  12. #endif    /*  COFF  */
  13. #include "unc.h"
  14.  
  15. #define    LINELNG    70
  16.  
  17. void    gette(), getde();
  18. long    gettw(), getdw();
  19. void    prinst();
  20.  
  21. char    noabs;            /*  No non-global absolutes  */
  22. int    rel;            /*  File being analysed is relocatable  */
  23. int    lpos;
  24.  
  25. struct    commit    abstab, comtab;
  26. #ifdef    COFF
  27. extern char shlibout;
  28. #endif    /*  COFF  */
  29.  
  30. /*
  31.  *    Print absolute and common values.
  32.  */
  33.  
  34. void    pabs()
  35. {
  36.     register  int    i;
  37.     register  symbol  cs;
  38.  
  39.     for  (i = 0;  i < abstab.c_int;  i++)
  40.     
  41.     for  (i = 0;  i < abstab.c_int;  i++)  {
  42.         cs = abstab.c_symb[i];
  43. #ifdef    COFF
  44.         if (cs->s_value >= 0x300000 && ! shlibout)
  45.             continue;
  46. #endif    /*  COFF  */
  47.         if  (cs->s_glob)
  48. #ifdef    COFF
  49.             (void) printf("#\tglobal\t%s\n", cs->s_name);
  50.         else  if  (noabs)
  51.             continue;
  52.         (void) printf("# %s\t= 0x%lx\n", cs->s_name, cs->s_value);
  53.     }
  54.     for  (i = 0;  i < comtab.c_int;  i++)  {
  55.         cs = comtab.c_symb[i];
  56.         (void) printf("\tcomm\t%s,%d\n", cs->s_name, cs->s_value);
  57. #else    /*  !COFF  */
  58.             (void) printf("\t.globl\t%s\n", cs->s_name);
  59.         else  if  (noabs)
  60.             continue;
  61.         (void) printf("%s\t=\t0x%lx\n", cs->s_name, cs->s_value);
  62.     }
  63.     for  (i = 0;  i < comtab.c_int;  i++)  {
  64.         cs = comtab.c_symb[i];
  65.         (void) printf("\t.comm\t%s,%d\n", cs->s_name, cs->s_value);
  66. #endif    /*  !COFF  */
  67.     }
  68. }
  69.  
  70. /*
  71.  *    Print out labels.
  72.  */
  73.  
  74. void    plabs(ls, seg)
  75. register  symbol  ls;
  76. int    seg;
  77. {
  78.     for  (; ls != NULL;  ls = ls->s_link)  {
  79.         if  (ls->s_type != seg)
  80.             continue;
  81.         if  (ls->s_lsymb)  {
  82. #ifdef    COFF
  83.             (void) printf("L%%%u:\n", ls->s_lsymb);
  84. #else    /*  !COFF  */
  85.             (void) printf("%u$:\n", ls->s_lsymb);
  86. #endif    /*  !COFF  */
  87.             return;        /*  Set last  */
  88.         }
  89.         if  (ls->s_glob)
  90. #ifdef    COFF
  91.             (void) printf("\n\tglobal\t%s", ls->s_name);
  92.         if (ls->s_name[0] == '.')
  93.             (void) printf("\n# %s:\n", ls->s_name);
  94.         else
  95.             (void) printf("\n%s:\n", ls->s_name);
  96. #else    /*  !COFF  */
  97.             (void) printf("\n\t.globl\t%s", ls->s_name);
  98.         (void) printf("\n%s:\n", ls->s_name);
  99. #endif    /*  !COFF  */
  100.     }
  101. }
  102.  
  103. /*
  104.  *    Print out text.
  105.  */
  106.  
  107. void    ptext(fid)
  108. register  ef_fid  fid;
  109. {
  110.     register  long    tpos, endt;
  111.     t_entry    tstr;
  112.  
  113. #ifdef    COFF
  114.     (void) fputs("\ttext\n", stdout);
  115. #else    /*  !COFF  */
  116.     (void) printf(".text\n");
  117. #endif    /*  !COFF  */
  118.     
  119.     tpos = fid->ef_tbase;
  120.     endt = tpos + fid->ef_tsize;
  121. contin:    
  122.     for  (;  tpos < endt;  tpos += tstr.t_lng * 2)  {
  123.         gette(fid, tpos, &tstr);
  124. #ifdef    COFF
  125.         plabs(tstr.t_lab, S_TEXT);
  126. #else    /*  !COFF  */
  127.         plabs(tstr.t_lab, TEXT);
  128. #endif    /*  !COFF  */
  129.         if  (tstr.t_type == T_BEGIN)
  130.             prinst(&tstr, tpos);
  131.         else  if  (tstr.t_relsymb != NULL)  {
  132. #ifdef    COFF
  133.             (void) printf("\tlong\t%s", tstr.t_relsymb->s_name);
  134.             if  (tstr.t_relsymb->s_type!=S_TEXT &&
  135.                 tstr.t_relsymb->s_type!=S_DATA)
  136. #else    /*  !COFF  */
  137.             (void) printf("\t.long\t%s", tstr.t_relsymb->s_name);
  138.             if  (tstr.t_relsymb->s_type!=TEXT &&
  139.                 tstr.t_relsymb->s_type!=DATA)
  140. #endif    /*  !COFF  */
  141.                 (void) printf("+0x%x", gettw(fid, tpos, R_LONG));
  142. #ifdef    COFF
  143.             (void) putchar('\n');
  144. #else    /*  !COFF  */
  145.             putchar('\n');
  146. #endif    /*  !COFF  */
  147.             tpos += 4;
  148.             goto  contin;
  149.         }
  150.         else
  151. #ifdef    COFF
  152.             (void) printf("\tshort\t0x%x\n", tstr.t_contents);
  153. #else    /*  !COFF  */
  154.             (void) printf("\t.word\t0x%x\n", tstr.t_contents);
  155. #endif    /*  !COFF  */
  156.     }
  157.  
  158.     /*
  159.      *    Print out any trailing label.
  160.      */
  161.     
  162.     gette(fid, tpos, &tstr);
  163. #ifdef    COFF
  164.     plabs(tstr.t_lab, S_TEXT);
  165. #else    /*  !COFF  */
  166.     plabs(tstr.t_lab, TEXT);
  167. #endif    /*  !COFF  */
  168. }
  169.  
  170. /*
  171.  *    Print out data.
  172.  */
  173.  
  174. void    pdata(fid)
  175. register  ef_fid  fid;
  176. {
  177.     register  long    dpos, endd;
  178. #ifdef    COFF
  179.     register  int    lng, ccnt;
  180. #else    /*  !COFF  */
  181.     register  int    lng;
  182. #endif    /*  !COFF  */
  183.     unsigned  ctyp;
  184.     int    had, par, inc;
  185.     char    *msg;
  186.     d_entry    dstr;
  187.     
  188. #ifdef    COFF
  189.     (void) fputs("\n\tdata\n", stdout);
  190. #else    /*  !COFF  */
  191.     (void) printf("\n.data\n");
  192. #endif    /*  !COFF  */
  193.     
  194.     dpos = fid->ef_dbase;
  195.     endd = dpos + fid->ef_dsize;
  196.  
  197.     while  (dpos < endd)  {
  198.         
  199.         getde(fid, dpos, &dstr);
  200. #ifdef    COFF
  201.         plabs(dstr.d_lab, S_DATA);
  202. #else    /*  !COFF  */
  203.         plabs(dstr.d_lab, DATA);
  204. #endif    /*  !COFF  */
  205.             
  206.         switch  (dstr.d_type)  {
  207.         case  D_CONT:
  208.             (void) fprintf(stderr, "Data sync error\n");
  209. #ifdef    COFF
  210.             dpos++;
  211.             break;
  212. #else    /*  !COFF  */
  213.             exit(200);
  214. #endif    /*  !COFF  */
  215.             
  216.         case  D_ASC:
  217.         case  D_ASCZ:
  218.             ctyp = dstr.d_type;
  219.             lng = dstr.d_lng;
  220. #ifdef    COFF
  221.         nextline:
  222.             (void) fputs("\tbyte\t", stdout);
  223.             ccnt=0;
  224. #else    /*  !COFF  */
  225.             (void) printf("\t.asci");
  226.             if  (ctyp == D_ASC)
  227.                 (void) printf("i\t\"");
  228.             else  {
  229.                 (void) printf("z\t\"");
  230.                 lng--;
  231.             }
  232.                 
  233. #endif    /*  !COFF  */
  234.             while  (lng > 0)  {
  235. #ifdef    COFF
  236.                 if (ccnt) (void) putchar(',');
  237. #endif    /*  COFF  */
  238.                 getde(fid, dpos, &dstr);
  239.                 switch  (dstr.d_contents)  {
  240.                 default:
  241.                     if  (dstr.d_contents < ' ' ||
  242.                         dstr.d_contents > '~')
  243. #ifdef    COFF
  244.                         ccnt += printf("0x%x", dstr.d_contents);
  245.                     else {
  246.                         (void) putchar('\'');
  247.                         (void)putchar(dstr.d_contents);
  248.                         ccnt += 2;
  249.                     }
  250. #else    /*  !COFF  */
  251.                         (void) printf("\\%.3o", dstr.d_contents);
  252.                     else
  253.                         putchar(dstr.d_contents);
  254. #endif    /*  !COFF  */
  255.                     break;
  256. #ifndef    COFF
  257.                 case  '\"':
  258.                 case  '\'':
  259. #endif    /*  !COFF  */
  260.                 case  '\\':
  261. #ifdef    COFF
  262.                     (void) putchar('\'');
  263.                     (void) putchar('\\');
  264.                     (void) putchar('\\');
  265.                     ccnt+=2;
  266. #else    /*  !COFF  */
  267.                 case  '|':
  268.                     (void) printf("\\%c", dstr.d_contents);
  269. #endif    /*  !COFF  */
  270.                     break;
  271.                 case  '\b':
  272. #ifdef    COFF
  273.                     (void) putchar('\'');
  274.                     (void) putchar('\\');
  275.                     (void) putchar('b');
  276.                     ccnt+=2;
  277. #else    /*  !COFF  */
  278.                     (void) printf("\\b");
  279. #endif    /*  !COFF  */
  280.                     break;
  281.                 case  '\n':
  282. #ifdef    COFF
  283.                     (void) putchar('\'');
  284.                     (void) putchar('\\');
  285.                     (void) putchar('n');
  286.                     ccnt+=2;
  287. #else    /*  !COFF  */
  288.                     (void) printf("\\n");
  289. #endif    /*  !COFF  */
  290.                     break;
  291.                 case  '\r':
  292. #ifdef    COFF
  293.                     (void) putchar('\'');
  294.                     (void) putchar('\\');
  295.                     (void) putchar('r');
  296.                     ccnt+=2;
  297. #else    /*  !COFF  */
  298.                     (void) printf("\\r");
  299. #endif    /*  !COFF  */
  300.                     break;
  301. #ifdef    COFF
  302.                 case  '\f':
  303.                     (void) putchar('\'');
  304.                     (void) putchar('\\');
  305.                     (void) putchar('f');
  306.                     ccnt+=2;
  307.                     break;
  308.                 case  '\t':
  309.                     (void) putchar('\'');
  310.                     (void) putchar('\\');
  311.                     (void) putchar('t');
  312.                     ccnt+=2;
  313.                     break;
  314. #endif    /*  COFF  */
  315.                 }
  316. #ifdef    COFF
  317.  
  318. #else    /*  !COFF  */
  319.                 
  320. #endif    /*  !COFF  */
  321.                 lng--;
  322.                 dpos++;
  323. #ifdef    COFF
  324.                 if (++ccnt > 40 && lng > 0) {
  325.                     (void) putchar('\n');
  326.                     goto nextline;
  327.                 }
  328. #endif    /*  COFF  */
  329.             }
  330. #ifdef    COFF
  331.             (void) putchar('\n');
  332. #else    /*  !COFF  */
  333.             (void) printf("\"\n");
  334.             if  (ctyp == D_ASCZ)
  335.                 dpos++;
  336. #endif    /*  !COFF  */
  337.             break;
  338.  
  339.         case  D_BYTE:
  340.             msg = "byte";
  341.             par = R_BYTE;
  342.             inc = 1;
  343.             goto  wrest;
  344.             
  345.         case  D_WORD:
  346. #ifdef    COFF
  347.             msg = "short";
  348. #else    /*  !COFF  */
  349.             msg = "word";
  350. #endif    /*  !COFF  */
  351.             par = R_WORD;
  352.             inc = 2;
  353.             goto  wrest;
  354.             
  355.         case  D_LONG:
  356.             msg = "long";
  357.             par = R_LONG;
  358.             inc = 4;
  359.         wrest:
  360. #ifdef    COFF
  361.             (void) putchar('\t');
  362.             (void) fputs(msg, stdout);
  363.             (void) putchar('\t');
  364. #else    /*  !COFF  */
  365.             (void) printf("\t.%s\t", msg);
  366. #endif    /*  !COFF  */
  367.             lng = dstr.d_lng;
  368.             lpos = 16;
  369.             had = 0;
  370.             while  (lng > 0)  {
  371. #ifdef    COFF
  372.                 if  (lpos > LINELNG) {
  373.                     (void) putchar('\n');
  374.                     (void) putchar('\t');
  375.                     (void) fputs(msg, stdout);
  376.                     (void) putchar('\t');
  377. #else    /*  !COFF  */
  378.                 if  (lpos > LINELNG)  {
  379.                     (void) printf("\n\t.%s\t", msg);
  380. #endif    /*  !COFF  */
  381.                     lpos = 16;
  382.                 }
  383. #ifdef    COFF
  384.                 else  if  (had) {
  385.                     (void) putchar(',');
  386.                     (void) putchar(' ');
  387.                     lpos += 2;
  388.                 }
  389. #else    /*  !COFF  */
  390.                 else  if  (had)
  391.                     lpos += printf(", ");
  392.  
  393. #endif    /*  !COFF  */
  394.                 lpos += printf("0x%x", getdw(fid, dpos, par));
  395.                 lng -= inc;
  396.                 dpos += inc;
  397.                 had++;
  398.             }
  399. #ifdef    COFF
  400.             (void) putchar('\n');
  401. #else    /*  !COFF  */
  402.             putchar('\n');
  403. #endif    /*  !COFF  */
  404.             break;
  405.  
  406.         case  D_ADDR:
  407. #ifdef    COFF
  408.             (void) fputs("\tlong\t", stdout);
  409. #else    /*  !COFF  */
  410.             (void) printf("\t.long\t");
  411. #endif    /*  !COFF  */
  412.             lng = dstr.d_lng;
  413.             lpos = 16;
  414.             had = 0;
  415.             while  (lng > 0)  {
  416.                 if  (lpos > LINELNG)  {
  417. #ifdef    COFF
  418.                     (void) fputs("\n\tlong\t", stdout);
  419. #else    /*  !COFF  */
  420.                     (void) printf("\n\t.long\t");
  421. #endif    /*  !COFF  */
  422.                     lpos = 16;
  423.                 }
  424. #ifdef    COFF
  425.                 else  if  (had) {
  426.                     (void) putchar(',');
  427.                     (void) putchar(' ');
  428.                     lpos += 2;
  429.                 }
  430. #else    /*  !COFF  */
  431.                 else  if  (had)
  432.                     lpos += printf(", ");
  433. #endif    /*  !COFF  */
  434.  
  435.                 getde(fid, dpos, &dstr);
  436.                 lpos += printf("%s", dstr.d_relsymb->s_name);
  437.                 lng -= sizeof(long);
  438.                 dpos += sizeof(long);
  439.                 had++;
  440.             }
  441. #ifdef    COFF
  442.             (void) putchar('\n');
  443. #else    /*  !COFF  */
  444.             putchar('\n');
  445. #endif    /*  !COFF  */
  446.             break;
  447.         }
  448.     }
  449.     
  450.     /*
  451.      *    Print trailing label.
  452.      */
  453.     
  454.     getde(fid, dpos, &dstr);
  455. #ifdef    COFF
  456.     plabs(dstr.d_lab, S_DATA);
  457. #else    /*  !COFF  */
  458.     plabs(dstr.d_lab, DATA);
  459. #endif    /*  !COFF  */
  460. }
  461.  
  462. void    pbss(fid)
  463. register  ef_fid  fid;
  464. {
  465.     register  long    bpos = fid->ef_bbase;
  466.     long    endb = fid->ef_end;
  467.     d_entry    bstr;
  468.     
  469. #ifdef    COFF
  470.     (void) fputs("\n# .bss\n", stdout);
  471.     while  (bpos < endb)  {
  472.         getde(fid, bpos, &bstr);
  473.         plabs(bstr.d_lab, S_BSS);
  474.         (void) printf("\tspace\t%d\n", bstr.d_lng);
  475.         bpos += bstr.d_lng;
  476.     }
  477.     getde(fid, endb, &bstr);
  478.     plabs(bstr.d_lab, S_BSS);
  479. #else    /*  !COFF  */
  480.     (void) printf("\n.bss\n");
  481.     
  482.     while  (bpos < endb)  {
  483.         getde(fid, bpos, &bstr);
  484.         plabs(bstr.d_lab, BSS);
  485.         (void) printf("\t.space\t%d\n", bstr.d_lng);
  486.         bpos += bstr.d_lng;
  487.     }
  488.     
  489.     getde(fid, endb, &bstr);
  490.     plabs(bstr.d_lab, BSS);
  491. #endif    /*  !COFF  */
  492.     
  493. }
  494. #ifdef    COFF
  495.  
  496.  
  497. #endif    /*  COFF  */
  498.