home *** CD-ROM | disk | FTP | other *** search
/ Club Amiga de Montreal - CAM / CAM_CD_1.iso / files / 439.lha / HunkFunk / HunkFunk.c < prev    next >
Encoding:
C/C++ Source or Header  |  1990-11-13  |  9.1 KB  |  460 lines
  1. /****************************************************************************
  2. *
  3. *    HunkFunk.c ----    Source code for HunkFunk Amiga object/binary file
  4. *            scanner.
  5. *
  6. *    Author --------    Olaf 'Olsen' Barthel, MXM
  7. *            Brabeckstrasse 35
  8. *            D-3000 Hannover 71
  9. *
  10. *    Compiler ------    Aztec 'C' 5.0
  11. *
  12. *            Use: CC -so HunkFunk.c
  13. *                 LN HunkFunk.o -Lc
  14. *
  15. *    HunkFunk is © Copyright 1990 by MXM. Source code and executable
  16. *    file are both placed in the public domain. A small copy fee
  17. *    is okay, but anything which looks, smells or tastes like commercial
  18. *    distribution must be registered with the author.
  19. *
  20. ****************************************************************************/
  21.  
  22. #include <libraries/dosextens.h>
  23. #include <functions.h>
  24.  
  25.     /* Hunk identifiers. */
  26.  
  27. #define HUNK_UNIT    0x03E7    /* Date unit to follow. */
  28. #define HUNK_NAME    0x03E8    /* Define a name. */
  29. #define HUNK_CODE    0x03E9    /* Code block to follow. */
  30. #define HUNK_DATA    0x03EA    /* Data block to follow. */
  31. #define HUNK_BSS    0x03EB    /* Data block to create. */
  32. #define HUNK_RELOC32    0x03EC    /* 32-bit relocation information. */
  33. #define HUNK_RELOC16    0x03ED    /* 16-bit relocation information (object files only). */
  34. #define HUNK_RELOC8    0x03EE    /* 8-bit relocation information (object files only). */
  35. #define HUNK_EXT    0x03EF    /* Extended data (object files only). */
  36. #define HUNK_SYMBOL    0x03F0    /* A name symbol. */
  37. #define HUNK_DEBUG    0x03F1    /* Debug information (compiler/assembler dependent). */
  38. #define HUNK_END    0x03F2    /* End of unit. */
  39. #define HUNK_HEADER    0x03F3    /* Segment header. */
  40.  
  41.     /* Note the gap between HUNK_HEADER and HUNK_OVERLAY. */
  42.  
  43. #define HUNK_OVERLAY    0x03F5    /* Overlay root node. */
  44. #define HUNK_BREAK    0x03F6    /* End of overlay node. */
  45.  
  46. #define EXT_DEF        1    /* Symbol definition. */
  47. #define EXT_ABS        2    /* Absolute reference. */
  48. #define EXT_RES        3    /* Same as EXT_DEF? */
  49. #define EXT_REF32    129    /* 32-bit reference. */
  50. #define EXT_COMMON    130    /* 32-bit reference/BSS. */
  51. #define EXT_REF16    131    /* 16-bit reference. */    
  52. #define EXT_REF8    132    /* 8-bit reference. */    
  53.  
  54.     /* Some simple macros. */
  55.  
  56. #define ReadLong()    Read(FileHandle,&Type,sizeof(ULONG))
  57. #define ReadName(Longs)    Read(FileHandle,NameString,sizeof(LONG) * (Longs))
  58. #define SkipLong(Longs)    Seek(FileHandle,sizeof(LONG) * (Longs),OFFSET_CURRENT)
  59. #define MakeName(Longs) NameString[Longs * sizeof(LONG)] = 0
  60.  
  61.     /* Unit load types. */
  62.  
  63. #define TYPE_CHIP    1
  64. #define TYPE_FAST    2
  65.  
  66.     /* Disable the standard ^C handling. */
  67.  
  68. LONG Chk_Abort(VOID) { return(0); }
  69. VOID _wb_parse(VOID) {}
  70.  
  71. void
  72. main(int argc,char **argv)
  73. {
  74.     BPTR    FileHandle;
  75.     ULONG    Type;
  76.     char    NameString[257];
  77.     LONG    i,From,To;
  78.     UBYTE    PrintFlag;
  79.  
  80.         /* Info? */
  81.  
  82.     if(argc < 2)
  83.     {
  84.         puts("Usage: HunkFunk <File>");
  85.         exit(RETURN_OK);
  86.     }
  87.  
  88.         /* Open file to be examined. */
  89.  
  90.     if(!(FileHandle = Open(argv[1],MODE_OLDFILE)))
  91.     {
  92.         printf("HunkFunk: Couldn't open file \"%s\"!\n",argv[1]);
  93.         exit(RETURN_FAIL);
  94.     }
  95.  
  96.         /* Scan the file until EOF. */
  97.  
  98.     for(;;)
  99.     {
  100.             /* End of file? */
  101.  
  102.         if(ReadLong() != sizeof(LONG))
  103.             break;
  104.  
  105.             /* User pressed ^C? */
  106.  
  107.         if(SetSignal(NULL,NULL) & SIGBREAKF_CTRL_C)
  108.         {
  109.             printf("*** Break\a\n");
  110.  
  111.             SetSignal(NULL,SIGBREAKF_CTRL_C);
  112.             goto Quit;
  113.         }
  114.  
  115.             /* Look which type it is. */
  116.  
  117.         switch(Type & 0xFFFF)
  118.         {
  119.             case HUNK_UNIT:        ReadLong();
  120.  
  121.                         if(Type)
  122.                             ReadName(Type);
  123.  
  124.                         MakeName(Type);
  125.  
  126.                         printf("HUNK_UNIT    \"%s\"\n",NameString);
  127.                         break;
  128.  
  129.             case HUNK_NAME:        ReadLong();
  130.  
  131.                         if(Type)
  132.                             ReadName(Type);
  133.  
  134.                         MakeName(Type);
  135.  
  136.                         printf("HUNK_NAME    \"%s\"\n",NameString);
  137.                         break;
  138.  
  139.             case HUNK_CODE:        ReadLong();
  140.                         SkipLong(Type);
  141.                         printf("HUNK_CODE    %ld Bytes\n",Type << 2);
  142.                         break;
  143.  
  144.             case HUNK_DATA:        ReadLong();
  145.                         SkipLong(Type);
  146.                         printf("HUNK_DATA    %ld Bytes\n",Type << 2);
  147.                         break;
  148.  
  149.             case HUNK_BSS:        ReadLong();
  150.                         printf("HUNK_BSS     %ld Bytes\n",Type << 2);
  151.                         break;
  152.  
  153.             case HUNK_RELOC32:    printf("HUNK_RELOC32\n");
  154.  
  155.                         for(;;)
  156.                         {
  157.                             ReadLong();
  158.  
  159.                             if(SetSignal(NULL,NULL) & SIGBREAKF_CTRL_C)
  160.                             {
  161.                                 printf("*** Break\a\n");
  162.  
  163.                                 SetSignal(NULL,SIGBREAKF_CTRL_C);
  164.                                 goto Quit;
  165.                             }
  166.  
  167.                             if(Type)
  168.                             {
  169.                                 SkipLong(1);
  170.                                 SkipLong(Type);
  171.                             }
  172.                             else
  173.                                 break;
  174.                         }
  175.  
  176.                         break;
  177.  
  178.             case HUNK_RELOC16:    printf("HUNK_RELOC16\n");
  179.  
  180.                         for(;;)
  181.                         {
  182.                             ReadLong();
  183.  
  184.                             if(SetSignal(NULL,NULL) & SIGBREAKF_CTRL_C)
  185.                             {
  186.                                 printf("*** Break\a\n");
  187.  
  188.                                 SetSignal(NULL,SIGBREAKF_CTRL_C);
  189.                                 goto Quit;
  190.                             }
  191.  
  192.                             if(Type)
  193.                             {
  194.                                 SkipLong(1);
  195.                                 SkipLong(Type);
  196.                             }
  197.                             else
  198.                                 break;
  199.                         }
  200.  
  201.                         break;
  202.  
  203.             case HUNK_RELOC8:    printf("HUNK_RELOC8\n");
  204.  
  205.                         for(;;)
  206.                         {
  207.                             ReadLong();
  208.  
  209.                             if(SetSignal(NULL,NULL) & SIGBREAKF_CTRL_C)
  210.                             {
  211.                                 printf("*** Break\a\n");
  212.  
  213.                                 SetSignal(NULL,SIGBREAKF_CTRL_C);
  214.                                 goto Quit;
  215.                             }
  216.  
  217.                             if(Type)
  218.                             {
  219.                                 SkipLong(1);
  220.                                 SkipLong(Type);
  221.                             }
  222.                             else
  223.                                 break;
  224.                         }
  225.  
  226.                         break;
  227.  
  228.             case HUNK_EXT:        printf("HUNK_EXT\n");
  229.  
  230.                         for(;;)
  231.                         {
  232.                             ReadLong();
  233.  
  234.                             if(SetSignal(NULL,NULL) & SIGBREAKF_CTRL_C)
  235.                             {
  236.                                 printf("*** Break\a\n");
  237.  
  238.                                 SetSignal(NULL,SIGBREAKF_CTRL_C);
  239.                                 goto Quit;
  240.                             }
  241.  
  242.                             if(!Type)
  243.                                 break;
  244.  
  245.                             switch((Type >> 24) & 0xFF)
  246.                             {
  247.                                 case EXT_DEF:    printf("             EXT_DEF\n");
  248.                                         break;
  249.  
  250.                                 case EXT_ABS:    printf("             EXT_ABS\n");
  251.                                         break;
  252.  
  253.                                 case EXT_RES:    printf("             EXT_RES\n");
  254.                                         break;
  255.  
  256.                                 case EXT_REF32:    printf("             EXT_REF32\n");
  257.                                         break;
  258.  
  259.                                 case EXT_COMMON:printf("             EXT_COMMON\n");
  260.                                         break;
  261.  
  262.                                 case EXT_REF16:    printf("             EXT_REF16\n");
  263.                                         break;
  264.  
  265.                                 case EXT_REF8:    printf("             EXT_REF8\n");
  266.                                         break;
  267.  
  268.                                 default:    printf("             EXT_??? (0x%02x)\n",(Type >> 24) & 0xFF);
  269.                                         break;
  270.                             }
  271.  
  272.                             PrintFlag = FALSE;
  273.  
  274.                                 /* Is it followed by a symbol name? */
  275.  
  276.                             if(Type & 0xFFFFFF)
  277.                             {
  278.                                 ReadName((Type & 0xFFFFFF));
  279.                                 MakeName((Type & 0xFFFFFF));
  280.  
  281.                                 printf("             %s",NameString);
  282.  
  283.                                 PrintFlag = TRUE;
  284.                             }
  285.  
  286.                                 /* Remember extension type. */
  287.  
  288.                             i = (Type >> 24) & 0xFF;
  289.  
  290.                                 /* Display value of symbol. */
  291.  
  292.                             if(i == EXT_DEF || i == EXT_ABS || i == EXT_RES)
  293.                             {
  294.                                 if(!(Type & 0xFFFFFF))
  295.                                     printf("???");
  296.  
  297.                                 ReadLong();
  298.  
  299.                                 printf(" = 0x%08lx",Type);
  300.  
  301.                                 PrintFlag = TRUE;
  302.                             }
  303.  
  304.                             if(PrintFlag)
  305.                                 printf("\n");
  306.  
  307.                                 /* Skip relocation information. */
  308.  
  309.                             if(i == EXT_REF32 || i == EXT_REF16 || i == EXT_REF8)
  310.                             {
  311.                                 ReadLong();
  312.                                 SkipLong(Type);
  313.                             }
  314.  
  315.                                 /* Display size of common block. */
  316.  
  317.                             if(i == EXT_COMMON)
  318.                             {
  319.                                 ReadLong();
  320.  
  321.                                 printf("      Size = %ld Bytes\n",Type << 2);
  322.  
  323.                                 ReadLong();
  324.                                 SkipLong(Type);
  325.                             }
  326.                         }
  327.  
  328.                         break;
  329.  
  330.             case HUNK_SYMBOL:    printf("HUNK_SYMBOL\n");
  331.  
  332.                         for(;;)
  333.                         {
  334.                             ReadLong();
  335.  
  336.                             if(SetSignal(NULL,NULL) & SIGBREAKF_CTRL_C)
  337.                             {
  338.                                 printf("*** Break\a\n");
  339.  
  340.                                 SetSignal(NULL,SIGBREAKF_CTRL_C);
  341.                                 goto Quit;
  342.                             }
  343.  
  344.                             if(!Type)
  345.                                 break;
  346.  
  347.                                 /* Display name. */
  348.  
  349.                             ReadName((Type & 0xFFFFFF));
  350.                             MakeName((Type & 0xFFFFFF));
  351.  
  352.                             printf("             %s",NameString);
  353.  
  354.                                 /* Display value. */
  355.  
  356.                             ReadLong();
  357.  
  358.                             printf(" = 0x%08lx\n",Type);
  359.                         }
  360.  
  361.                         break;
  362.  
  363.             case HUNK_DEBUG:    ReadLong();
  364.                         SkipLong(Type);
  365.  
  366.                         printf("HUNK_DEBUG   %ld Bytes\n",Type << 2);
  367.                         break;
  368.  
  369.             case HUNK_END:        printf("HUNK_END\n\n");
  370.                         break;
  371.  
  372.             case HUNK_HEADER:    printf("HUNK_HEADER\n");
  373.  
  374.                         for(;;)
  375.                         {
  376.                             ReadLong();
  377.  
  378.                             if(SetSignal(NULL,NULL) & SIGBREAKF_CTRL_C)
  379.                             {
  380.                                 printf("*** Break\a\n");
  381.  
  382.                                 SetSignal(NULL,SIGBREAKF_CTRL_C);
  383.                                 goto Quit;
  384.                             }
  385.  
  386.                                 /* Display names of resident libraries. */
  387.  
  388.                             if(Type)
  389.                             {
  390.                                 ReadName(Type);
  391.                                 MakeName(Type);
  392.  
  393.                                 printf("      Name = %s\n",NameString);
  394.                             }
  395.                             else
  396.                                 break;
  397.                         }
  398.  
  399.                         ReadLong();
  400.  
  401.                         printf("  Numhunks = %ld (",Type);
  402.  
  403.                         ReadLong();
  404.                         printf("%ld to ",From = Type);
  405.  
  406.                         ReadLong();
  407.                         printf("%ld)\n",To = Type);
  408.  
  409.                             /* Display hunk lengths/types. */
  410.  
  411.                         for(i = 0 ; i < To - From + 1 ; i++)
  412.                         {
  413.                             ReadLong();
  414.                             printf("  Hunk %03ld = %ld Bytes ",i,(Type & 0x3FFFFFFF) << 2);
  415.  
  416.                             if((Type >> 30) == TYPE_CHIP)
  417.                                 printf("CHIP");
  418.  
  419.                             if((Type >> 30) == TYPE_FAST)
  420.                                 printf("FAST");
  421.  
  422.                             printf("\n");
  423.                         }
  424.  
  425.                         break;
  426.  
  427.             case HUNK_OVERLAY:    printf("HUNK_OVERLAY\n");
  428.  
  429.                         ReadLong();
  430.  
  431.                         /* 8 * Entries + Levels + 1 */
  432.  
  433.                         From = Type;
  434.  
  435.                         ReadLong();
  436.  
  437.                         To = Type - 2;
  438.  
  439.                         From -= (To + 1);
  440.  
  441.                         printf("    Levels = %ld\n",To);
  442.                         printf("   Entries = %ld\n",From / 8);
  443.  
  444.                         Seek(FileHandle,(From + To + 1) * sizeof(LONG),OFFSET_CURRENT);
  445.  
  446.                         break;
  447.  
  448.             case HUNK_BREAK:    printf("HUNK_BREAK\n\n");
  449.                         break;
  450.  
  451.             default:        printf("HUNK_??? (0x%04lx) - Aborting!\a\n",Type & 0xFFFF);
  452.                         goto Quit;
  453.         }
  454.     }
  455.  
  456. Quit:    Close(FileHandle);
  457.  
  458.     exit(RETURN_OK);
  459. }
  460.