home *** CD-ROM | disk | FTP | other *** search
/ Source Code 1994 March / Source_Code_CD-ROM_Walnut_Creek_March_1994.iso / compsrcs / misc / volume29 / unzip / part08 < prev    next >
Encoding:
Text File  |  1992-04-02  |  54.2 KB  |  1,803 lines
  1. Newsgroups: comp.sources.misc
  2. From: info-zip@cs.ucla.edu (Info-Zip)
  3. Subject:  v29i038:  unzip - Info-ZIP's portable UnZip v4.2, Part08/12
  4. Message-ID: <1992Apr3.063305.29044@sparky.imd.sterling.com>
  5. X-Md4-Signature: 66b1fd790fcb8bcabe1524123e87542d
  6. Date: Fri, 3 Apr 1992 06:33:05 GMT
  7. Approved: kent@sparky.imd.sterling.com
  8.  
  9. Submitted-by: info-zip@cs.ucla.edu (Info-Zip)
  10. Posting-number: Volume 29, Issue 38
  11. Archive-name: unzip/part08
  12. Environment: Unix, VMS, OS/2, MS-DOS, Amiga, Macintosh
  13. Supersedes: unzip, Volume 19, Issues 96-101
  14.  
  15. #! /bin/sh
  16. # This is a shell archive.  Remove anything before this line, then feed it
  17. # into a shell via "sh file" or similar.  To overwrite existing files,
  18. # type "sh file -c".
  19. # The tool that generated this appeared in the comp.sources.unix newsgroup;
  20. # send mail to comp-sources-unix@uunet.uu.net if you want that tool.
  21. # Contents:  MSDOS/bcc/unzip_cr.prj.u VMS/VMSmunch.c VMS/vms.c
  22. #   unimplod.c
  23. # Wrapped by kent@sparky on Mon Mar 30 01:45:54 1992
  24. PATH=/bin:/usr/bin:/usr/ucb ; export PATH
  25. echo If this archive is complete, you will see the following message:
  26. echo '          "shar: End of archive 8 (of 12)."'
  27. if test -f 'MSDOS/bcc/unzip_cr.prj.u' -a "${1}" != "-c" ; then 
  28.   echo shar: Will not clobber existing file \"'MSDOS/bcc/unzip_cr.prj.u'\"
  29. else
  30.   echo shar: Extracting \"'MSDOS/bcc/unzip_cr.prj.u'\" \(9233 characters\)
  31.   sed "s/^X//" >'MSDOS/bcc/unzip_cr.prj.u' <<'END_OF_FILE'
  32. Xbegin 666 MSDOS/bcc/unzip_cr.prj
  33. XM5'5R8F\@0R!0<F]J96-T($9I;&4@&@ !#1(7 1H  0<R $ 'R0 "  $ R@ "
  34. XM    RP "  $ S  "  $ S0 "  ( S@ "    SP "    T  "    T0 "    
  35. XMT@ "  $ TP "  $ U  "  , U@ " $  UP "  $ \0 !  #R  $  /,  0 !
  36. XM]  !  'U  $  ?8  @  @/<  0  ^  !  #Y  $  /H  @  (+ $ @   OL 
  37. XM 0  _  !  ']  $  /X  0  _P !     0$  0$! 0   P$!  $$ 0$   4!
  38. XM 0  !@$!  $' 0$ &0@! 0!D"0$! " * 0$   L! 0  # $!   - 0$   X!
  39. XM 0  #P$!   0 0$  !$! 0  $@$!   3 0$  !0! 0  %0$!  $6 0$  !<!
  40. XM @  @!@! 0  &0$"   !&@$!   ; 0$  !P! 0 !'0$!   > 0$  Q\! 0 !
  41. XM( $!   B 0$  ",! 0  ) $!   E 0$  "8! @#_?R<!   K 0(   !9 @$ 
  42. XM 6L" 0  6@(!  %; @$  5P" 0 !70(!  %> @$  5\" 0 !8 (!  %A @$ 
  43. XM 6(" 0 !8P(!  %D @$  64" 0 !9@(!  %G @$  6@" 0  :0(!  %L @$ 
  44. XM 6T" 0 !;@(!  %O @$  7 " 0 !<0(!  %R @$  7," 0 != (!  %U @$ 
  45. XM '8" 0 !=P(!  %X @$  7D" 0 !>@(!  %[ @$  7P" 0  C@(!  %] @$ 
  46. XM 7X" 0 !?P(!  &  @$  8$" 0 !@@(!  &# @$  80" 0 !A0(!  && @$ 
  47. XM 8<" 0 !B (!  &) @$  8H" 0 !BP(!  &, @$  8T" 0 !CP(!  &0 @$ 
  48. XM 9$" 0 !D@(!  &3 @$  2T!1                                   
  49. XM                                                         "X!
  50. XM@ !#.EQ"3U),04Y$7$E.0TQ51$4                                 
  51. XM                                                            
  52. XM                                                     "\!@ !#
  53. XM.EQ"3U),04Y$7$Q)0@                                          
  54. XM                                                            
  55. XM                                                 # !!  S,@  
  56. XM,0$% #(U    ,@$% #$P,   ,P%_ $-265!4 "!#4EE05               
  57. XM                                                            
  58. XM                                                            
  59. XM                   T 1X *@                                  
  60. XM    -0$> "H                                      #8!'@ J    
  61. XM                                   W 1X *@                  
  62. XM                    . $> "H                                 
  63. XM     #D!'@ J                                       Z 1X *@  
  64. XM                                    .P$> "H                 
  65. XM                     #P!'@ J                                
  66. XM       ] 1X *@                                      /@$> "H 
  67. XM                                     #\!'@ J                
  68. XM                      !  8                                  
  69. XM                                                            
  70. XM                                                            
  71. XM                  !$ 0@ ,S(W-C<   !% 0@ .#$Y,@    !& 7\     
  72. XM                                                            
  73. XM                                                            
  74. XM                                             $,!!0 N0P   /__
  75. XM   S  8  0"/8V<8"@#5" !^1U)%4                               
  76. XM                9W)E<                                       
  77. XM                                                            
  78. XM   M;BL@)$U%32@V-"D@)$Y/4U=!4" D4%)/35!4("1#05 @35-'*$=215 R
  79. XM35-'*79O:60@*BYC(                                           
  80. XM                                                            
  81. XM                                                            
  82. XM                             ,C_ 7Y4=7)B;R!!<W-E;6)L97(     
  83. XM                          !405--                            
  84. XM                                                            
  85. XM             "]-6" O6DD@+T\@)%1!4TT                         
  86. XM                                                            
  87. XM                                                            
  88. XM                                                            
  89. XM                                        R?\ 5'5R8F\@?D1E8G5G
  90. XM9V5R                                 '1D                    
  91. XM                                                            
  92. XM                        )$5814Y!344                         
  93. XM                                                            
  94. XM                                                            
  95. XM                                                            
  96. XM                                                  #*_P!4=7)B
  97. XM;R!^4')O9FEL97(                                 ='!R;V8     
  98. XM                                                            
  99. XM                                   D15A%3D%-10              
  100. XM                                                            
  101. XM                                                            
  102. XM                                                            
  103. XM                                                            
  104. XM ,O_ 5)^97-O=7)C92!#;VUP:6QE<@                            !2
  105. XM0P                                                          
  106. XM                                             "120P          
  107. XM                                                            
  108. XM                                                            
  109. XM                                                            
  110. XM                                                            
  111. XM            S/\!?DEM<&]R="!,:6)R87)I86X                     
  112. XM         $E-4$Q)0@                                          
  113. XM                                                        )$E-
  114. XM4$Q)0@                                                      
  115. XM                                                            
  116. XM                                                            
  117. XM                                                            
  118. XM                      #-____                                
  119. XM                                                            
  120. XM                                                            
  121. XM                                                            
  122. XM                                                            
  123. XM                                                            
  124. XM                                                            
  125. XM                                    -0 Z!   '@#28V<8$Q   -.3
  126. XM  "4!   54Y:25 N0P!53EI)4"Y#                                
  127. XM                                                       "  , 
  128. XM!  +       C5F<8__________\     1DE,15])3RY# $Q%7TE/+D,     
  129. XM                                                            
  130. XM                   %  8 !P *    (  H5F<89 (  )8    Y 0  34%0
  131. XM3D%-12Y# %!.04U%+D,                                         
  132. XM                                           +  P #0 )    %  L
  133. XM5F<82 (  !<   #+    34%40T@N0P!-051#2"Y#                    
  134. XM                                                            
  135. XM       .  \ $  (    %@ S5F<8P@0  $\$  "9 @  34E30RY# %Q-25-#
  136. XM+D,                                                         
  137. XM                               1 !( $P '    &  X5F<88 4  !@&
  138. XM  "  0  54Y)35!,3T0N0P!-4$Q/1"Y#                            
  139. XM                                                       4 !4 
  140. XM%@ &    &@ ]5F<8H ,  "(#  "^    54Y214150T4N0P!%1%5#12Y#    
  141. XM                                                            
  142. XM                   7 !@ &0 %    ' !$5F<8:@,   @   "S    54Y3
  143. XM2%))3DLN0P!(4DE.2RY#                                        
  144. XM                                           : !L '  $        
  145. XM    __________\     15A44D%#5"Y# %1204-4+D,                 
  146. XM                                                            
  147. XM       = !X 'P #            __________\     0U)94%0N0P!#4EE0
  148. XM5"Y#                                                        
  149. XM                               *  D "  "  " -@ >!2(   #__Q$%
  150. XM! 7D!,0$I 2$!& $/009!/P#W0.] YP#>P-: _____\Z DL#U@$^ W(!,@,.
  151. XM 2(#J@ 2 T8  @.> O__1@   !   P!YMF88!  EF&48!0  $! 7!@  $! 7
  152. XM!P  $! 7"   $! 7"0  $$T6"@  $! 7"P  $! 7#   $! 7#0  $! 7#@  
  153. XM$! 7#P  $! 7$   $! 7$0  $! 7__\    #   0 !\ <%R$%00 )9AE& 4 
  154. XM ! 0%P8  ! 0%P<  ! 0%P@  ! 0%PD  !!-%@H  ! 0%PL  ! 0%PP  ! 0
  155. XM%PT  ! 0%PX  ! 0%P\  ! 0%Q   ! 0%Q$  ! 0%___3" @(   $  = /:B
  156. XM8A<$ "6891@%   0$!<&   0$!<'   0$!<(   0$!<)   0318*   0$!<+
  157. XM   0$!<,   0$!<-   0$!<.   0$!</   0$!<0   0$!<1   0$!?__TP@
  158. XM("   !  &P"EA4$8!  EF&48!0  $! 7!@  $! 7!P  $! 7"   $! 7"0  
  159. XM$$T6"@  $! 7"P  $! 7#   $! 7#0  $! 7#@  $! 7#P  $! 7$   $! 7
  160. XM$0  $! 7__],(" @   0 !D 3(YC& 0 )9AE& 4  ! 0%P8  ! 0%P<  ! 0
  161. XM%P@  ! 0%PD  !!-%@H  ! 0%PL  ! 0%PP  ! 0%PT  ! 0%PX  ! 0%P\ 
  162. XM ! 0%Q   ! 0%Q$  ! 0%___3" @(   $  7 &R.01@$ "6891@%   0$!<&
  163. XM   0$!<'   0$!<(   0$!<)   0318*   0$!<+   0$!<,   0$!<-   0
  164. XM$!<.   0$!</   0$!<0   0$!<1   0$!?__TP@("   !  %0#0?&48!  E
  165. XMF&48!0  $! 7!@  $! 7!P  $! 7"   $! 7"0  $$T6"@  $! 7"P  $! 7
  166. XM#   $! 7#0  $! 7#@  $! 7#P  $! 7$   $! 7$0  $! 7__],(" @____
  167. XM__]53E-(4DE.2RY# /______54Y214150T4N0P#______U5.24U03$]$+D, 
  168. XM______]-25-#+D, ______]-051#2"Y# /______34%03D%-12Y# /______
  169. XM+BY<0D]23$%.1%Q)3D-,541%7$Q)34E44RY( /______+BY<0D]23$%.1%Q)
  170. XM3D-,541%7%-44DE.1RY( /______+BY<0D]23$%.1%Q)3D-,541%7%-41$Q)
  171. XM0BY( /______+BY<0D]23$%.1%Q)3D-,541%7$9#3E1,+D@ ______\N+EQ"
  172. XM3U),04Y$7$E.0TQ51$5<5$E-12Y( /______+BY<0D]23$%.1%Q)3D-,541%
  173. XM7$E/+D@ ______\N+EQ"3U),04Y$7$E.0TQ51$5<4UE37%1)345"+D@ ____
  174. XM__\N+EQ"3U),04Y$7$E.0TQ51$5<4UE37%-4050N2 #______RXN7$)/4DQ!
  175. XM3D1<24Y#3%5$15Q365-<5%E015,N2 #______RXN7$)/4DQ!3D1<24Y#3%5$
  176. XM15Q%4E).3RY( /______+BY<0D]23$%.1%Q)3D-,541%7$-465!%+D@ ____
  177. XM__\N+EQ"3U),04Y$7$E.0TQ51$5<7T1%1E,N2 #______RXN7$)/4DQ!3D1<
  178. XM24Y#3%5$15Q35$1)3RY( /______54Y:25 N2 #______U5.6DE0+D, -P!@
  179. XM "    !? %X 70!< %L 6@!" $, 1 !9 %@ 5P!6 %4 5 !3 %( 40!0 $\ 
  180. XM3@!- $P 2P!* $D 2 !' $8 10!"                                
  181. X+         /__    
  182. X 
  183. Xend
  184. END_OF_FILE
  185.   if test 9233 -ne `wc -c <'MSDOS/bcc/unzip_cr.prj.u'`; then
  186.     echo shar: \"'MSDOS/bcc/unzip_cr.prj.u'\" unpacked with wrong size!
  187.   else
  188.     echo shar: Uudecoding \"'MSDOS/bcc/unzip_cr.prj.u'\"
  189.     cat MSDOS/bcc/unzip_cr.prj.u | uudecode
  190.     if [ -f MSDOS/bcc/unzip_cr.prj.u ]; then
  191.        rm MSDOS/bcc/unzip_cr.prj.u
  192.     fi
  193.   fi
  194.   # end of 'MSDOS/bcc/unzip_cr.prj.u'
  195. fi
  196. if test -f 'VMS/VMSmunch.c' -a "${1}" != "-c" ; then 
  197.   echo shar: Will not clobber existing file \"'VMS/VMSmunch.c'\"
  198. else
  199.   echo shar: Extracting \"'VMS/VMSmunch.c'\" \(11678 characters\)
  200.   sed "s/^X//" >'VMS/VMSmunch.c' <<'END_OF_FILE'
  201. X/*---------------------------------------------------------------------------
  202. X
  203. X  VMSmunch.c                    version 1.1                      7 Feb 1992
  204. X
  205. X  This routine is a blatant and unrepentent appropriation of all the nasty
  206. X  and difficult-to-do and complicated VMS shenanigans which Joe Meadows has
  207. X  so magnificently captured in his FILE utility.  Not only that, it's even
  208. X  allowed! (see below).  But let it be clear at the outset that Joe did all
  209. X  the work; yea, verily, he is truly a godlike unit.
  210. X
  211. X  The appropriations and modifications herein were performed primarily by
  212. X  him known as "Cave Newt," although the Info-ZIP working group probably had
  213. X  their fingers in it somewhere along the line.  The idea is to put the raw
  214. X  power of Joe's original routine at the disposal of various routines used
  215. X  by UnZip (and Zip, possibly), not least among them the utime() function.
  216. X  Read on for details...
  217. X
  218. X  ---------------------------------------------------------------------------
  219. X
  220. X  Usage (i.e., "interface," in geek-speak):
  221. X
  222. X     int VMSmunch( char *filename, int action, char *ptr );
  223. X
  224. X     filename   the name of the file on which to be operated, obviously
  225. X     action     an integer which specifies what action to take
  226. X     ptr        pointer to any extra item which may be needed (else NULL)
  227. X
  228. X  The possible values for the action argument are as follows:
  229. X
  230. X     GET_TIMES      get the creation and revision dates of filename; ptr
  231. X                    must point to an empty VMStimbuf struct, as defined below
  232. X                    (with room for at least 24 characters, including term.)
  233. X     SET_TIMES      set the creation and revision dates of filename (utime
  234. X                    option); ptr must point to a valid VMStimbuf struct,
  235. X                    as defined below
  236. X     GET_RTYPE      get the record type of filename; ptr must point to an
  237. X                    integer which, on return, is set to the type (as defined
  238. X                    in fatdef.h:  FAT$C_* defines)
  239. X     CHANGE_RTYPE   change the record type to that specified by the integer
  240. X                    to which ptr points; save the old record type (later
  241. X                    saves overwrite earlier ones)
  242. X     RESTORE_RTYPE  restore the record type to the previously saved value;
  243. X                    or, if none, set it to "fixed-length, 512-byte" record
  244. X                    format (ptr not used)
  245. X
  246. X  ---------------------------------------------------------------------------
  247. X
  248. X  Comments from FILE.C, a utility to modify file characteristics:
  249. X
  250. X     Written by Joe Meadows Jr, at the Fred Hutchinson Cancer Research Center
  251. X     BITNET: JOE@FHCRCVAX
  252. X     PHONE: (206) 467-4970
  253. X
  254. X     There are no restrictions on this code, you may sell it, include it 
  255. X     with any commercial package, or feed it to a whale.. However, I would 
  256. X     appreciate it if you kept this comment in the source code so that anyone
  257. X     receiving this code knows who to contact in case of problems. Note that 
  258. X     I do not demand this condition..
  259. X
  260. X  ---------------------------------------------------------------------------*/
  261. X
  262. X
  263. X
  264. X
  265. X/*****************************/
  266. X/*  Includes, Defines, etc.  */
  267. X/*****************************/
  268. X
  269. X#include <descrip.h>
  270. X#include <rms.h>
  271. X#include <stdio.h>
  272. X#include <iodef.h>
  273. X#include <atrdef.h>   /* this gets created with the c3.0 compiler */
  274. X#include <fibdef.h>   /* this gets created with the c3.0 compiler */
  275. X
  276. X#include "fatdef.h"
  277. X#include "fchdef.h"
  278. X#include "fjndef.h"
  279. X
  280. X#include "VMSmunch.h"  /* GET/SET_TIMES, RTYPE, etc. */
  281. X
  282. X#define RTYPE     fat$r_rtype_overlay.fat$r_rtype_bits
  283. X#define RATTRIB   fat$r_rattrib_overlay.fat$r_rattrib_bits
  284. X
  285. Xstatic void asctim();
  286. Xstatic void bintim();
  287. X
  288. Xstruct VMStimbuf {      /* VMSmunch */
  289. X    char *actime;       /* VMS revision date, ASCII format */
  290. X    char *modtime;      /* VMS creation date, ASCII format */
  291. X};
  292. X
  293. X/* from <ssdef.h> */
  294. X#ifndef SS$_NORMAL
  295. X#  define SS$_NORMAL    1
  296. X#  define SS$_BADPARAM  20
  297. X#endif
  298. X
  299. X
  300. X
  301. X
  302. X
  303. X/*************************/
  304. X/*  Function VMSmunch()  */
  305. X/*************************/
  306. X
  307. Xint VMSmunch( filename, action, ptr )
  308. X    char  *filename, *ptr;
  309. X    int   action;
  310. X{
  311. X
  312. X    /* original file.c variables */
  313. X
  314. X    static struct FAB Fab;
  315. X    static struct NAM Nam;
  316. X    static struct fibdef Fib; /* short fib */
  317. X
  318. X    static struct dsc$descriptor FibDesc =
  319. X      {sizeof(Fib),DSC$K_DTYPE_Z,DSC$K_CLASS_S,&Fib};
  320. X    static struct dsc$descriptor_s DevDesc =
  321. X      {0,DSC$K_DTYPE_T,DSC$K_CLASS_S,&Nam.nam$t_dvi[1]};
  322. X    static struct fatdef Fat;
  323. X    static union {
  324. X      struct fchdef fch;
  325. X      long int dummy;
  326. X    } uchar;
  327. X    static struct fjndef jnl;
  328. X    static long int Cdate[2],Rdate[2],Edate[2],Bdate[2];
  329. X    static short int revisions;
  330. X    static unsigned long uic;
  331. X    static union {
  332. X      unsigned short int value;
  333. X      struct {
  334. X        unsigned system : 4;
  335. X        unsigned owner : 4;
  336. X        unsigned group : 4;
  337. X        unsigned world : 4;
  338. X      } bits;
  339. X    } prot;
  340. X
  341. X    static struct atrdef Atr[] = {
  342. X      {sizeof(Fat),ATR$C_RECATTR,&Fat},        /* record attributes */
  343. X      {sizeof(uchar),ATR$C_UCHAR,&uchar},      /* File characteristics */
  344. X      {sizeof(Cdate),ATR$C_CREDATE,&Cdate[0]}, /* Creation date */
  345. X      {sizeof(Rdate),ATR$C_REVDATE,&Rdate[0]}, /* Revision date */
  346. X      {sizeof(Edate),ATR$C_EXPDATE,&Edate[0]}, /* Expiration date */
  347. X      {sizeof(Bdate),ATR$C_BAKDATE,&Bdate[0]}, /* Backup date */
  348. X      {sizeof(revisions),ATR$C_ASCDATES,&revisions}, /* number of revisions */
  349. X      {sizeof(prot),ATR$C_FPRO,&prot},         /* file protection  */
  350. X      {sizeof(uic),ATR$C_UIC,&uic},            /* file owner */
  351. X      {sizeof(jnl),ATR$C_JOURNAL,&jnl},        /* journal flags */
  352. X      {0,0,0}
  353. X    } ;
  354. X
  355. X    static char EName[NAM$C_MAXRSS];
  356. X    static char RName[NAM$C_MAXRSS];
  357. X    static struct dsc$descriptor_s FileName =
  358. X      {0,DSC$K_DTYPE_T,DSC$K_CLASS_S,0};
  359. X    static struct dsc$descriptor_s string = {0,DSC$K_DTYPE_T,DSC$K_CLASS_S,0};
  360. X    static short int DevChan;
  361. X    static short int iosb[4];
  362. X
  363. X    static long int i,status;
  364. X/*  static char *retval;  */
  365. X
  366. X
  367. X    /* new VMSmunch variables */
  368. X
  369. X    static int  old_rtype=FAT$C_FIXED;   /* storage for record type */
  370. X
  371. X
  372. X
  373. X/*---------------------------------------------------------------------------
  374. X    Initialize attribute blocks, parse filename, resolve any wildcards, and
  375. X    get the file info.
  376. X  ---------------------------------------------------------------------------*/
  377. X
  378. X    /* initialize RMS structures, we need a NAM to retrieve the FID */
  379. X    Fab = cc$rms_fab;
  380. X    Fab.fab$l_fna = filename;
  381. X    Fab.fab$b_fns = strlen(filename);
  382. X    Fab.fab$l_nam = &Nam; /* FAB has an associated NAM */
  383. X    Nam = cc$rms_nam;
  384. X    Nam.nam$l_esa = &EName; /* expanded filename */
  385. X    Nam.nam$b_ess = sizeof(EName);
  386. X    Nam.nam$l_rsa = &RName; /* resultant filename */
  387. X    Nam.nam$b_rss = sizeof(RName);
  388. X
  389. X    /* do $PARSE and $SEARCH here */
  390. X    status = sys$parse(&Fab);
  391. X    if (!(status & 1)) return(status);
  392. X
  393. X    /* search for the first file.. If none signal error */
  394. X    status = sys$search(&Fab);
  395. X    if (!(status & 1)) return(status);
  396. X
  397. X    while (status & 1) {
  398. X        /* initialize Device name length, note that this points into the NAM
  399. X           to get the device name filled in by the $PARSE, $SEARCH services */
  400. X        DevDesc.dsc$w_length = Nam.nam$t_dvi[0];
  401. X
  402. X        status = sys$assign(&DevDesc,&DevChan,0,0);
  403. X        if (!(status & 1)) return(status);
  404. X
  405. X        FileName.dsc$a_pointer = Nam.nam$l_name;
  406. X        FileName.dsc$w_length = Nam.nam$b_name+Nam.nam$b_type+Nam.nam$b_ver;
  407. X
  408. X        /* Initialize the FIB */
  409. X        for (i=0;i<3;i++)
  410. X            Fib.fib$r_fid_overlay.fib$w_fid[i]=Nam.nam$w_fid[i];
  411. X        for (i=0;i<3;i++)
  412. X            Fib.fib$r_did_overlay.fib$w_did[i]=Nam.nam$w_did[i];
  413. X
  414. X        /* Use the IO$_ACCESS function to return info about the file */
  415. X        /* Note, used this way, the file is not opened, and the expiration */
  416. X        /* and revision dates are not modified */
  417. X        status = sys$qiow(0,DevChan,IO$_ACCESS,&iosb,0,0,
  418. X                          &FibDesc,&FileName,0,0,&Atr,0);
  419. X        if (!(status & 1)) return(status);
  420. X        status = iosb[0];
  421. X        if (!(status & 1)) return(status);
  422. X
  423. X    /*-----------------------------------------------------------------------
  424. X        We have the current information from the file:  now see what user
  425. X        wants done with it.
  426. X      -----------------------------------------------------------------------*/
  427. X
  428. X        switch (action) {
  429. X
  430. X          case GET_TIMES:
  431. X              asctim(((struct VMStimbuf *)ptr)->modtime, Cdate);
  432. X              asctim(((struct VMStimbuf *)ptr)->actime, Rdate);
  433. X              break;
  434. X
  435. X          case SET_TIMES:
  436. X              bintim(((struct VMStimbuf *)ptr)->modtime, Cdate);
  437. X              bintim(((struct VMStimbuf *)ptr)->actime, Rdate);
  438. X              break;
  439. X
  440. X          case GET_RTYPE:   /* non-modifying */
  441. X              *(int *)ptr = Fat.RTYPE.fat$v_rtype;
  442. X              return RMS$_NORMAL;     /* return to user */
  443. X              break;
  444. X
  445. X          case CHANGE_RTYPE:
  446. X              old_rtype = Fat.RTYPE.fat$v_rtype;         /* save current one */
  447. X              if ((*(int *)ptr < FAT$C_UNDEFINED) || 
  448. X                  (*(int *)ptr > FAT$C_STREAMCR))
  449. X                  Fat.RTYPE.fat$v_rtype = FAT$C_STREAMLF;  /* Unix I/O happy */
  450. X              else
  451. X                  Fat.RTYPE.fat$v_rtype = *(int *)ptr;
  452. X              break;
  453. X
  454. X          case RESTORE_RTYPE:
  455. X              Fat.RTYPE.fat$v_rtype = old_rtype;
  456. X              break;
  457. X
  458. X          default:
  459. X              return SS$_BADPARAM;   /* anything better? */
  460. X        }
  461. X
  462. X    /*-----------------------------------------------------------------------
  463. X        Go back and write modified data to the file header.
  464. X      -----------------------------------------------------------------------*/
  465. X
  466. X        /* note, part of the FIB was cleared by earlier QIOW, so reset it */
  467. X        Fib.fib$r_acctl_overlay.fib$l_acctl = FIB$M_NORECORD;
  468. X        for (i=0;i<3;i++)
  469. X            Fib.fib$r_fid_overlay.fib$w_fid[i]=Nam.nam$w_fid[i];
  470. X        for (i=0;i<3;i++)
  471. X            Fib.fib$r_did_overlay.fib$w_did[i]=Nam.nam$w_did[i];
  472. X
  473. X        /* Use the IO$_MODIFY function to change info about the file */
  474. X        /* Note, used this way, the file is not opened, however this would */
  475. X        /* normally cause the expiration and revision dates to be modified. */
  476. X        /* Using FIB$M_NORECORD prohibits this from happening. */
  477. X        status = sys$qiow(0,DevChan,IO$_MODIFY,&iosb,0,0,
  478. X                          &FibDesc,&FileName,0,0,&Atr,0);
  479. X        if (!(status & 1)) return(status);
  480. X
  481. X        status = iosb[0];
  482. X        if (!(status & 1)) return(status);
  483. X
  484. X        status = sys$dassgn(DevChan);
  485. X        if (!(status & 1)) return(status);
  486. X
  487. X        /* look for next file, if none, no big deal.. */
  488. X        status = sys$search(&Fab);
  489. X    }
  490. X} /* end function VMSmunch() */
  491. X
  492. X
  493. X
  494. X
  495. X
  496. X/***********************/
  497. X/*  Function bintim()  */
  498. X/***********************/
  499. X
  500. Xvoid asctim(time,binval)   /* convert 64-bit binval to string, put in time */
  501. X    char *time;
  502. X    long int binval[2];
  503. X{
  504. X    static struct dsc$descriptor date_str={23,DSC$K_DTYPE_T,DSC$K_CLASS_S,0};
  505. X      /* dsc$w_length, dsc$b_dtype, dsc$b_class, dsc$a_pointer */
  506. X 
  507. X    date_str.dsc$a_pointer = time;
  508. X    sys$asctim(0, &date_str, binval, 0);
  509. X    time[23] = '\0';
  510. X}
  511. X
  512. X
  513. X
  514. X
  515. X
  516. X/***********************/
  517. X/*  Function bintim()  */
  518. X/***********************/
  519. X
  520. Xvoid bintim(time,binval)   /* convert time string to 64 bits, put in binval */
  521. X    char *time;
  522. X    long int binval[2];
  523. X{
  524. X    static struct dsc$descriptor date_str={0,DSC$K_DTYPE_T,DSC$K_CLASS_S,0};
  525. X
  526. X    date_str.dsc$w_length = strlen(time);
  527. X    date_str.dsc$a_pointer = time;
  528. X    sys$bintim(&date_str, binval);
  529. X}
  530. END_OF_FILE
  531.   if test 11678 -ne `wc -c <'VMS/VMSmunch.c'`; then
  532.     echo shar: \"'VMS/VMSmunch.c'\" unpacked with wrong size!
  533.   fi
  534.   # end of 'VMS/VMSmunch.c'
  535. fi
  536. if test -f 'VMS/vms.c' -a "${1}" != "-c" ; then 
  537.   echo shar: Will not clobber existing file \"'VMS/vms.c'\"
  538. else
  539.   echo shar: Extracting \"'VMS/vms.c'\" \(20178 characters\)
  540.   sed "s/^X//" >'VMS/vms.c' <<'END_OF_FILE'
  541. X/*************************************************************************
  542. X *                                                                       *
  543. X * Copyright (C) 1992 Igor Mandrichenko.                                 *
  544. X * Permission is granted to any individual or institution to use, copy,  *
  545. X * or redistribute this software so long as all of the original files    *
  546. X * are included unmodified, that it is not sold for profit, and that     *
  547. X * this copyright notice is retained.                                    *
  548. X *                                                                       *
  549. X *************************************************************************/
  550. X
  551. X/*
  552. X *    vms.c  by Igor Mandrichenko
  553. X *    version 1.1-2
  554. X *
  555. X *    This module contains routines to extract VMS file attributes
  556. X *    from extra field and create file with these attributes.  This
  557. X *    source is mainly based on sources of file_io.c from UNZIP 4.1
  558. X *    by Info-ZIP.  [Info-ZIP note:  very little of this code is from
  559. X *    file_io.c; it has virtually been written from the ground up.
  560. X *    Of the few lines which are from the older code, most are mine
  561. X *    (G. Roelofs) and I make no claims upon them.  On the contrary,
  562. X *    my/our thanks to Igor for his contributions!]
  563. X */
  564. X
  565. X/* 
  566. X *    Revision history:
  567. X *    1.0-1    Mandrichenko    16-feb-1992
  568. X *        Recognize -c option
  569. X *    1.0-2    Mandrichenko    17-feb-1992
  570. X *        Do not use ASYnchroneous mode.
  571. X *    1.0-3   Mandrichenko    2-mar-1992
  572. X *        Make code more standard
  573. X *        Use lrec instead of crec -- unzip4.2p do not provide 
  574. X *        crec now.
  575. X *      1.1    Mandrichenko    5-mar-1992  
  576. X *        Make use of asynchronous output.
  577. X *        Be ready to extract RMS blocks of invalid size (because diff
  578. X *              VMS version used to compress).
  579. X *    1.1-1    Mandrichenko    11-mar-1992
  580. X *        Use internal file attributes saved in pInfo to decide
  581. X *        if the file is text.  [GRR:  temporarily disabled, since
  582. X *              no way to override and force binary extraction]
  583. X *    1.1-2   Mandrichenko    13-mar-1992
  584. X *        Do not restore owner/protection info if -X not specified.
  585. X */
  586. X
  587. X#ifdef VMS            /*    VMS only !    */
  588. X
  589. X/************************************/
  590. X/*  File_IO Includes, Defines, etc. */
  591. X/************************************/
  592. X
  593. X#ifdef VAXC
  594. X#include rms
  595. X#include descrip
  596. X#include syidef
  597. X#else
  598. X#include <rms.h>
  599. X#include <descrip.h>
  600. X#include <syidef.h>
  601. X#endif
  602. X
  603. X#include "unzip.h"
  604. X
  605. X#define ERR(s) !((s) & 1)
  606. X
  607. X#define BUFS512    8192*2    /* Must be a multiple of 512 */
  608. X
  609. Xstatic int WriteBuffer __((int fd, unsigned char *buf, int len));
  610. Xstatic int _flush_blocks __((void));
  611. Xstatic int _flush_records __((void));
  612. Xstatic byte *extract_block __((byte *));
  613. X
  614. X/*
  615. X*   Local static storage
  616. X*/
  617. Xstatic struct FAB *outfab = 0;
  618. Xstatic struct RAB *outrab = 0;
  619. Xstatic struct FAB fileblk;
  620. Xstatic struct XABFHC *xabfhc = 0;
  621. Xstatic struct XABDAT dattim, *xabdat = 0;
  622. Xstatic struct XABRDT *xabrdt = 0;
  623. Xstatic struct XABPRO *xabpro = 0;
  624. Xstatic struct XABKEY *xabkey = 0;
  625. Xstatic struct XABALL *xaball = 0;
  626. Xstatic struct RAB rab;
  627. X
  628. Xstatic int text_file = 0;
  629. X
  630. Xstatic char locbuf[BUFS512];
  631. Xstatic int loccnt = 0;
  632. Xstatic char *locptr;
  633. X
  634. X
  635. Xstruct bufdsc
  636. X{    struct bufdsc    *next;
  637. X    byte *buf;
  638. X    int bufcnt;
  639. X};
  640. X
  641. Xstatic struct bufdsc b1,b2,*curbuf;
  642. Xstatic byte buf1[BUFS512],buf2[BUFS512];
  643. X
  644. Xint create_output_file()
  645. X{                /* return non-0 if sys$create failed */
  646. X    int ierr, yr, mo, dy, hh, mm, ss;
  647. X    char timbuf[24];        /* length = first entry in "stupid" + 1 */
  648. X    int attr_given = 0;        /* =1 if VMS attributes are present in
  649. X                *     extra_field */
  650. X
  651. X    rab = cc$rms_rab;        /* fill FAB & RAB with default values */
  652. X    fileblk = cc$rms_fab;
  653. X
  654. X    text_file = /* pInfo->text || */ aflag || cflag;
  655. X
  656. X    if (attr_given = find_vms_attrs())
  657. X    {    text_file = 0;
  658. X    if( cflag )
  659. X    {    printf("Can not put VMS file %s to stdout.\n",
  660. X            filename);
  661. X        return 50;
  662. X    }
  663. X    }
  664. X    
  665. X    if (!attr_given)
  666. X    {
  667. X    outfab = &fileblk;
  668. X    outfab->fab$l_xab = 0L;
  669. X    if (text_file)
  670. X    {
  671. X        outfab->fab$b_rfm = FAB$C_VAR;    /* variable length records */
  672. X        outfab->fab$b_rat = FAB$M_CR;    /* carriage-return carriage ctrl */
  673. X    }
  674. X    else
  675. X    {
  676. X        outfab->fab$b_rfm = FAB$C_STMLF;    /* stream-LF record format */
  677. X        outfab->fab$b_rat = FAB$M_CR;    /* carriage-return carriage ctrl */
  678. X    }
  679. X    }
  680. X
  681. X    if(!cflag)
  682. X        outfab->fab$l_fna = filename;
  683. X    else
  684. X        outfab->fab$l_fna = "sys$output:";
  685. X
  686. X    outfab->fab$b_fns = strlen(outfab->fab$l_fna);
  687. X
  688. X    if (!attr_given || xabdat == 0)
  689. X    {
  690. X    static char *month[] =
  691. X        {"JAN", "FEB", "MAR", "APR", "MAY", "JUN",
  692. X         "JUL", "AUG", "SEP", "OCT", "NOV", "DEC"};
  693. X    /*  fixed-length string descriptor (why not just a pointer to timbuf? sigh.) */
  694. X    struct dsc$descriptor stupid =
  695. X        {23, DSC$K_DTYPE_T, DSC$K_CLASS_S, timbuf};
  696. X
  697. X    yr = ((lrec.last_mod_file_date >> 9) & 0x7f) + 1980;    /* dissect date */
  698. X    mo = ((lrec.last_mod_file_date >> 5) & 0x0f) - 1;
  699. X    dy = (lrec.last_mod_file_date & 0x1f);
  700. X    hh = (lrec.last_mod_file_time >> 11) & 0x1f;    /* dissect time */
  701. X    mm = (lrec.last_mod_file_time >> 5) & 0x3f;
  702. X    ss = (lrec.last_mod_file_time & 0x1f) * 2;
  703. X
  704. X    dattim = cc$rms_xabdat;    /* fill XAB with default values */
  705. X    dattim.xab$l_nxt = outfab->fab$l_xab;
  706. X    outfab->fab$l_xab = (char*)(xabdat = &dattim);
  707. X
  708. X    sprintf(timbuf, "%02d-%3s-%04d %02d:%02d:%02d.00", dy, month[mo], yr,
  709. X        hh, mm, ss);
  710. X    sys$bintim(&stupid, &dattim.xab$q_cdt);
  711. X    }
  712. X
  713. X#ifdef DEBUG
  714. X    printf("XAB chain before CREATE dump:\n");
  715. X    dump_rms_block(outfab);
  716. X    {
  717. X    struct XABALL *x;
  718. X    for (x = outfab->fab$l_xab; x != 0L; x = x->xab$l_nxt)
  719. X        dump_rms_block(x);
  720. X    }
  721. X#endif
  722. X
  723. X    outfab->fab$w_ifi = 0;    /* Clear IFI. It may be nonzero after ZIP */
  724. X
  725. X    if ((ierr = sys$create(outfab)) != RMS$_NORMAL)
  726. X    {
  727. X    message("[ can not create output file ]\n", ierr);
  728. X    message("", outfab->fab$l_stv);
  729. X    fprintf(stderr, "Can't create output file:  %s\n", filename);
  730. X    return (1);
  731. X    }
  732. X
  733. X    if (!text_file && !cflag)    /* Do not reopen text files and stdout
  734. X                *  Just open them in right mode        */
  735. X    {
  736. X    /*
  737. X    *    Reopen file for Block I/O with no XABs.
  738. X    */
  739. X    if ((ierr = sys$close(outfab)) != RMS$_NORMAL)
  740. X    {
  741. X#ifdef DEBUG
  742. X        message("[ create_output_file: sys$close failed ]\n", ierr);
  743. X        message("", outfab->fab$l_stv);
  744. X#endif
  745. X        fprintf(stderr, "Can't create output file:  %s\n", filename);
  746. X        return (1);
  747. X    }
  748. X
  749. X
  750. X    outfab->fab$b_fac = FAB$M_BIO | FAB$M_PUT;    /* Get ready for block
  751. X                             * output */
  752. X    outfab->fab$l_xab = 0L;    /* Unlink all XABs */
  753. X
  754. X    if ((ierr = sys$open(outfab)) != RMS$_NORMAL)
  755. X    {
  756. X        message("[ Can not open output file ]\n", ierr);
  757. X        message("", outfab->fab$l_stv);
  758. X        return (1);
  759. X    }
  760. X    }
  761. X
  762. X    outrab = &rab;
  763. X    rab.rab$l_fab = outfab;
  764. X    if( !text_file ) rab.rab$l_rop |= RAB$M_BIO;
  765. X    if( !text_file ) rab.rab$l_rop |= RAB$M_ASY;
  766. X    rab.rab$b_rac = RAB$C_SEQ;
  767. X
  768. X    if ((ierr = sys$connect(outrab)) != RMS$_NORMAL)
  769. X    {
  770. X#ifdef DEBUG
  771. X    fprintf(stderr, "create_output_file: sys$connect failed on file %s\n",
  772. X        filename);
  773. X    fprintf(stderr, "                    status = %d\n", ierr);
  774. X    fprintf(stderr, "                   fab.sts = %d\n", outfab->fab$l_sts);
  775. X    fprintf(stderr, "                   fab.stv = %d\n", outfab->fab$l_stv);
  776. X#endif
  777. X    fprintf(stderr, "Can't create output file:  %s\n", filename);
  778. X    return (1);
  779. X    }
  780. X
  781. X    locptr = &locbuf[0];
  782. X    loccnt = 0;
  783. X
  784. X    b1.buf = &buf1[0];
  785. X    b1.bufcnt = 0;
  786. X    b1.next = &b2;
  787. X    b2.buf = &buf2[0];
  788. X    b2.bufcnt = 0;
  789. X    b2.next = &b1;
  790. X    curbuf = &b1;
  791. X
  792. X    return (0);
  793. X}
  794. X
  795. X/*
  796. X*   Extra record format
  797. X*   ===================
  798. X*   signature         (2 bytes)    = 'I','M'
  799. X*   size        (2 bytes)
  800. X*   block signature (4 bytes)
  801. X*   flags        (2 bytes)
  802. X*   uncomprssed size(2 bytes) 
  803. X*   reserved        (4 bytes) 
  804. X*   data        ((size-12) bytes)
  805. X*   ....
  806. X*/
  807. X
  808. Xstruct extra_block
  809. X{
  810. X    UWORD sig;            /* Extra field block header structure */
  811. X    UWORD size;
  812. X    ULONG bid;
  813. X    UWORD flags;
  814. X    UWORD length;
  815. X    ULONG reserved;
  816. X    byte body[1];
  817. X};
  818. X
  819. X/*
  820. X *   Extra field signature and block signatures
  821. X */
  822. X
  823. X#define SIGNATURE "IM"
  824. X#define FABL    (cc$rms_fab.fab$b_bln)
  825. X#define RABL    (cc$rms_rab.rab$b_bln)
  826. X#define XALLL    (cc$rms_xaball.xab$b_bln)
  827. X#define XDATL    (cc$rms_xabdat.xab$b_bln)
  828. X#define XFHCL    (cc$rms_xabfhc.xab$b_bln)
  829. X#define XKEYL    (cc$rms_xabkey.xab$b_bln)
  830. X#define XPROL    (cc$rms_xabpro.xab$b_bln)
  831. X#define XRDTL    (cc$rms_xabrdt.xab$b_bln)
  832. X#define XSUML    (cc$rms_xabsum.xab$b_bln)
  833. X#define EXTBSL  4        /* Block signature length   */
  834. X#define RESL    8        /* Rserved 8 bytes  */
  835. X#define EXTHL    (4+EXTBSL)
  836. X#define FABSIG    "VFAB"
  837. X#define XALLSIG    "VALL"
  838. X#define XFHCSIG    "VFHC"
  839. X#define XDATSIG    "VDAT"
  840. X#define XRDTSIG    "VRDT"
  841. X#define XPROSIG    "VPRO"
  842. X#define XKEYSIG    "VKEY"
  843. X#define XNAMSIG    "VNAM"
  844. X#define VERSIG  "VMSV"
  845. X
  846. X
  847. X
  848. X#define W(p)    (*(unsigned short*)(p))
  849. X#define L(p)    (*(unsigned long*)(p))
  850. X#define EQL_L(a,b)    ( L(a) == L(b) )
  851. X#define EQL_W(a,b)    ( W(a) == W(b) )
  852. X
  853. X/****************************************************************
  854. X * Function find_vms_attrs scans ZIP entry extra field if any   *
  855. X * and looks for VMS attribute records. Returns 0 if either no  *
  856. X * attributes found or no fab given.                            *
  857. X ****************************************************************/
  858. Xint find_vms_attrs()
  859. X{
  860. X    byte *scan = extra_field;
  861. X    struct extra_block *blk;
  862. X    struct XABALL *first_xab = 0L, *last_xab = 0L;
  863. X    int len;
  864. X
  865. X    outfab = xabfhc = xabdat = xabrdt = xabpro = 0L;
  866. X
  867. X    if (scan == NULL)
  868. X    return 0;
  869. X/*
  870. X    if (crec.extra_field_length)
  871. X    len = crec.extra_field_length;
  872. X    else
  873. X*/
  874. X    len = lrec.extra_field_length;
  875. X
  876. X#define LINK(p)    {                     \
  877. X        if( first_xab == 0L )            \
  878. X            first_xab = p;            \
  879. X        if( last_xab != 0L )            \
  880. X            last_xab -> xab$l_nxt = p;    \
  881. X        last_xab = p;                \
  882. X        p -> xab$l_nxt = 0;            \
  883. X    }
  884. X    /* End of macro LINK */
  885. X
  886. X    while (len > 0)
  887. X    {
  888. X    blk = (struct block *)scan;
  889. X    if (EQL_W(&blk->sig, SIGNATURE))
  890. X    {
  891. X        byte *block_id;
  892. X        block_id = &blk->bid;
  893. X        if (EQL_L(block_id, FABSIG))
  894. X        {
  895. X        outfab = (struct FAB *) extract_block(blk, 0,
  896. X                        &cc$rms_fab, FABL);
  897. X        }
  898. X        else if (EQL_L(block_id, XALLSIG))
  899. X        {
  900. X        xaball = (struct XABALL *) extract_block(blk, 0, 
  901. X                        &cc$rms_xaball, XALLL);
  902. X        LINK(xaball);
  903. X        }
  904. X        else if (EQL_L(block_id, XKEYSIG))
  905. X        {
  906. X        xabkey = (struct XABKEY *) extract_block(blk, 0,
  907. X                        &cc$rms_xabkey, XKEYL);
  908. X        LINK(xabkey);
  909. X        }
  910. X        else if (EQL_L(block_id, XFHCSIG))
  911. X        {
  912. X        xabfhc = (struct XABFHC *) extract_block(blk, 0,
  913. X                        &cc$rms_xabfhc, XFHCL);
  914. X        LINK(xabfhc);
  915. X        }
  916. X        else if (EQL_L(block_id, XDATSIG))
  917. X        {
  918. X        xabdat = (struct XABDAT *) extract_block(blk, 0,
  919. X                        &cc$rms_xabdat, XDATL);
  920. X        LINK(xabdat);
  921. X        }
  922. X        else if (EQL_L(block_id, XRDTSIG))
  923. X        {
  924. X        xabrdt = (struct XABRDT *) extract_block(blk, 0,
  925. X                        &cc$rms_xabrdt, XRDTL);
  926. X        /*    LINK(xabrdt);    -- Do not link xabrdt    */
  927. X        }
  928. X        else if (EQL_L(block_id, XPROSIG))
  929. X        {
  930. X        xabpro = (struct XABPRO *) extract_block(blk, 0,
  931. X                        &cc$rms_xabpro, XPROL);
  932. X        /*    LINK(xabpro);    -- Do not link xabpro
  933. X                       until close */
  934. X        }
  935. X        else if (EQL_L(block_id, VERSIG))
  936. X        {
  937. X        char verbuf[80];
  938. X        int verlen = 0;
  939. X        int vl = 0;
  940. X        int item = SYI$_VERSION;
  941. X        $DESCRIPTOR(version, verbuf);
  942. X        byte *vers;
  943. X
  944. X        lib$getsyi(&item, 0, &version, &verlen, 0, 0);
  945. X        verbuf[verlen] = 0;
  946. X        vers = extract_block(blk, &vl, 0, 0);
  947. X        if (strncmp(verbuf, vers, verlen))
  948. X        {
  949. X            printf("[ Warning: VMS version mismatch.");
  950. X
  951. X            printf("   This version %s --", verbuf);
  952. X            strncpy(verbuf, vers, vl);
  953. X            verbuf[vl] = 0;
  954. X            printf(" version made by %s ]\n", verbuf);
  955. X        }
  956. X        free(vers);
  957. X        }
  958. X        else
  959. X        fprintf(stderr, "[ Warning: Unknown block signature %s ]\n",
  960. X            block_id);
  961. X    }
  962. X    len -= blk->size + 4;
  963. X    scan += blk->size + 4;
  964. X    }
  965. X    if (outfab != 0)
  966. X    {
  967. X    outfab->fab$l_xab = first_xab;
  968. X    return 1;
  969. X    }
  970. X    else
  971. X    return 0;
  972. X}
  973. X
  974. X/******************************
  975. X *   Function extract_block   *
  976. X ******************************/
  977. X/*
  978. X *  Simple uncompression routne. The compression uses bit stream.
  979. X *  Compression scheme:
  980. X *
  981. X *  if(byte!=0)
  982. X *      putbit(1),putyte(byte)
  983. X *  else
  984. X *    putbit(0)
  985. X */
  986. Xstatic byte *extract_block(p, retlen, init, needlen)
  987. X    int *retlen;
  988. Xstruct extra_block *p;
  989. Xbyte *init;
  990. Xint needlen;
  991. X{
  992. X    byte *block;        /* Pointer to block allocated */
  993. X    byte *bitptr;        /* Pointer into compressed data */
  994. X    byte *outptr;        /* Pointer into output block */
  995. X    UWORD length;
  996. X    ULONG bitbuf = 0;
  997. X    int bitcnt = 0;
  998. X
  999. X#define _FILL     if(bitcnt+8 <= 32)            \
  1000. X        {    bitbuf |= (*bitptr++) << bitcnt;\
  1001. X            bitcnt += 8;            \
  1002. X        }
  1003. X
  1004. X
  1005. X    if( p->flags & 1 )
  1006. X    length = p->length;    /* Block is compressed */
  1007. X    else
  1008. X        length = p->size - EXTBSL - RESL;    /* Simple case, uncompressed */
  1009. X
  1010. X    if( needlen == 0 )
  1011. X    needlen = length;
  1012. X
  1013. X    if(retlen)
  1014. X    *retlen = needlen;
  1015. X
  1016. X    if( (p->flags & 1) || (needlen > length) )
  1017. X    {    if ((block = (byte*)malloc(needlen)) == NULL)
  1018. X        return NULL;
  1019. X    }
  1020. X/*
  1021. X    else if( needlen > length )
  1022. X    {    if ((block = (byte*)malloc(needlen)) == NULL)
  1023. X        return NULL;
  1024. X    }
  1025. X*/
  1026. X    else outptr = block = &p->body[0];
  1027. X
  1028. X    if(init && (length < needlen))
  1029. X    memcpy(block,init,needlen);
  1030. X
  1031. X    if ((p->flags & 1) == 0)
  1032. X    return block;        /* Do nothing more if uncompressed */
  1033. X
  1034. X    outptr = block;
  1035. X    bitptr = &p->body[0];
  1036. X
  1037. X    if(length > needlen)
  1038. X    length = needlen;
  1039. X
  1040. X    while (length--)
  1041. X    {
  1042. X    if (bitcnt <= 0)
  1043. X        _FILL;
  1044. X
  1045. X    if (bitbuf & 1)
  1046. X    {
  1047. X        bitbuf >>= 1;
  1048. X        if ((bitcnt -= 1) < 8)
  1049. X        _FILL;
  1050. X        *outptr++ = (byte) bitbuf;
  1051. X        bitcnt -= 8;
  1052. X        bitbuf >>= 8;
  1053. X    }
  1054. X    else
  1055. X    {
  1056. X        *outptr++ = 0;
  1057. X        bitcnt -= 1;
  1058. X        bitbuf >>= 1;
  1059. X    }
  1060. X    }
  1061. X    return block;
  1062. X}
  1063. X
  1064. X/***************************/
  1065. X/*  Function FlushOutput() */
  1066. X/***************************/
  1067. X
  1068. Xint FlushOutput()
  1069. X{                /* return PK-type error code */
  1070. X    /* flush contents of output buffer */
  1071. X    if (tflag)
  1072. X    {                /* Do not output. Update CRC only */
  1073. X    UpdateCRC(outbuf, outcnt);
  1074. X    outpos += outcnt;
  1075. X    outcnt = 0;
  1076. X    outptr = outbuf;
  1077. X    return 0;
  1078. X    }
  1079. X    else
  1080. X    return text_file ? _flush_records(0) : _flush_blocks(0);
  1081. X}
  1082. X
  1083. Xstatic int _flush_blocks(final_flag)    /* Asynchronous version */
  1084. X  int final_flag;
  1085. X/* 1 if this is the final flushout */
  1086. X{
  1087. X    int round;
  1088. X    int rest;
  1089. X    int off = 0;
  1090. X    int out_count = outcnt;
  1091. X    int status;
  1092. X
  1093. X    while(out_count > 0)
  1094. X    {    if( curbuf -> bufcnt < BUFS512 )
  1095. X    {    int ncpy;
  1096. X        ncpy = out_count > (BUFS512-curbuf->bufcnt) ? 
  1097. X                BUFS512-curbuf->bufcnt : 
  1098. X                out_count;
  1099. X        memcpy(curbuf->buf + curbuf->bufcnt, outbuf+off, ncpy);
  1100. X        out_count -= ncpy;
  1101. X        curbuf -> bufcnt += ncpy;
  1102. X        off += ncpy;
  1103. X    }        
  1104. X    if( curbuf -> bufcnt == BUFS512 )
  1105. X    {
  1106. X        status = WriteBuffer(curbuf->buf,curbuf->bufcnt);
  1107. X        if(status)
  1108. X            return status;
  1109. X        curbuf = curbuf -> next;
  1110. X        curbuf -> bufcnt = 0;
  1111. X    }
  1112. X    }
  1113. X
  1114. X    UpdateCRC(outbuf, outcnt);
  1115. X    outpos += outcnt;
  1116. X    outcnt = 0;
  1117. X    outptr = outbuf;
  1118. X
  1119. X    return (final_flag && (curbuf->bufcnt > 0)) ? 
  1120. X        WriteBuffer(curbuf->buf,curbuf->bufcnt) :
  1121. X    0;    /* 0:  no error */
  1122. X}
  1123. X
  1124. X#define RECORD_END(c)    ((c) == CR || (c) == LF)
  1125. X
  1126. Xstatic int _flush_records(final_flag)
  1127. X  int final_flag;
  1128. X/* 1 if this is the final flushout */
  1129. X{
  1130. X    int rest;
  1131. X    int end = 0, start = 0;
  1132. X    int off = 0;
  1133. X
  1134. X    if (outcnt == 0 && loccnt == 0)
  1135. X    return 0;        /* Nothing to do ... */
  1136. X
  1137. X    if (loccnt)
  1138. X    {
  1139. X    for (end = 0; end < outcnt && !RECORD_END(outbuf[end]);)
  1140. X        ++end;
  1141. X    if (end >= outcnt)
  1142. X    {
  1143. X        fprintf(stderr, "[ Warning: Record too long (%d) ]\n",
  1144. X            outcnt + loccnt);
  1145. X        if (WriteRecord(locbuf, loccnt))
  1146. X        return (50);
  1147. X        memcpy(locbuf, outbuf, outcnt);
  1148. X        locptr = &locbuf[loccnt = outcnt];
  1149. X    }
  1150. X    else
  1151. X    {
  1152. X        memcpy(locptr, outbuf, end);
  1153. X        if (WriteRecord(locbuf, loccnt + end))
  1154. X        return (50);
  1155. X        loccnt = 0;
  1156. X        locptr = &locbuf;
  1157. X    }
  1158. X    start = end + 1;
  1159. X    }
  1160. X
  1161. X    do
  1162. X    {
  1163. X    while (start < outcnt && outbuf[start] == CR)    /* Skip CR's at the
  1164. X                            *  beginning of rec. */
  1165. X        ++start;
  1166. X    /* Find record end */
  1167. X    for (end = start; end < outcnt && !RECORD_END(outbuf[end]);)
  1168. X        ++end;
  1169. X
  1170. X    if (end < outcnt)
  1171. X    {            /* Record end found, write the record */
  1172. X        if (WriteRecord(outbuf + start, end - start))
  1173. X        return (50);
  1174. X        /* Shift to the begining of the next record */
  1175. X        start = end + 1;
  1176. X    }
  1177. X    } while (start < outcnt && end < outcnt);
  1178. X
  1179. X    rest = outcnt - start;
  1180. X
  1181. X    if (rest > 0)
  1182. X    if (final_flag)
  1183. X    {
  1184. X        /* This is a final flush. Put out all remaining in
  1185. X        *  the buffer                */
  1186. X        if (loccnt && WriteRecord(locbuf, loccnt))
  1187. X        return (50);
  1188. X    }
  1189. X    else
  1190. X    {
  1191. X        memcpy(locptr, outbuf + start, rest);
  1192. X        locptr += rest;
  1193. X        loccnt += rest;
  1194. X    }
  1195. X    UpdateCRC(outbuf, outcnt);
  1196. X    outpos += outcnt;
  1197. X    outcnt = 0;
  1198. X    outptr = outbuf;
  1199. X    return (0);            /* 0:  no error */
  1200. X}
  1201. X
  1202. X/***************************/
  1203. X/*  Function WriteBuffer() */
  1204. X/***************************/
  1205. X
  1206. Xstatic int WriteBuffer(buf, len)/* return 0 if successful, 1 if not */
  1207. X  unsigned char *buf;
  1208. Xint len;
  1209. X{
  1210. X    int status;
  1211. X
  1212. X    status = sys$wait(outrab);
  1213. X#ifdef DEBUG
  1214. X    if(ERR(status))
  1215. X    {    message("[ Write buffer: sys$wait faled ]\n",status);
  1216. X    message("",outrab->rab$l_sts);
  1217. X    message("",outrab->rab$l_sts);
  1218. X    }
  1219. X#endif
  1220. X    outrab->rab$w_rsz = len;
  1221. X    outrab->rab$l_rbf = buf;
  1222. X
  1223. X    if (ERR(status = sys$write(outrab)))
  1224. X    {
  1225. X    fprintf(stderr, "WriteBuffer: sys$write failed.\n",
  1226. X        filename);
  1227. X    fprintf(stderr, "                    status = %d\n", status);
  1228. X    fprintf(stderr, "                  rab->sts = %d\n", outrab->rab$l_sts);
  1229. X    fprintf(stderr, "                       stv = %d\n", outrab->rab$l_stv);
  1230. X    return 50;
  1231. X    }
  1232. X    return (0);
  1233. X}
  1234. X
  1235. X/***************************/
  1236. X/*  Function WriteRecord() */
  1237. X/***************************/
  1238. X
  1239. Xstatic int WriteRecord(rec, len)/* return 0 if successful, 1 if not */
  1240. X  unsigned char *rec;
  1241. Xint len;
  1242. X{
  1243. X    int status;
  1244. X
  1245. X    sys$wait(outrab);
  1246. X#ifdef DEBUG
  1247. X    if(ERR(status))
  1248. X    {    message("[ Write buffer: sys$wait faled ]\n",status);
  1249. X    message("",outrab->rab$l_sts);
  1250. X    message("",outrab->rab$l_sts);
  1251. X    }
  1252. X#endif
  1253. X    outrab->rab$w_rsz = len;
  1254. X    outrab->rab$l_rbf = rec;
  1255. X
  1256. X    if (ERR(status = sys$put(outrab)))
  1257. X    {
  1258. X    fprintf(stderr, "WriteRecord: sys$put failed.\n",
  1259. X        filename);
  1260. X    fprintf(stderr, "                    status = %d\n", status);
  1261. X    fprintf(stderr, "                  rab->sts = %d\n", outrab->rab$l_sts);
  1262. X    fprintf(stderr, "                       stv = %d\n", outrab->rab$l_stv);
  1263. X    return 50;
  1264. X    }
  1265. X    return (0);
  1266. X}
  1267. X
  1268. X/********************************/
  1269. X/*  Function CloseOutputFile()  */
  1270. X/********************************/
  1271. X
  1272. Xint CloseOutputFile()
  1273. X{
  1274. X    int status;
  1275. X
  1276. X    if (text_file) _flush_records(1);
  1277. X    else
  1278. X    _flush_blocks(1);
  1279. X
  1280. X    if ((outfab->fab$l_xab = xabrdt) != 0L)    /* Link XABPRO and XABRDT */
  1281. X    xabrdt->xab$l_nxt = (secinf ? xabpro : 0L);
  1282. X    else
  1283. X    outfab->fab$l_xab = (secinf ? xabpro : 0L);
  1284. X
  1285. X    sys$wait(outrab);
  1286. X
  1287. X    status = sys$close(outfab);
  1288. X#ifdef DEBUG
  1289. X    if (ERR(status))
  1290. X    {
  1291. X    message("\r[ Warning: can not set owner/protection/time attributes ]\n", status);
  1292. X    message("", outfab->fab$l_stv);
  1293. X    }
  1294. X#endif
  1295. X}
  1296. X
  1297. X#ifdef DEBUG
  1298. Xdump_rms_block(p)
  1299. X  unsigned char *p;
  1300. X{
  1301. X    unsigned char bid, len;
  1302. X    int err;
  1303. X    char *type;
  1304. X    char buf[132];
  1305. X    int i;
  1306. X
  1307. X    err = 0;
  1308. X    bid = p[0];
  1309. X    len = p[1];
  1310. X    switch (bid)
  1311. X    {
  1312. X    case FAB$C_BID:
  1313. X        type = "FAB";
  1314. X        break;
  1315. X    case XAB$C_ALL:
  1316. X        type = "xabALL";
  1317. X        break;
  1318. X    case XAB$C_KEY:
  1319. X        type = "xabKEY";
  1320. X        break;
  1321. X    case XAB$C_DAT:
  1322. X        type = "xabDAT";
  1323. X        break;
  1324. X    case XAB$C_RDT:
  1325. X        type = "xabRDT";
  1326. X        break;
  1327. X    case XAB$C_FHC:
  1328. X        type = "xabFHC";
  1329. X        break;
  1330. X    case XAB$C_PRO:
  1331. X        type = "xabPRO";
  1332. X        break;
  1333. X    default:
  1334. X        type = "Unknown";
  1335. X        err = 1;
  1336. X        break;
  1337. X    }
  1338. X    printf("Block @%08X of type %s (%d).", p, type, bid);
  1339. X    if (err)
  1340. X    {
  1341. X    printf("\n");
  1342. X    return;
  1343. X    }
  1344. X    printf(" Size = %d\n", len);
  1345. X    printf(" Offset - Hex - Dec\n");
  1346. X    for (i = 0; i < len; i += 8)
  1347. X    {
  1348. X    int j;
  1349. X    printf("%3d - ", i);
  1350. X    for (j = 0; j < 8; j++)
  1351. X        if (i + j < len)
  1352. X        printf("%02X ", p[i + j]);
  1353. X        else
  1354. X        printf("   ");
  1355. X    printf(" - ");
  1356. X    for (j = 0; j < 8; j++)
  1357. X        if (i + j < len)
  1358. X        printf("%03d ", p[i + j]);
  1359. X        else
  1360. X        printf("    ");
  1361. X    printf("\n");
  1362. X    }
  1363. X}
  1364. X
  1365. X#endif                /* DEBUG */
  1366. X
  1367. Xmessage(string, status)
  1368. X    int status;
  1369. Xchar *string;
  1370. X{
  1371. X    char msgbuf[256];
  1372. X    $DESCRIPTOR(msgd, msgbuf);
  1373. X    int msglen = 0;
  1374. X
  1375. X    if (ERR(lib$sys_getmsg(&status, &msglen, &msgd, 0, 0)))
  1376. X    fprintf(stderr, "%s[ VMS status = %d ]\n", string, status);
  1377. X    else
  1378. X    {
  1379. X    msgbuf[msglen] = 0;
  1380. X    fprintf(stderr, "%s[ %s ]\n", string, msgbuf);
  1381. X    }
  1382. X}
  1383. X
  1384. X
  1385. X#endif                /* !VMS */
  1386. END_OF_FILE
  1387.   if test 20178 -ne `wc -c <'VMS/vms.c'`; then
  1388.     echo shar: \"'VMS/vms.c'\" unpacked with wrong size!
  1389.   fi
  1390.   # end of 'VMS/vms.c'
  1391. fi
  1392. if test -f 'unimplod.c' -a "${1}" != "-c" ; then 
  1393.   echo shar: Will not clobber existing file \"'unimplod.c'\"
  1394. else
  1395.   echo shar: Extracting \"'unimplod.c'\" \(9343 characters\)
  1396.   sed "s/^X//" >'unimplod.c' <<'END_OF_FILE'
  1397. X/*---------------------------------------------------------------------------
  1398. X
  1399. X  unimplod.c
  1400. X
  1401. X  The Imploding algorithm is actually a combination of two distinct algor-
  1402. X  ithms.  The first algorithm compresses repeated byte sequences using a
  1403. X  sliding dictionary.  The second algorithm is used to compress the encoding
  1404. X  of the sliding dictionary ouput, using multiple Shannon-Fano trees.
  1405. X
  1406. X  ---------------------------------------------------------------------------
  1407. X
  1408. X  Copyrights:  see accompanying file "COPYING" in UnZip source distribution.
  1409. X
  1410. X  ---------------------------------------------------------------------------*/
  1411. X
  1412. X
  1413. X#include "unzip.h"
  1414. X
  1415. X
  1416. X/***********************/
  1417. X/*  UnImplode Defines */
  1418. X/***********************/
  1419. X
  1420. X#define LITVALS     256
  1421. X#define DISTVALS    64
  1422. X#define LENVALS     64
  1423. X#define MAXSF       LITVALS
  1424. X
  1425. X
  1426. X
  1427. X/************************/
  1428. X/*  UnImplode Typedefs */
  1429. X/************************/
  1430. X
  1431. Xtypedef struct sf_entry {
  1432. X    byte Value;
  1433. X    byte BitLength;
  1434. X} sf_entry;
  1435. X
  1436. Xtypedef struct sf_tree {        /* a shannon-fano "tree" (table) */
  1437. X    sf_entry entry[MAXSF];
  1438. X    int entries;
  1439. X    int MaxLength;
  1440. X} sf_tree;
  1441. X
  1442. Xtypedef struct sf_node {        /* node in a true shannon-fano tree */
  1443. X    UWORD left;                 /* 0 means leaf node */
  1444. X    UWORD right;                /*   or value if leaf node */
  1445. X} sf_node;
  1446. X
  1447. X
  1448. X
  1449. X/********************************/
  1450. X/*  UnImplode Global Variables */
  1451. X/********************************/
  1452. X
  1453. X/* s-f storage is shared with that used by other comp. methods */
  1454. X
  1455. Xsf_tree lit_tree;
  1456. Xsf_tree length_tree;
  1457. Xsf_tree distance_tree;
  1458. Xsf_node *lit_nodes = (sf_node *) prefix_of;     /* 2*LITVALS nodes */
  1459. X#ifdef MACOS
  1460. Xsf_node *length_nodes ;  /* 2*LENVALS nodes */
  1461. Xsf_node *distance_nodes ;    /* 2*DISTVALS nodes */
  1462. X#else
  1463. Xsf_node *length_nodes = (sf_node *) suffix_of;  /* 2*LENVALS nodes */
  1464. Xsf_node *distance_nodes = (sf_node *) stack;    /* 2*DISTVALS nodes */
  1465. X#endif
  1466. Xboolean lit_tree_present;
  1467. Xboolean eightK_dictionary;
  1468. Xint minimum_match_length;
  1469. Xint dict_bits;
  1470. X
  1471. X
  1472. X
  1473. X/*****************************************/
  1474. X/*  UnImplode Local Function Prototypes */
  1475. X/*****************************************/
  1476. X
  1477. Xstatic void LoadTrees __((void));
  1478. Xstatic void LoadTree __((sf_tree * tree, int treesize, sf_node * nodes));
  1479. Xstatic void ReadLengths __((sf_tree * tree));
  1480. Xstatic void SortLengths __((sf_tree * tree));
  1481. Xstatic void GenerateTrees __((sf_tree * tree, sf_node * nodes));
  1482. Xstatic void ReadTree __((register sf_node * nodes, int *dest));
  1483. X
  1484. X
  1485. X
  1486. X
  1487. X
  1488. X/**************************/
  1489. X/*  Function unImplode() */
  1490. X/**************************/
  1491. X
  1492. Xvoid unImplode()
  1493. X /* expand imploded data */
  1494. X{
  1495. X    register int srcix;
  1496. X    register int Length;
  1497. X    register int limit;
  1498. X    int lout;
  1499. X    int Distance;
  1500. X
  1501. X    LoadTrees();
  1502. X
  1503. X#ifdef DEBUG
  1504. X    printf("\n");
  1505. X#endif
  1506. X    while ((!zipeof) && ((outpos + outcnt) < ucsize)) {
  1507. X        READBIT(1, lout);
  1508. X
  1509. X        if (lout != 0) {        /* encoded data is literal data */
  1510. X            if (lit_tree_present) {     /* use Literal Shannon-Fano tree */
  1511. X                ReadTree(lit_nodes, &lout);
  1512. X#ifdef DEBUG
  1513. X                printf("lit=%d\n", lout);
  1514. X#endif
  1515. X            } else
  1516. X                READBIT(8, lout);
  1517. X
  1518. X            OUTB(lout);
  1519. X        } else {                /* encoded data is sliding dictionary match */
  1520. X            READBIT(dict_bits, Distance);
  1521. X
  1522. X            ReadTree(distance_nodes, &lout);
  1523. X#ifdef DEBUG
  1524. X            printf("d=%5d (%2d,%3d)", (lout << dict_bits) | Distance, lout,
  1525. X                   Distance);
  1526. X#endif
  1527. X            Distance |= (lout << dict_bits);
  1528. X            /* using the Distance Shannon-Fano tree, read and decode the
  1529. X               upper 6 bits of the Distance value */
  1530. X
  1531. X            ReadTree(length_nodes, &lout);
  1532. X            Length = lout;
  1533. X#ifdef DEBUG
  1534. X            printf("\tl=%3d\n", Length);
  1535. X#endif
  1536. X            /* using the Length Shannon-Fano tree, read and decode the
  1537. X               Length value */
  1538. X
  1539. X            if (Length == 63) {
  1540. X                READBIT(8, lout);
  1541. X                Length += lout;
  1542. X            }
  1543. X            Length += minimum_match_length;
  1544. X
  1545. X            /* move backwards Distance+1 bytes in the output stream, and copy
  1546. X              Length characters from this position to the output stream.
  1547. X              (if this position is before the start of the output stream,
  1548. X              then assume that all the data before the start of the output
  1549. X              stream is filled with zeros.  Requires initializing outbuf
  1550. X              for each file.) */
  1551. X
  1552. X            srcix = (outcnt - (Distance + 1)) & (OUTBUFSIZ - 1);
  1553. X            limit = OUTBUFSIZ - Length;
  1554. X            if ((srcix <= limit) && (outcnt < limit)) {
  1555. X                outcnt += Length;
  1556. X                while (Length--)
  1557. X                    *outptr++ = outbuf[srcix++];
  1558. X            } else {
  1559. X                while (Length--) {
  1560. X                    OUTB(outbuf[srcix++]);
  1561. X                    srcix &= OUTBUFSIZ - 1;
  1562. X                }
  1563. X            }
  1564. X        }
  1565. X    }
  1566. X}
  1567. X
  1568. X
  1569. X
  1570. X
  1571. X
  1572. X/**************************/
  1573. X/*  Function LoadTrees() */
  1574. X/**************************/
  1575. X
  1576. Xstatic void LoadTrees()
  1577. X{
  1578. X    eightK_dictionary = (lrec.general_purpose_bit_flag & 0x02) != 0;    /* bit 1 */
  1579. X    lit_tree_present = (lrec.general_purpose_bit_flag & 0x04) != 0;     /* bit 2 */
  1580. X
  1581. X    if (eightK_dictionary)
  1582. X        dict_bits = 7;
  1583. X    else
  1584. X        dict_bits = 6;
  1585. X
  1586. X    if (lit_tree_present) {
  1587. X        minimum_match_length = 3;
  1588. X        LoadTree(&lit_tree, 256, lit_nodes);
  1589. X    } else
  1590. X        minimum_match_length = 2;
  1591. X
  1592. X    LoadTree(&length_tree, 64, length_nodes);
  1593. X    LoadTree(&distance_tree, 64, distance_nodes);
  1594. X}
  1595. X
  1596. X
  1597. X
  1598. X
  1599. X
  1600. X/*************************/
  1601. X/*  Function LoadTree() */
  1602. X/*************************/
  1603. X
  1604. Xstatic void LoadTree(tree, treesize, nodes)
  1605. Xsf_tree *tree;
  1606. Xint treesize;
  1607. Xsf_node *nodes;
  1608. X /* allocate and load a shannon-fano tree from the compressed file */
  1609. X{
  1610. X    tree->entries = treesize;
  1611. X    ReadLengths(tree);
  1612. X    SortLengths(tree);
  1613. X    GenerateTrees(tree, nodes);
  1614. X}
  1615. X
  1616. X
  1617. X
  1618. X
  1619. X
  1620. X/****************************/
  1621. X/*  Function ReadLengths() */
  1622. X/****************************/
  1623. X
  1624. Xstatic void ReadLengths(tree)
  1625. Xsf_tree *tree;
  1626. X{
  1627. X    int treeBytes;
  1628. X    int i;
  1629. X    int num, len;
  1630. X
  1631. X    /* get number of bytes in compressed tree */
  1632. X    READBIT(8, treeBytes);
  1633. X    treeBytes++;
  1634. X    i = 0;
  1635. X
  1636. X    tree->MaxLength = 0;
  1637. X
  1638. X/* High 4 bits: Number of values at this bit length + 1. (1 - 16)
  1639. X * Low  4 bits: Bit Length needed to represent value + 1. (1 - 16)
  1640. X */
  1641. X    while (treeBytes > 0) {
  1642. X        READBIT(4, len);
  1643. X        len++;
  1644. X        READBIT(4, num);
  1645. X        num++;
  1646. X
  1647. X        while (num > 0) {
  1648. X            if (len > tree->MaxLength)
  1649. X                tree->MaxLength = len;
  1650. X            tree->entry[i].BitLength = len;
  1651. X            tree->entry[i].Value = i;
  1652. X            i++;
  1653. X            num--;
  1654. X        }
  1655. X
  1656. X        treeBytes--;
  1657. X    }
  1658. X}
  1659. X
  1660. X
  1661. X
  1662. X
  1663. X
  1664. X/****************************/
  1665. X/*  Function SortLengths() */
  1666. X/****************************/
  1667. X
  1668. Xstatic void SortLengths(tree)
  1669. Xsf_tree *tree;
  1670. X /* Sort the Bit Lengths in ascending order, while retaining the order
  1671. X   of the original lengths stored in the file */
  1672. X{
  1673. X    register sf_entry *ejm1;    /* entry[j - 1] */
  1674. X    register int j;
  1675. X    register sf_entry *entry;
  1676. X    register int i;
  1677. X    sf_entry tmp;
  1678. X    int entries;
  1679. X    unsigned a, b;
  1680. X
  1681. X    entry = &tree->entry[0];
  1682. X    entries = tree->entries;
  1683. X
  1684. X    for (i = 0; ++i < entries;) {
  1685. X        tmp = entry[i];
  1686. X        b = tmp.BitLength;
  1687. X        j = i;
  1688. X        while ((j > 0)
  1689. X               && ((a = (ejm1 = &entry[j - 1])->BitLength) >= b)) {
  1690. X            if ((a == b) && (ejm1->Value <= tmp.Value))
  1691. X                break;
  1692. X            *(ejm1 + 1) = *ejm1;/* entry[j] = entry[j - 1] */
  1693. X            --j;
  1694. X        }
  1695. X        entry[j] = tmp;
  1696. X    }
  1697. X}
  1698. X
  1699. X
  1700. X
  1701. X
  1702. X
  1703. X/******************************/
  1704. X/*  Function GenerateTrees() */
  1705. X/******************************/
  1706. X
  1707. Xstatic void GenerateTrees(tree, nodes)
  1708. Xsf_tree *tree;
  1709. Xsf_node *nodes;
  1710. X /* Generate the Shannon-Fano trees */
  1711. X{
  1712. X    int codelen, i, j, lvlstart, next, parents;
  1713. X
  1714. X    i = tree->entries - 1;      /* either 255 or 63 */
  1715. X    lvlstart = next = 1;
  1716. X
  1717. X    /* believe it or not, there may be a 1-bit code */
  1718. X
  1719. X    for (codelen = tree->MaxLength; codelen >= 1; --codelen) {
  1720. X
  1721. X        /* create leaf nodes at level <codelen> */
  1722. X
  1723. X        while ((i >= 0) && (tree->entry[i].BitLength == codelen)) {
  1724. X            nodes[next].left = 0;
  1725. X            nodes[next].right = tree->entry[i].Value;
  1726. X            ++next;
  1727. X            --i;
  1728. X        }
  1729. X
  1730. X        /* create parent nodes for all nodes at level <codelen>,
  1731. X           but don't create the root node here */
  1732. X
  1733. X        parents = next;
  1734. X        if (codelen > 1) {
  1735. X            for (j = lvlstart; j <= parents - 2; j += 2) {
  1736. X                nodes[next].left = j;
  1737. X                nodes[next].right = j + 1;
  1738. X                ++next;
  1739. X            }
  1740. X        }
  1741. X        lvlstart = parents;
  1742. X    }
  1743. X
  1744. X    /* create root node */
  1745. X
  1746. X    nodes[0].left = next - 2;
  1747. X    nodes[0].right = next - 1;
  1748. X}
  1749. X
  1750. X
  1751. X
  1752. X
  1753. X
  1754. X/************************/
  1755. X/*  Function ReadTree() */
  1756. X/************************/
  1757. X
  1758. X#ifndef ASM
  1759. X
  1760. Xstatic void ReadTree(nodes, dest)
  1761. Xregister sf_node *nodes;
  1762. Xint *dest;
  1763. X /* read next byte using a shannon-fano tree */
  1764. X{
  1765. X    register int cur;
  1766. X    register int left;
  1767. X    UWORD b;
  1768. X
  1769. X    for (cur = 0;;) {
  1770. X        if ((left = nodes[cur].left) == 0) {
  1771. X            *dest = nodes[cur].right;
  1772. X            return;
  1773. X        }
  1774. X        READBIT(1, b);
  1775. X        cur = (b ? nodes[cur].right : left);
  1776. X    }
  1777. X}
  1778. X
  1779. X#endif                          /* !ASM */
  1780. END_OF_FILE
  1781.   if test 9343 -ne `wc -c <'unimplod.c'`; then
  1782.     echo shar: \"'unimplod.c'\" unpacked with wrong size!
  1783.   fi
  1784.   # end of 'unimplod.c'
  1785. fi
  1786. echo shar: End of archive 8 \(of 12\).
  1787. cp /dev/null ark8isdone
  1788. MISSING=""
  1789. for I in 1 2 3 4 5 6 7 8 9 10 11 12 ; do
  1790.     if test ! -f ark${I}isdone ; then
  1791.     MISSING="${MISSING} ${I}"
  1792.     fi
  1793. done
  1794. if test "${MISSING}" = "" ; then
  1795.     echo You have unpacked all 12 archives.
  1796.     rm -f ark[1-9]isdone ark[1-9][0-9]isdone
  1797. else
  1798.     echo You still must unpack the following archives:
  1799.     echo "        " ${MISSING}
  1800. fi
  1801. exit 0
  1802. exit 0 # Just in case...
  1803.