home *** CD-ROM | disk | FTP | other *** search
/ Amiga Elysian Archive / AmigaElysianArchive.iso / comm / term23_2.lha / Source_Code / termSource / termIdentify.c < prev    next >
C/C++ Source or Header  |  1992-08-18  |  13KB  |  618 lines
  1. /*
  2. **    $Id: termIdentify.c,v 1.2 92/08/15 20:14:20 olsen Sta Locker: olsen $
  3. **    $Revision: 1.2 $
  4. **    $Date: 92/08/15 20:14:20 $
  5. **
  6. **    Heuristic file type identification routines
  7. **
  8. **    Copyright © 1990-1992 by Olaf `Olsen' Barthel & MXM
  9. **        All Rights Reserved
  10. */
  11.  
  12. #include "termGlobal.h"
  13.  
  14.     /* The file types we know. */
  15.  
  16. enum    {    TYPE_DIR,TYPE_FILE,
  17.         TYPE_ICON,
  18.         TYPE_TEXT,
  19.         TYPE_C,TYPE_H,
  20.         TYPE_ASM,TYPE_I,
  21.         TYPE_MOD,
  22.         TYPE_REXX,
  23.         TYPE_BASIC,
  24.         TYPE_AMIGAGUIDE,
  25.         TYPE_TEX,TYPE_METAFONT,TYPE_GF,TYPE_TEXFONT,TYPE_TEXDVI,TYPE_FLIB,
  26.         TYPE_OLDMANX,TYPE_NEWMANX,TYPE_OLDMANXLIB,TYPE_NEWMANXLIB,
  27.         TYPE_OBJECT,TYPE_LIB,
  28.         TYPE_EXECUTABLE,
  29.         TYPE_LIBRARY,TYPE_DEVICE,TYPE_FILESYS,TYPE_HANDLER,
  30.         TYPE_GIF,TYPE_DEGAS,TYPE_MACPAINT,TYPE_SUPERPAINT,TYPE_PICT,TYPE_SUNRASTER,TYPE_POSTSCRIPT,TYPE_PCX,TYPE_TIFF,TYPE_BMP,TYPE_JFIF,TYPE_ILBM,
  31.         TYPE_ANIM,TYPE_8SVX,TYPE_SMUS,TYPE_FTXT,TYPE_PREFS,TYPE_TERM,TYPE_AMIGAVISION,TYPE_IFF,
  32.         TYPE_IMPLODER,TYPE_POWERPACKER,TYPE_LHPAK,TYPE_LHASFX,
  33.         TYPE_ARC,TYPE_ARJ,TYPE_COMPRESSED,TYPE_CPIO,TYPE_UUENCODED,TYPE_FREEZE,TYPE_MACCOMPRESS,TYPE_COMPACT,TYPE_DIAMOND,TYPE_LHARC,TYPE_LHA,TYPE_ZOO,TYPE_ZIP,TYPE_STUFFIT,TYPE_PACKIT,TYPE_DMS,TYPE_WARP,TYPE_ZOOM,
  34.         TYPE_SPARCOBJECT,TYPE_SPARCEXECUTABLE,
  35.         TYPE_MSDOSEXECUTABLE,
  36.         TYPE_ATARIEXECUTABLE,
  37.         TYPE_MACEXECUTABLE,
  38.         TYPE_CDAF,TYPE_XPK
  39.     };
  40.  
  41.     /* A structure containing both a file name suffix and the
  42.      * approriate file type.
  43.      */
  44.  
  45. struct Suffix
  46. {
  47.     UBYTE    *Name;
  48.     UBYTE     Type;
  49. };
  50.  
  51.     /* A table of valid ASCII characters (7 bits). */
  52.  
  53. STATIC BYTE ID_ValidTab[256] =
  54. {
  55.     0,0,0,0,0,0,0,1,1,1,1,1,1,1,0,0,
  56.     0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,
  57.     1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
  58.     1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
  59.     1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
  60.     1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
  61.     1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
  62.     1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
  63.     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  64.     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  65.     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  66.     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  67.     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  68.     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  69.     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  70.     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
  71. };
  72.  
  73.     /* A table of clearly invalid ASCII characters (8 bits). */
  74.  
  75. STATIC BYTE ID_InvalidTab[256] =
  76. {
  77.     1,1,1,1,1,1,1,0,0,0,0,0,0,0,1,1,
  78.     1,0,1,0,1,1,1,1,1,1,1,0,1,1,1,1,
  79.     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  80.     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  81.     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  82.     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  83.     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  84.     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  85.     1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
  86.     1,1,1,1,1,1,1,1,1,1,1,0,1,1,1,1,
  87.     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  88.     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  89.     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  90.     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  91.     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  92.     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
  93. };
  94.  
  95.     /* Some file name suffixes for text files and the approriate
  96.      * file types.
  97.      */
  98.  
  99. STATIC struct Suffix TextSuffix[] =
  100. {
  101.     ".C",        TYPE_C,
  102.     ".CPP",        TYPE_C,
  103.     ".CXX",        TYPE_C,
  104.     ".C++",        TYPE_C,
  105.     ".CC",        TYPE_C,
  106.     ".H",        TYPE_H,
  107.     ".ASM",        TYPE_ASM,
  108.     ".A",        TYPE_ASM,
  109.     ".S",        TYPE_ASM,
  110.     ".I",        TYPE_I,
  111.     ".BAS",        TYPE_BASIC,
  112.     ".GFA",        TYPE_BASIC,
  113.     ".REXX",    TYPE_REXX,
  114.     ".CED",        TYPE_REXX,
  115.     ".TTX",        TYPE_REXX,
  116.     ".VLT",        TYPE_REXX,
  117.     ".CPR",        TYPE_REXX,
  118.     ".TxEd",    TYPE_REXX,
  119.     ".ADPro",    TYPE_REXX,
  120.     ".TEX",        TYPE_TEX,
  121.     ".STY",        TYPE_TEX,
  122.     ".MF",        TYPE_METAFONT,
  123.     ".MOD",        TYPE_MOD,
  124.     ".DEF",        TYPE_MOD,
  125.     ".PS",        TYPE_POSTSCRIPT,
  126.     ".GUIDE",    TYPE_AMIGAGUIDE,
  127.     ".UUE",        TYPE_UUENCODED
  128. };
  129.  
  130.     /* Some more file name suffixes for executable files and the
  131.      * approriate file types.
  132.      */
  133.  
  134. STATIC struct Suffix ExecutableSuffix[] =
  135. {
  136.     ".device",    TYPE_DEVICE,
  137.     ".library",    TYPE_LIBRARY,
  138.     "FileSystem",    TYPE_FILESYS,
  139.     "Handler",    TYPE_HANDLER
  140. };
  141.  
  142.     /* Miscellaneous magic cookies. */
  143.  
  144. STATIC STRPTR MagicCookies[] =
  145. {
  146.     "P1",
  147.     "P2",
  148.     "P3",
  149.     "P4",
  150.     "P5",
  151.     "P6",
  152.     "begin",
  153.     "xbtoa"
  154. };
  155.  
  156.     /* LongCompare(UBYTE *Buffer,ULONG Value):
  157.      *
  158.      *    Compare space in memory with a longword value.
  159.      */
  160.  
  161. STATIC BYTE __regargs
  162. LongCompare(UBYTE *Buffer,ULONG Value)
  163. {
  164.     UBYTE *OtherBuffer = (UBYTE *)&Value,i;
  165.  
  166.     for(i = 0 ; i < 4 ; i++)
  167.     {
  168.         if(OtherBuffer[i] != Buffer[i])
  169.             return(FALSE);
  170.     }
  171.  
  172.     return(TRUE);
  173. }
  174.  
  175.     /* Identify(UBYTE *Name):
  176.      *
  177.      *    Simple routine to identify a file type by looking at
  178.      *    its first 400 bytes. If successful a comment is
  179.      *    attached to the file describing the file type.
  180.      */
  181.  
  182. VOID
  183. Identify(UBYTE *Name)
  184. {
  185.     ULONG    *Buffer;
  186.     UBYTE     Type        = TYPE_FILE,
  187.         *TypeName    = NULL;
  188.     WORD     i,
  189.          Len = strlen(Name);
  190.     UBYTE     IFFType[5];
  191.  
  192.         /* Allocate a buffer for the first 410 bytes of the
  193.          * file.
  194.          */
  195.  
  196.     if(Buffer = (ULONG *)AllocVec(410,MEMF_ANY | MEMF_CLEAR))
  197.     {
  198.         BPTR File,Size;
  199.  
  200.             /* Open the file. */
  201.  
  202.         if(File = Open(Name,MODE_OLDFILE))
  203.         {
  204.                 /* Read the first 410 bytes. */
  205.  
  206.             if((Size = Read(File,Buffer,410)) >= sizeof(ULONG))
  207.             {
  208.                 UBYTE    *CharBuffer = (UBYTE *)Buffer;
  209.                 WORD     Count = 0;
  210.  
  211.                     /* See if it's an ASCII file. */
  212.  
  213.                 for(i = 0 ; i < Size ; i++)
  214.                 {
  215.                     if(ID_ValidTab[CharBuffer[i]])
  216.                         Count++;
  217.                     else
  218.                     {
  219.                         if(ID_InvalidTab[CharBuffer[i]])
  220.                         {
  221.                             Count = 0;
  222.  
  223.                             break;
  224.                         }
  225.                     }
  226.                 }
  227.  
  228.                     /* If more than 75% of the
  229.                      * characters in the first
  230.                      * 400 bytes are legal
  231.                      * ASCII characters this
  232.                      * file is supposed to be
  233.                      * a text file.
  234.                      */
  235.  
  236.                 if(Count > 3 * (Size / 4))
  237.                     Type = TYPE_TEXT;
  238.  
  239.                     /* Examine the first longword. */
  240.  
  241.                 if(Type == TYPE_FILE)
  242.                 {
  243.                     switch(Buffer[0])
  244.                     {
  245.                         case 0x58504B46:Type = TYPE_XPK;
  246.                                 break;
  247.  
  248.                         case 0x000003E7:Type = TYPE_OBJECT;
  249.                                 break;
  250.  
  251.                         case 0x000003F3:if(Buffer[10] == 'LSFX')
  252.                                     Type = TYPE_LHPAK;
  253.                                 else
  254.                                 {
  255.                                     if(Buffer[11] == 'SFX!')
  256.                                         Type = TYPE_LHASFX;
  257.                                     else
  258.                                         Type = TYPE_EXECUTABLE;
  259.                                 }
  260.  
  261.                                 break;
  262.  
  263.                         case 0x000003FA:Type = TYPE_LIB;
  264.                                 break;
  265.  
  266.                         case 0xF7593647:Type = TYPE_TEXFONT;
  267.                                 break;
  268.  
  269.                         case 0xF7020183:Type = TYPE_TEXDVI;
  270.                                 break;
  271.  
  272.                         case 0xF7832020:Type = TYPE_GF;
  273.                                 break;
  274.  
  275.                         case 0x504B0304:Type = TYPE_ZIP;
  276.                                 break;
  277.  
  278.                         case 0x01030107:Type = TYPE_SPARCOBJECT;
  279.                                 break;
  280.  
  281.                         case 0x8103010B:Type = TYPE_SPARCEXECUTABLE;
  282.                                 break;
  283.  
  284.                         case 0x59A66A95:Type = TYPE_SUNRASTER;
  285.                                 break;
  286.  
  287.                         case 0x1F9D902A:Type = TYPE_COMPRESSED;
  288.                                 break;
  289.  
  290.                         case 0x30373037:Type = TYPE_CPIO;
  291.                                 break;
  292.  
  293.                         case 'FLIB':    Type = TYPE_FLIB;
  294.                                 break;
  295.  
  296.                         case 'FORM':    switch(Buffer[2])
  297.                                 {
  298.                                     case 'ILBM':    Type = TYPE_ILBM;
  299.                                             break;
  300.  
  301.                                     case 'ANIM':    Type = TYPE_ANIM;
  302.                                             break;
  303.  
  304.                                     case '8SVX':    Type = TYPE_8SVX;
  305.                                             break;
  306.  
  307.                                     case 'SMUS':    Type = TYPE_SMUS;
  308.                                             break;
  309.  
  310.                                     case 'FTXT':    Type = TYPE_FTXT;
  311.                                             break;
  312.  
  313.                                     case 'PREF':    Type = TYPE_PREFS;
  314.                                             break;
  315.  
  316.                                     case 'TERM':    Type = TYPE_TERM;
  317.                                             break;
  318.  
  319.                                     case 'AVCF':    Type = TYPE_AMIGAVISION;
  320.                                             break;
  321.  
  322.                                     case 'CDAF':    Type = TYPE_CDAF;
  323.                                             break;
  324.  
  325.                                     default:    Type = TYPE_IFF;
  326.  
  327.                                             CopyMem(&Buffer[2],IFFType,4);
  328.  
  329.                                             IFFType[4] = 0;
  330.  
  331.                                             break;
  332.                                 }
  333.  
  334.                                 break;
  335.  
  336.                         case 'IMP!':    Type = TYPE_IMPLODER;
  337.                                 break;
  338.  
  339.                         case 'PP20':    Type = TYPE_POWERPACKER;
  340.                                 break;
  341.  
  342.                         case 'DMS!':    Type = TYPE_DMS;
  343.                                 break;
  344.  
  345.                         case 'Warp':    Type = TYPE_WARP;
  346.                                 break;
  347.  
  348.                         case 'ZOM5':
  349.                         case 'ZOOM':    Type = TYPE_ZOOM;
  350.                                 break;
  351.  
  352.                         case 'ZOO ':    Type = TYPE_ZOO;
  353.                                 break;
  354.  
  355.                         case 'GIF8':    Type = TYPE_GIF;
  356.                                 break;
  357.  
  358.                         default:    break;
  359.                     }
  360.                 }
  361.  
  362.                     /* Now for oddly placed magic cookies... */
  363.  
  364.                 if(Type == TYPE_FILE)
  365.                 {
  366.                         /* Dumb check for PCX (awful header -- just
  367.                          * a single byte indicates that the file
  368.                          * is supposed to be a PCX file! Those
  369.                          * PC guys just don't have any
  370.                          * decent software culture!).
  371.                          */
  372.  
  373.                     if(CharBuffer[0] == 0x0A)
  374.                         Type = TYPE_PCX;
  375.  
  376.                         /* Yet another awful file format... */
  377.  
  378.                     if(CharBuffer[0] == 'B' && CharBuffer[1] == 'M')
  379.                         Type = TYPE_BMP;
  380.  
  381.                         /* Check for JFIF... */
  382.  
  383.                     if(LongCompare(&CharBuffer[6],'JFIF'))
  384.                         Type = TYPE_JFIF;
  385.  
  386.                         /* Check for `freeze' output file. */
  387.  
  388.                     if(CharBuffer[0] == (UBYTE)'\037' && CharBuffer[1] >= (UBYTE)'\236')
  389.                         Type = TYPE_FREEZE;
  390.                 }
  391.  
  392.                     /* Check for Macintosh data (note:
  393.                      * this code assumes that the Mac
  394.                      * binary header is still present,
  395.                      * so if you are dealing with stripped
  396.                      * binary files, don't expect the
  397.                      * following code to work!).
  398.                      */
  399.  
  400.                 if(Type == TYPE_FILE)
  401.                 {
  402.                     UBYTE *ByteBuffer = &((UBYTE *)Buffer)[65];
  403.  
  404.                         /* Check for MacPaint... */
  405.  
  406.                     if(LongCompare(ByteBuffer,'PNTG'))
  407.                         Type = TYPE_MACPAINT;
  408.  
  409.                         /* Check for SuperPaint... */
  410.  
  411.                     if(LongCompare(ByteBuffer,'SPTG'))
  412.                         Type = TYPE_SUPERPAINT;
  413.  
  414.                         /* Check for PICT... */
  415.  
  416.                     if(LongCompare(ByteBuffer,'PICT'))
  417.                         Type = TYPE_PICT;
  418.  
  419.                         /* Check for executable... */
  420.  
  421.                     if(LongCompare(ByteBuffer,'APPL') || LongCompare(ByteBuffer,'PRES') || LongCompare(ByteBuffer,'FDOC') || LongCompare(ByteBuffer,'cdev') || LongCompare(ByteBuffer,'INIT'))
  422.                         Type = TYPE_MACEXECUTABLE;
  423.  
  424.                         /* Check for StuffIt archive... */
  425.  
  426.                     if(LongCompare(ByteBuffer,'SIT!') || LongCompare(ByteBuffer,'SIT2'))
  427.                         Type = TYPE_STUFFIT;
  428.  
  429.                         /* Check for PackIt archive... */
  430.  
  431.                     if(LongCompare(ByteBuffer,'PIT '))
  432.                         Type = TYPE_PACKIT;
  433.  
  434.                         /* Check for self-extracting Compact archive. */
  435.  
  436.                     if(LongCompare(ByteBuffer,'APPL') && LongCompare(&ByteBuffer[4],'EXTR'))
  437.                         Type = TYPE_COMPACT;
  438.  
  439.                         /* Check for MacCompress archive. */
  440.  
  441.                     if(LongCompare(ByteBuffer,'ZIVM'))
  442.                         Type = TYPE_MACCOMPRESS;
  443.  
  444.                         /* Check for LhArc archive with MacBinary header. */
  445.  
  446.                     if(LongCompare(ByteBuffer,'LARC'))
  447.                         Type = TYPE_LHARC;
  448.  
  449.                         /* Check for Compact archive. */
  450.  
  451.                     if(LongCompare(ByteBuffer,'PACT'))
  452.                         Type = TYPE_COMPACT;
  453.  
  454.                         /* Check for Diamond archive. */
  455.  
  456.                     if(LongCompare(ByteBuffer,'Pack'))
  457.                         Type = TYPE_DIAMOND;
  458.                 }
  459.  
  460.                     /* Still no match? Have another try... */
  461.  
  462.                 if(Type == TYPE_FILE)
  463.                 {
  464.                     if((Buffer[0] & 0x0000FFFF) == 0x00002D6C && (Buffer[1] & 0xFF00FF00) == 0x68002D00)
  465.                     {
  466.                         if(CharBuffer[5] == '5')
  467.                             Type = TYPE_LHA;
  468.                         else
  469.                             Type = TYPE_LHARC;
  470.                     }
  471.                     else
  472.                     {
  473.                         switch(Buffer[0] & 0xFFFF0000)
  474.                         {
  475.                             case 0x4D4D0000:
  476.                             case 0x49490000:    Type = TYPE_TIFF;
  477.                                         break;
  478.  
  479.                             case 0x1A080000:    Type = TYPE_ARC;
  480.                                         break;
  481.  
  482.                             case 0xEA600000:    Type = TYPE_ARJ;
  483.                                         break;
  484.  
  485.                             case 0x434A0000:    Type = TYPE_NEWMANX;
  486.                                         break;
  487.  
  488.                             case 0x414A0000:    Type = TYPE_OLDMANX;
  489.                                         break;
  490.  
  491.                             case 0x636A0000:    Type = TYPE_NEWMANXLIB;
  492.                                         break;
  493.  
  494.                             case 0x616A0000:    Type = TYPE_OLDMANXLIB;
  495.                                         break;
  496.  
  497.                             case 0xF5000000:    Type = TYPE_BASIC;
  498.                                         break;
  499.  
  500.                             case 0xE3100000:    Type = TYPE_ICON;
  501.                                         break;
  502.  
  503.                             case 0x4D5A0000:    Type = TYPE_MSDOSEXECUTABLE;
  504.                                         break;
  505.  
  506.                             case 0x601A0000:    Type = TYPE_ATARIEXECUTABLE;
  507.                                         break;
  508.  
  509.                             case 0x80000000:    Type = TYPE_DEGAS;
  510.                                         break;
  511.  
  512.                             default:        break;
  513.                         }
  514.                     }
  515.                 }
  516.  
  517.                     /* Take a look at the file name
  518.                      * suffixes.
  519.                      */
  520.  
  521.                 switch(Type)
  522.                 {
  523.                     case TYPE_TEXT:
  524.  
  525.                             for(i = 0 ; i < sizeof(TextSuffix) / sizeof(struct Suffix) ; i++)
  526.                             {
  527.                                 Size = strlen(TextSuffix[i] . Name);
  528.  
  529.                                 if(Len >= Size)
  530.                                 {
  531.                                     if(!Stricmp(&Name[Len - Size],TextSuffix[i] . Name))
  532.                                     {
  533.                                         Type = TextSuffix[i] . Type;
  534.                                         break;
  535.                                     }
  536.                                 }
  537.                             }
  538.  
  539.                                 /* Is it still a text file? */
  540.  
  541.                             if(Type == TYPE_TEXT)
  542.                             {
  543.                                     /* Check for magic cookies. */
  544.  
  545.                                 for(i = 0 ; i < sizeof(MagicCookies) / sizeof(STRPTR) ; i++)
  546.                                 {
  547.                                     if(!memcmp(CharBuffer,MagicCookies[i],strlen(MagicCookies[i])))
  548.                                     {
  549.                                         TypeName = LocaleString(MSG_IDENTIFY_COOKIE_0 + i);
  550.  
  551.                                         break;
  552.                                     }
  553.                                 }
  554.                             }
  555.  
  556.                             break;
  557.  
  558.                     case TYPE_EXECUTABLE:
  559.  
  560.                             for(i = 0 ; i < sizeof(ExecutableSuffix) / sizeof(struct Suffix) ; i++)
  561.                             {
  562.                                 Size = strlen(ExecutableSuffix[i] . Name);
  563.  
  564.                                 if(Len >= Size)
  565.                                 {
  566.                                     if(!Stricmp(&Name[Len - Size],ExecutableSuffix[i] . Name))
  567.                                     {
  568.                                         Type = ExecutableSuffix[i] . Type;
  569.                                         break;
  570.                                     }
  571.                                 }
  572.                             }
  573.  
  574.                             break;
  575.  
  576.                     case TYPE_OBJECT:
  577.  
  578.                             if(Len >= 4)
  579.                             {
  580.                                 if(!Stricmp(&Name[Len - 4],".LIB"))
  581.                                     Type = TYPE_LIB;
  582.                             }
  583.  
  584.                             break;
  585.  
  586.                     default:    break;
  587.                 }
  588.             }
  589.  
  590.             Close(File);
  591.         }
  592.  
  593.         FreeVec(Buffer);
  594.     }
  595.  
  596.     if(Type > TYPE_FILE || TypeName)
  597.     {
  598.         if(Type == TYPE_IFF)
  599.         {
  600.             UBYTE NameBuffer[40];
  601.  
  602.             SPrintf(NameBuffer,LocaleString(MSG_IDENTIFY_IFF_FILE),IFFType);
  603.  
  604.             SetComment(Name,NameBuffer);
  605.         }
  606.         else
  607.         {
  608.             if(TypeName)
  609.                 SetComment(Name,TypeName);
  610.             else
  611.                 SetComment(Name,LocaleString(MSG_IDENTIFY_FILETYPE_0 + Type - TYPE_ICON));
  612.         }
  613.     }
  614.  
  615.     if(Type != TYPE_EXECUTABLE && Type != TYPE_LHPAK && Type != TYPE_LHASFX)
  616.         SetProtection(Name,FIBF_EXECUTE);
  617. }
  618.