home *** CD-ROM | disk | FTP | other *** search
/ C/C++ Interactive Reference Guide / C-C++ Interactive Reference Guide.iso / c_ref / csource5 / 303_01 / file.c < prev    next >
Encoding:
C/C++ Source or Header  |  1990-05-16  |  4.7 KB  |  233 lines
  1. /*
  2.  *    SCCS:    %W%    %G%    %U%
  3.  *    Various operations on files.
  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. long    lseek();
  16. void    unimpl();
  17.  
  18. /*
  19.  *    Validate addr and get text entry corresponding to it from the given
  20.  *    file.
  21.  */
  22.  
  23. void    gette(fid, addr, te)
  24. register  ef_fid  fid;
  25. register  long    addr;
  26. t_entry    *te;
  27. {
  28.     addr -= fid->ef_tbase;
  29. #ifdef    COFF
  30.     if  (addr < 0x300000 && 
  31.          (addr < 0  ||  addr > fid->ef_tsize  || (addr & 1) != 0))  
  32.      {
  33.         (void) fprintf(stderr, "Invalid text address %lx\n", addr);
  34.         exit(200);
  35.      }
  36. #else    /*  !COFF  */
  37.     if  (addr < 0  ||  addr > fid->ef_tsize  || (addr & 1) != 0)  {
  38.         (void) fprintf(stderr, "Invalid text address %lx\n", addr);
  39.         exit(200);
  40.     }
  41. #endif    /*  !COFF  */
  42.     (void) lseek(fid->ef_t, (long)(addr * sizeof(t_entry)/2), 0);
  43.     if  (read(fid->ef_t, (char *) te, sizeof(t_entry)) != sizeof(t_entry))  {
  44.         (void) fprintf(stderr, "Trouble reading text at %lx\n", addr);
  45.         exit(201);
  46.     }
  47. }
  48.  
  49. /*
  50.  *    Store a text entry.
  51.  */
  52.  
  53. void    putte(fid, addr, te)
  54. register  ef_fid  fid;
  55. register  long    addr;
  56. t_entry    *te;
  57. {
  58.     addr -= fid->ef_tbase;
  59. #ifdef    COFF
  60.     if  (addr < 0x300000 &&
  61.          (addr < 0  ||  addr > fid->ef_tsize  ||  (addr & 1) != 0))
  62.      {
  63.         (void) fprintf(stderr, "Invalid text address %lx\n", addr);
  64.         exit(200); 
  65.      }
  66. #else    /*  !COFF  */
  67.     if  (addr < 0  ||  addr > fid->ef_tsize  ||  (addr & 1) != 0)  {
  68.         (void) fprintf(stderr, "Invalid text address %lx\n", addr);
  69.         exit(200);
  70.     }
  71. #endif    /*  !COFF  */
  72.     (void) lseek(fid->ef_t, (long)(addr * sizeof(t_entry)/2), 0);
  73.     (void) write(fid->ef_t, (char *) te, sizeof(t_entry));
  74. }
  75.  
  76. /*
  77.  *    Validate addr and get data entry corresponding to it from the given
  78.  *    file.
  79.  */
  80.  
  81. void    getde(fid, addr, de)
  82. register  ef_fid  fid;
  83. register  long    addr;
  84. d_entry    *de;
  85. {
  86. #ifdef    COFF
  87.     if  (addr < 0x300000 && (addr < fid->ef_dbase  ||  addr > fid->ef_end))
  88.      {
  89.         (void) fprintf(stderr, "Invalid data address %lx\n", addr);
  90.         exit(200);
  91.      }
  92. #else    /*  !COFF  */
  93.     if  (addr < fid->ef_dbase  ||  addr > fid->ef_end)  {
  94.         (void) fprintf(stderr, "Invalid data address %lx\n", addr);
  95.         exit(200);
  96.     }
  97. #endif    /*  !COFF  */
  98.     addr -= fid->ef_dbase;
  99.     (void) lseek(fid->ef_d, (long)(addr * sizeof(d_entry)), 0);
  100.     if  (read(fid->ef_d, (char *) de, sizeof(d_entry)) != sizeof(d_entry))  {
  101.         (void) fprintf(stderr, "Trouble reading data at %lx\n", addr);
  102.         exit(201);
  103.     }
  104. }
  105.  
  106. /*
  107.  *    Store a data entry.
  108.  */
  109.  
  110. void    putde(fid, addr, de)
  111. register  ef_fid  fid;
  112. register  long    addr;
  113. d_entry    *de;
  114. {
  115. #ifdef    COFF
  116.     if  (addr < 0x300000 &&
  117.          (addr < fid->ef_dbase  ||  addr > fid->ef_end))
  118.      {
  119.         (void) fprintf(stderr, "Invalid data address %lx\n", addr);
  120.         exit(200);
  121.      }
  122. #else    /*  !COFF  */
  123.     if  (addr < fid->ef_dbase  ||  addr > fid->ef_end)  {
  124.         (void) fprintf(stderr, "Invalid data address %lx\n", addr);
  125.         exit(200);
  126.     }
  127. #endif    /*  !COFF  */
  128.     addr -= fid->ef_dbase;
  129.     (void) lseek(fid->ef_d, (long)(addr * sizeof(d_entry)), 0);
  130.     (void) write(fid->ef_d, (char *) de, sizeof(d_entry));
  131. }
  132.  
  133. /*
  134.  *    Set type and length of given data entry.
  135.  */
  136.  
  137. void    setde(fid, addr, type, lng)
  138. ef_fid    fid;
  139. long    addr;
  140. unsigned  type;
  141. int    lng;
  142. {
  143.     d_entry    dat;
  144.  
  145.     if  (addr > fid->ef_end)
  146.         return;
  147.     getde(fid, addr, &dat);
  148.     if  (type == D_CONT  &&  dat.d_reloc != R_NONE)  {
  149.         char    obuf[30];
  150.         (void) sprintf(obuf, "overlapped reloc 0x%x", addr);
  151.         unimpl(obuf);
  152.     }
  153.     dat.d_type = type;
  154.     dat.d_lng = lng;
  155.     putde(fid, addr, &dat);
  156. }
  157.     
  158. /*
  159.  *    Get a word of data file, size as requested.
  160.  */
  161.  
  162. long    getdw(fid, pos, size)
  163. register  ef_fid  fid;
  164. long    pos;
  165. int    size;
  166. {
  167.     d_entry    dat;
  168.     register  long    res;
  169.     register  int    i, lt;
  170.     
  171.     getde(fid, pos, &dat);
  172.     
  173.     switch  (size)  {
  174.     case  R_BYTE:
  175.         return    dat.d_contents;
  176.         
  177.     case  R_LONG:
  178.         lt = 4;
  179.         goto  rest;
  180.         
  181.     case  R_WORD:
  182.         lt = 2;
  183.     rest:
  184.         res = dat.d_contents;
  185.         for  (i = 1;  i < lt; i++)  {
  186.             getde(fid, pos+i, &dat);
  187.             res = (res << 8) + dat.d_contents;
  188.         }
  189.         return    res;
  190.         
  191.     default:
  192.         (void) fprintf(stderr, "Data word size error\n");
  193.         exit(20);
  194.     }
  195.     /*NOTREACHED*/
  196. }
  197.  
  198. /*
  199.  *    Get a word of text file.
  200.  */
  201.  
  202. long    gettw(fid, pos, size)
  203. register  ef_fid  fid;
  204. long    pos;
  205. int    size;
  206. {
  207.     t_entry    tex;
  208.     long    res;
  209.     
  210.     gette(fid, pos, &tex);
  211.     
  212.     switch  (size)  {
  213.     case  R_BYTE:
  214.         return    tex.t_contents >> 8;
  215.         
  216.     case  R_WORD:
  217.         return    tex.t_contents;
  218.         
  219.     case  R_LONG:
  220.         res = tex.t_contents;
  221.         gette(fid, pos+2, &tex);
  222.         return    (res << 16) + tex.t_contents;
  223.     default:
  224. #ifdef    COFF
  225.         (void) fprintf(stderr, "Text< word size error\n");
  226. #else    /*  !COFF  */
  227.         (void) fprintf(stderr, "Text word size error\n");
  228. #endif    /*  !COFF  */
  229.         exit(20);
  230.     }
  231.     /*NOTREACHED*/
  232. }
  233.