home *** CD-ROM | disk | FTP | other *** search
/ MacFormat 1994 November / macformat-018.iso / Utility Spectacular / Developer / macgzip_022-src / macos / think / DoOpen.c next >
Encoding:
C/C++ Source or Header  |  1994-07-26  |  6.2 KB  |  356 lines  |  [TEXT/KAHL]
  1. /*
  2.  * Copyright (C) 1993  SPDsoft
  3.  * 
  4.  */
  5.  
  6. #include "ThePrefs.h"
  7. #include "MacErrors.h"
  8.  
  9. #include <string.h>
  10. #include <stdio.h>
  11. #include <ctype.h>
  12.  
  13. #include "tailor.h"
  14.  
  15. #define EMPTY_STR "\0           "
  16.  
  17. long GvRefNum;
  18.  
  19. typedef struct {
  20.         OSType    Type;
  21.         OSType    Creator;
  22.         short    Binary;
  23.         short    BinHex;
  24.         char    Suffix[32];
  25. #ifdef    GET_DESC
  26.         char    Description[256]; /* useless for me */
  27. #endif
  28.         Boolean    Found;
  29.         }    TSufMap;
  30.         
  31. TSufMap    SufMap;
  32.  
  33.  
  34. extern int gzip_main (int argc, char **argv);
  35. int AsciiMode(char *name, int ascii, int compress);
  36. void FixMacFile( char* name, int ascii, int decompress);
  37.  
  38.  
  39. OSErr DoOpen( Str255 fName, long vRefNum)
  40. {
  41.     int        argc;
  42.     char    *argv[5]={"gzip",EMPTY_STR,NULL,NULL,NULL};
  43.  
  44.     char    sTemp[256], *c;
  45.     int        result;
  46.     Boolean    Compress;
  47.     extern Boolean modKey;
  48.     
  49.     ParamBlockRec    myParamBlock;
  50.     FInfo            vFInfo;
  51.     extern char *get_suffix(char *name);
  52.     extern char z_suffix[MAX_SUFFIX+1]; /* default suffix (can be set with --suffix) */
  53.     extern int  z_len;           /* strlen(z_suffix) */
  54.  
  55.     strncpy(z_suffix, Z_SUFFIX, sizeof(z_suffix)-1);
  56.     if ( *currPrefs.suffix != 0x00 )
  57.         sprintf(z_suffix,"%#s",(char*)currPrefs.suffix);
  58.  
  59.     z_len = strlen(z_suffix);
  60.  
  61.     
  62.  
  63.     GvRefNum=vRefNum;
  64.  
  65. /*********** ResFork ***************/
  66.  
  67.     myParamBlock.fileParam.ioCompletion=NULL;
  68.     myParamBlock.fileParam.ioNamePtr=fName;
  69.     myParamBlock.fileParam.ioVRefNum=vRefNum;
  70.     myParamBlock.fileParam.ioFRefNum=0;
  71.     myParamBlock.fileParam.ioFDirIndex=0 ;
  72.     
  73.     sprintf(sTemp,"Discard Resource Fork: %#s?",fName);
  74.     
  75.     PBGetFInfo( &myParamBlock, false );
  76.     if ( myParamBlock.fileParam.ioFlRLgLen != 0 )
  77.     {
  78.         if ( Cask( sTemp ) == cancel )
  79.             return(128);
  80.     }
  81.  
  82.     if((currPrefs.StKeysAlt)&&(modKey))
  83.     {
  84.             Compress = true;
  85.     }
  86.     else
  87.     {
  88.         switch(currPrefs.WhenCompress)
  89.         {
  90.             case NonMacGzip:
  91.                 GetFInfo(fName,GvRefNum,&vFInfo);
  92.                 
  93.                 Compress =    (vFInfo.fdType != 'Gzip') && (vFInfo.fdType != 'ZIVU') &&
  94.                             (vFInfo.fdType != 'pZIP');
  95.                             
  96.                             
  97.                                                         
  98.                 if (Compress) /* check suffixes */
  99.                 {
  100.                     sprintf(sTemp,"%#s",fName);
  101.                     
  102.                     c=get_suffix(sTemp);
  103.                     
  104.                     if ( c == NULL )
  105.                     {
  106.                         Compress = true;
  107.                     }
  108.                     else
  109.                     {
  110.                         Compress = (*c == 0x00);
  111.                     }
  112.                 }
  113.                 break;
  114.                 
  115.             case G_UseMenu:
  116.                 
  117.                 Compress = currPrefs.compress;
  118.                 break;
  119.         }
  120.     }
  121.     
  122.  
  123. /*********** args ***************/
  124.     argc=1;
  125.     
  126. /*********** 1st arg ***************/
  127.  
  128.     strcpy(argv[argc],"-N");
  129.  
  130.     if (!Compress)                            /* gunzip */
  131.     {
  132.         strcat(argv[argc], "d" );
  133.         
  134.         /* when decompress, asci is set in create_outfile */
  135.     }
  136.     else                                                /* gzip */
  137.     {
  138.         sprintf(argv[argc],"-%d",currPrefs.level );        /* # */
  139.         if( AsciiMode((char *)fName, currPrefs.ascii, currPrefs.compress))
  140.             strcat(argv[argc],"a");                        /* ascii */
  141.  
  142.     }
  143.  
  144.  
  145.     if(currPrefs.force)
  146.         strcat(argv[argc],"f");                            /* force */
  147.     
  148.     argc++;
  149.     
  150. /*********** 2nd arg ?**************/
  151.  
  152.     if ( *currPrefs.suffix != 0x00 )
  153.     {
  154.         sprintf((char*)sTemp,"-S%#s",(char*)currPrefs.suffix);
  155.         argv[argc]=(char*)sTemp;
  156.         argc++;
  157.     }
  158.  
  159. /*********** next arg ***************/
  160.  
  161.     PtoCstr(fName);
  162.     argv[argc]=(char*)fName;
  163.     argv[++argc]=NULL;
  164.     
  165. /*********** do it ***************/
  166.  
  167.     SetVol( nil, vRefNum);
  168.     
  169.     result = gzip_main ( argc, argv );
  170.     
  171. /*********** creator & other ***************/
  172.  
  173.     CtoPstr(fName);
  174.  
  175.     return( result );
  176.  
  177. }
  178.  
  179.  
  180. void FixMacFile( char* name, int ascii, int decompress)
  181. /*
  182.  * when using fetch prefs, this should be called after
  183.  * AsciiMode
  184.  */
  185.  
  186. {
  187.     FInfo    vFInfo;
  188.             
  189.     CtoPstr(name);
  190.     GetFInfo(name,GvRefNum,&vFInfo);
  191.     
  192.  
  193.     if ( decompress)
  194.     {
  195.         if ( SufMap.Found )
  196.         {
  197.             vFInfo.fdCreator = SufMap.Creator;
  198.             vFInfo.fdType = SufMap.Type;
  199.         }
  200.         else
  201.         {
  202.             if(ascii)
  203.             {
  204. /* This is a very dirty hack to avoid odd address error in 68000 */
  205.  
  206.                 vFInfo.fdType='TEXT';
  207.                 PtoCstr(currPrefs.textcreator); 
  208.                 vFInfo.fdCreator=*(OSType*)(currPrefs.textcreator);
  209.                 CtoPstr(currPrefs.textcreator);
  210.             }
  211.             else
  212.             {
  213.                 PtoCstr(currPrefs.bincreator);
  214.                 vFInfo.fdCreator=*(OSType*)(currPrefs.bincreator);
  215.                 CtoPstr(currPrefs.bincreator);
  216.                 PtoCstr(currPrefs.bintype);
  217.                 vFInfo.fdType=*(OSType*)(currPrefs.bintype);
  218.                 CtoPstr(currPrefs.bintype);
  219.             }
  220.         }
  221.     }
  222.     else
  223.     {
  224.         vFInfo.fdType='Gzip';
  225.         vFInfo.fdCreator='Gzip';
  226.     }
  227.     
  228.     SetFInfo(name,GvRefNum,&vFInfo);
  229.     PtoCstr(name);
  230. }
  231.  
  232. int AsciiMode(char *name, int ascii, int compress)
  233. {
  234.     
  235.     FInfo    vFInfo;
  236.     int        result, len;
  237.     
  238.     Ptr        pPrefs;
  239.     char    *p, *n;
  240.  
  241.     extern char        charKey;
  242.     extern Handle    FPrefs;
  243.     extern Size        FPrefsSize;
  244.  
  245.     
  246.     if(compress) /*    name is Pascal string */
  247.     {
  248.         if((currPrefs.StKeysComp)&&(charKey!=0x00))
  249.         {
  250.             result = (charKey == 'a');
  251.         }
  252.         else
  253.         {
  254.             switch(currPrefs.AsciiCompress)
  255.             {
  256.                 case OnlyText:
  257.                     GetFInfo(name,GvRefNum,&vFInfo);
  258.                     result = (vFInfo.fdType == 'TEXT');
  259.                     break;
  260.                     
  261.                 case Never:
  262.                     result = 0;
  263.                     break;
  264.                     
  265.                 case UseMenu:
  266.                     result = currPrefs.ascii;
  267.                     break;
  268.                     
  269.                 default:
  270.                     break;
  271.             
  272.             }
  273.         }
  274.     }
  275.     else  /* OJO *//*    name is C string */
  276.     {
  277.         SufMap.Found = false;
  278.         
  279.         if((currPrefs.StKeysComp)&&(charKey!=0x00))
  280.         {
  281.             result = (charKey == 'a');
  282.         }
  283.         else
  284.         {
  285.             switch(currPrefs.AsciiUnCompress)
  286.             {
  287.                 case Fetch:
  288.                 
  289.                     HLock( FPrefs );
  290.                     pPrefs = *FPrefs;
  291.                     
  292.                     
  293.  
  294.                     while( pPrefs < *FPrefs+FPrefsSize )
  295.                     {
  296.                         SufMap.Type =        *(OSType *)pPrefs;            pPrefs += 4;
  297.                         SufMap.Creator =    *(OSType *)pPrefs;            pPrefs += 4;
  298.                         SufMap.Binary =        (*(short *)pPrefs != 0);    pPrefs += 2;
  299.                         SufMap.BinHex =        (*(short *)pPrefs != 0);    pPrefs += 2;
  300.                         
  301.                         p = SufMap.Suffix;
  302.                         while((*p++ = *(char *)(pPrefs++))!=0)
  303.                         ;
  304.                         
  305. #ifdef    GET_DESC
  306.                         p = SufMap.Description;
  307.                         while((*p++= *(char *)(pPrefs++))!=0)
  308.                         ;
  309. #else
  310.                         while(*(char *)(pPrefs++)!=0)
  311.                         ;
  312. #endif
  313.                         len = strlen(SufMap.Suffix);
  314.                         
  315.                         for( p = SufMap.Suffix, n = name + strlen(name) - len;
  316.                         (tolower(*p) == tolower(*n)) && (p<SufMap.Suffix+len);
  317.                         p++, n++)
  318.                         ;
  319.                     
  320.                         if ( n == name + strlen(name) )
  321.                         {
  322.                             SufMap.Found = true;
  323.                             break;
  324.                         }                        
  325.                     }
  326.  
  327.                     HUnlock( FPrefs );
  328.  
  329.                     if(SufMap.Found)
  330.                     {
  331.                         result = !SufMap.Binary;
  332.                     }
  333.                     else
  334.                     {
  335.                         result = 0;
  336.                     }
  337.                     
  338.                     break;
  339.                     
  340.                 case Never:
  341.                     result = 0;
  342.                     break;
  343.                     
  344.                 case UseMenu:
  345.                     result = currPrefs.ascii;
  346.                     break;
  347.                     
  348.                 default:
  349.                     break;
  350.             }
  351.         }
  352.     }
  353.     
  354.     return (result);
  355. }
  356.