home *** CD-ROM | disk | FTP | other *** search
/ Amiga Developer CD 2.1 / Amiga Developer CD v2.1.iso / Extras / IFF / Old_IFF_Packages / November_1988 / Examples / PGTB / tbread.c < prev    next >
Encoding:
C/C++ Source or Header  |  1988-12-12  |  5.9 KB  |  279 lines
  1. /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
  2. /* |_o_o|\\  The Software Distillery                         */
  3. /* |. o.| || Made available to the Amiga development community             */
  4. /* | .    | || the authors:                       BBS:      */
  5. /* | o    | ||   John Mainwaring, Jim Cooper             (919)-471-6436  */
  6. /* |  . |//                                     */
  7. /* ======                                     */
  8. /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
  9.  
  10. /* this routine reads the traceback dump file and processes it */
  11.  
  12. #include "tb.h"
  13. #include "setjmp.h"
  14.  
  15. #define FORM (('F'<<24)|('O'<<16)|('R'<<8)|'M')
  16. #define PGTB (('P'<<24)|('G'<<16)|('T'<<8)|'B')
  17. #define FAIL (('F'<<24)|('A'<<16)|('I'<<8)|'L')
  18. #define REGS (('R'<<24)|('E'<<16)|('G'<<8)|'S')
  19. #define VERS (('V'<<24)|('E'<<16)|('R'<<8)|'S')
  20. #define STAK (('S'<<24)|('T'<<16)|('A'<<8)|'K')
  21. #define UDAT (('U'<<24)|('D'<<16)|('A'<<8)|'T')
  22. #define FMEM (('F'<<24)|('M'<<16)|('E'<<8)|'M')
  23.  
  24. extern struct tbtemplate *tbdata;
  25. extern jmp_buf bailout;
  26.  
  27. void readfail(FILE *, long);
  28. void readregs(FILE *, long);
  29. void readvers(FILE *, long);
  30. void readstak(FILE *, long);
  31. void readudat(FILE *, long);
  32. void readfmem(FILE *, long);
  33.  
  34. int tbread(infile)
  35. /*  ------*/
  36. FILE *infile;
  37. {
  38. long filesize, sectsize;
  39. ULONG sectid;
  40. char sectstr[5];
  41.  
  42. if (setjmp(bailout))
  43.    {
  44.    /* get here if any read routine fails a little bit.    It already    */
  45.    /* printed a complaint.  Driver program might be smart enough to   */
  46.    /* continue in some way - or maybe not.  Not our problem.          */
  47.    return(0);
  48.    }
  49.  
  50. if (getlong(infile) == FORM) {
  51.   fprintf(stderr, "FORM length = %ld\n", getlong(infile));
  52. } else {
  53.   fseek(infile,0L,0);  /* seek back to beginning */
  54. }
  55.  
  56. if (getlong(infile) != PGTB)
  57.    {
  58.    fprintf(stderr, "wrong file type\n");
  59.    return(0);
  60.    }
  61.  
  62. filesize = getlong(infile);
  63.  
  64. while (filesize > 0)
  65. {
  66. sectid = getlong(infile);
  67. sectsize = getlong(infile);
  68. filesize = filesize - sectsize - 2;
  69.  
  70. switch (sectid)
  71.    {
  72.    case FAIL:
  73.       readfail(infile, sectsize);
  74.       break;
  75.    case REGS:
  76.       readregs(infile, sectsize);
  77.       break;
  78.    case VERS:
  79.       readvers(infile, sectsize);
  80.       break;
  81.    case STAK:
  82.       readstak(infile, sectsize);
  83.       break;
  84.    case UDAT:
  85.       readudat(infile, sectsize);
  86.       break;
  87.    case FMEM:
  88.       readfmem(infile, sectsize);
  89.       break;
  90.    default:
  91.       longtoascii(sectid, sectstr);
  92.       fprintf(stderr, "*** unknown section type %lx = %s size = %ld\n",
  93.           sectid, sectstr, sectsize);
  94.       skiplong(infile, sectsize);
  95. /*    return(0);*/ /*not willing to guess how to recover from this */
  96.    }
  97.  
  98. }
  99. return(1);  /* success */
  100. }
  101.  
  102. void readvers(file, size)
  103. /*   --------           */
  104. FILE *file;
  105. long size;
  106. {
  107. long nlen;
  108.  
  109. tbdata->ver = getlong(file);
  110. tbdata->rev = getlong(file);
  111. nlen = getascii(file, &(tbdata->filename));
  112.  
  113. if (nlen != (size - 3))
  114.    {
  115.    fprintf(stderr, "incorrect VERS block format\n");
  116.    skiplong(file, size - 3);
  117.    }
  118. tbdata->gotvers = 1;
  119. }
  120.  
  121. void readregs(file, size)
  122. /*   --------           */
  123. FILE *file;
  124. long size;
  125.  
  126. {
  127. if (size != 18)
  128.    {
  129.    fprintf(stderr, "incorrect REGS block format\n");
  130.    skiplong(file, size);
  131.    return;
  132.    }
  133. getblock(file, &(tbdata->pc), size);
  134. tbdata->gotregs = 1;
  135. }
  136.  
  137. void readfail(file, size)
  138. /*   --------           */
  139. FILE *file;
  140. long size;
  141. {
  142. ULONG nlen;
  143. long i;
  144.  
  145. size -= 7; /* fixed components in this data element */
  146.  
  147. nlen = getascii(file, &(tbdata->taskname));
  148. size -= nlen; /* some housekeeeping */
  149.  
  150. /* the following is replaced by a block fetch
  151. tbdata->environ = getlong(file);
  152. tbdata->vbfreq = getlong(file);
  153. tbdata->psfreq = getlong(file);
  154. tbdata->starter = getlong(file);
  155. tbdata->guru = getlong(file);
  156. tbdata->segcount = getlong(file);
  157. */
  158. getblock(file, &(tbdata->environ), 6);
  159.  
  160. if (size != (2 * tbdata->segcount)) /* 2 longwords for each seg descriptor */
  161.    {
  162.    fprintf(stderr, "*** invalid FAIL data element size\n");
  163.    skiplong(file, size);
  164.    return;
  165.    }
  166.  
  167. if (!((char *)tbdata->segments =
  168.        AllocMem(tbdata->segcount * sizeof(struct segment), MEMF_CLEAR)))
  169.    {
  170.    fprintf(stderr, "*** unable to allocate memory\n");
  171.    exit(FATAL);
  172.    }
  173.  
  174. /* adjust seglist stuff to give address and size of memory used by program */
  175. for (i = 0; i < tbdata->segcount; i++)
  176.    {
  177.    tbdata->segments[i].addr = getlong(file) + 4;
  178.    tbdata->segments[i].size = getlong(file) - 8;
  179.    }
  180. tbdata->gotfail = 1;
  181. }
  182.  
  183. void readstak(file, size)
  184. /*   --------*/
  185. FILE *file;
  186. long size;
  187. {
  188. ULONG type;
  189. long formerr = 0;
  190. ULONG *sdptr;
  191.  
  192. type = getlong(file);
  193. size -= 1;
  194.  
  195. switch (type)
  196. {
  197. case 0: {  /* stack parms */
  198.    if (size != 3)
  199.       formerr = 1;
  200.    else
  201.       sdptr = &(tbdata->staktop);
  202.    break; }
  203. case 1: {  /* entire stack */
  204.    if (size > 2048)
  205.       formerr = 1;
  206.    else {
  207.       tbdata->topseg = tbdata->botseg = 0;
  208.       tbdata->seglen = size;
  209.       sdptr = tbdata->stak; }
  210.    break;}
  211. case 2: {  /* top 4k of stack */
  212.    if (size != 1024)
  213.       formerr = 1;
  214.    else {
  215.       tbdata->topseg = 1;
  216.       tbdata->seglen = 0;
  217.       sdptr = tbdata->stak; }
  218.    break; }
  219. case 3: {  /* bottom 4k of stack */
  220.    if (size != 1024)
  221.       formerr = 1;
  222.    else {
  223.       tbdata->botseg = 1;
  224.       tbdata->seglen = 0;
  225.       sdptr = &(tbdata->stak[1024]); }
  226.    break; }
  227. default:
  228.    formerr = 1;
  229. }
  230.  
  231. if (formerr)
  232.    {
  233.    fprintf(stderr, "*** invalid STAK block format, type %ld, size %ld\n",
  234.       type, size);
  235.    skiplong(file, size);
  236.    return;
  237.    }
  238.  
  239. getblock(file, sdptr, size);
  240. }
  241.  
  242. void readudat(file, size)
  243. /*   --------*/
  244. FILE *file;
  245. long size;
  246. {
  247. struct udata *next = tbdata->udhead, *this = (struct udata *)&(tbdata->udhead);
  248.  
  249. while (next)
  250.    {
  251.    this = next;
  252.    next = next->udptr;
  253.    }
  254.  
  255. if (!(this->udptr = (struct udata *)AllocMem((size << 2) + 8, MEMF_CLEAR)))
  256.    {
  257.    fprintf(stderr, "***unable to allocate memory\n");
  258.    exit(FATAL);
  259.    }
  260.  
  261. this->udptr->udsize = size;
  262. getblock(file, &(this->udptr->udat[0]), size);
  263. }
  264.  
  265. void readfmem(file, size)
  266. /*   --------           */
  267. FILE *file;
  268. long size;
  269. {
  270. if (size != 6)
  271.    {
  272.    fprintf(stderr, "incorrect FMEM block format\n");
  273.    skiplong(file, size);
  274.    return;
  275.    }
  276. getblock(file, &(tbdata->memca), size);
  277. tbdata->gotfmem = 1;
  278. }
  279.