← Back to branch summary

~ubuntu-branches/ubuntu/feisty/clamav/feisty

« back to all changes in this revision

Viewing changes to win32/3rdparty/zlib/contrib/ada/zlib-streams.adb

  • Committer: Bazaar Package Importer
  • Author(s): Kees Cook
  • Date: 2007-02-20 10:33:44 UTC
  • mto: This revision was merged to the branch mainline in revision 16.
  • Revision ID: james.westby@ubuntu.com-20070220103344-zgcu2psnx9d98fpa
Tags: upstream-0.90
Import upstream version 0.90

Show diffs side-by-side

added added

removed removed

Lines of Context:
win32/3rdparty/zlib/contrib/ada/zlib-streams.adb
1
 
----------------------------------------------------------------
2
 
----------------------------------------------------------------
3
 
 
4
 
 
5
 
with Ada.Unchecked_Deallocation;
6
 
 
7
 
package body ZLib.Streams is
8
 
 
9
 
   -----------
10
 
   -- Close --
11
 
   -----------
12
 
 
13
 
   procedure Close (Stream : in out Stream_Type) is
14
 
      procedure Free is new Ada.Unchecked_Deallocation
15
 
         (Stream_Element_Array, Buffer_Access);
16
 
   begin
17
 
      if Stream.Mode = Out_Stream or Stream.Mode = Duplex then
18
 
         --  We should flush the data written by the writer.
19
 
 
20
 
         Flush (Stream, Finish);
21
 
 
22
 
         Close (Stream.Writer);
23
 
      end if;
24
 
 
25
 
      if Stream.Mode = In_Stream or Stream.Mode = Duplex then
26
 
         Close (Stream.Reader);
27
 
         Free (Stream.Buffer);
28
 
      end if;
29
 
   end Close;
30
 
 
31
 
   ------------
32
 
   -- Create --
33
 
   ------------
34
 
 
35
 
   procedure Create
36
 
     (Stream            :    out Stream_Type;
37
 
      Mode              : in     Stream_Mode;
38
 
      Back              : in     Stream_Access;
39
 
      Back_Compressed   : in     Boolean;
40
 
      Level             : in     Compression_Level := Default_Compression;
41
 
      Strategy          : in     Strategy_Type     := Default_Strategy;
42
 
      Header            : in     Header_Type       := Default;
43
 
      Read_Buffer_Size  : in     Ada.Streams.Stream_Element_Offset
44
 
                                    := Default_Buffer_Size;
45
 
      Write_Buffer_Size : in     Ada.Streams.Stream_Element_Offset
46
 
                                    := Default_Buffer_Size)
47
 
   is
48
 
 
49
 
      subtype Buffer_Subtype is Stream_Element_Array (1 .. Read_Buffer_Size);
50
 
 
51
 
      procedure Init_Filter
52
 
         (Filter   : in out Filter_Type;
53
 
          Compress : in     Boolean);
54
 
 
55
 
      -----------------
56
 
      -- Init_Filter --
57
 
      -----------------
58
 
 
59
 
      procedure Init_Filter
60
 
         (Filter   : in out Filter_Type;
61
 
          Compress : in     Boolean) is
62
 
      begin
63
 
         if Compress then
64
 
            Deflate_Init
65
 
              (Filter, Level, Strategy, Header => Header);
66
 
         else
67
 
            Inflate_Init (Filter, Header => Header);
68
 
         end if;
69
 
      end Init_Filter;
70
 
 
71
 
   begin
72
 
      Stream.Back := Back;
73
 
      Stream.Mode := Mode;
74
 
 
75
 
      if Mode = Out_Stream or Mode = Duplex then
76
 
         Init_Filter (Stream.Writer, Back_Compressed);
77
 
         Stream.Buffer_Size := Write_Buffer_Size;
78
 
      else
79
 
         Stream.Buffer_Size := 0;
80
 
      end if;
81
 
 
82
 
      if Mode = In_Stream or Mode = Duplex then
83
 
         Init_Filter (Stream.Reader, not Back_Compressed);
84
 
 
85
 
         Stream.Buffer     := new Buffer_Subtype;
86
 
         Stream.Rest_First := Stream.Buffer'Last + 1;
87
 
         Stream.Rest_Last  := Stream.Buffer'Last;
88
 
      end if;
89
 
   end Create;
90
 
 
91
 
   -----------
92
 
   -- Flush --
93
 
   -----------
94
 
 
95
 
   procedure Flush
96
 
     (Stream : in out Stream_Type;
97
 
      Mode   : in     Flush_Mode := Sync_Flush)
98
 
   is
99
 
      Buffer : Stream_Element_Array (1 .. Stream.Buffer_Size);
100
 
      Last   : Stream_Element_Offset;
101
 
   begin
102
 
      loop
103
 
         Flush (Stream.Writer, Buffer, Last, Mode);
104
 
 
105
 
         Ada.Streams.Write (Stream.Back.all, Buffer (1 .. Last));
106
 
 
107
 
         exit when Last < Buffer'Last;
108
 
      end loop;
109
 
   end Flush;
110
 
 
111
 
   -------------
112
 
   -- Is_Open --
113
 
   -------------
114
 
 
115
 
   function Is_Open (Stream : Stream_Type) return Boolean is
116
 
   begin
117
 
      return Is_Open (Stream.Reader) or else Is_Open (Stream.Writer);
118
 
   end Is_Open;
119
 
 
120
 
   ----------
121
 
   -- Read --
122
 
   ----------
123
 
 
124
 
   procedure Read
125
 
     (Stream : in out Stream_Type;
126
 
      Item   :    out Stream_Element_Array;
127
 
      Last   :    out Stream_Element_Offset)
128
 
   is
129
 
 
130
 
      procedure Read
131
 
        (Item : out Stream_Element_Array;
132
 
         Last : out Stream_Element_Offset);
133
 
 
134
 
      ----------
135
 
      -- Read --
136
 
      ----------
137
 
 
138
 
      procedure Read
139
 
        (Item : out Stream_Element_Array;
140
 
         Last : out Stream_Element_Offset) is
141
 
      begin
142
 
         Ada.Streams.Read (Stream.Back.all, Item, Last);
143
 
      end Read;
144
 
 
145
 
      procedure Read is new ZLib.Read
146
 
         (Read       => Read,
147
 
          Buffer     => Stream.Buffer.all,
148
 
          Rest_First => Stream.Rest_First,
149
 
          Rest_Last  => Stream.Rest_Last);
150
 
 
151
 
   begin
152
 
      Read (Stream.Reader, Item, Last);
153
 
   end Read;
154
 
 
155
 
   -------------------
156
 
   -- Read_Total_In --
157
 
   -------------------
158
 
 
159
 
   function Read_Total_In (Stream : in Stream_Type) return Count is
160
 
   begin
161
 
      return Total_In (Stream.Reader);
162
 
   end Read_Total_In;
163
 
 
164
 
   --------------------
165
 
   -- Read_Total_Out --
166
 
   --------------------
167
 
 
168
 
   function Read_Total_Out (Stream : in Stream_Type) return Count is
169
 
   begin
170
 
      return Total_Out (Stream.Reader);
171
 
   end Read_Total_Out;
172
 
 
173
 
   -----------
174
 
   -- Write --
175
 
   -----------
176
 
 
177
 
   procedure Write
178
 
     (Stream : in out Stream_Type;
179
 
      Item   : in     Stream_Element_Array)
180
 
   is
181
 
 
182
 
      procedure Write (Item : in Stream_Element_Array);
183
 
 
184
 
      -----------
185
 
      -- Write --
186
 
      -----------
187
 
 
188
 
      procedure Write (Item : in Stream_Element_Array) is
189
 
      begin
190
 
         Ada.Streams.Write (Stream.Back.all, Item);
191
 
      end Write;
192
 
 
193
 
      procedure Write is new ZLib.Write
194
 
         (Write       => Write,
195
 
          Buffer_Size => Stream.Buffer_Size);
196
 
 
197
 
   begin
198
 
      Write (Stream.Writer, Item, No_Flush);
199
 
   end Write;
200
 
 
201
 
   --------------------
202
 
   -- Write_Total_In --
203
 
   --------------------
204
 
 
205
 
   function Write_Total_In (Stream : in Stream_Type) return Count is
206
 
   begin
207
 
      return Total_In (Stream.Writer);
208
 
   end Write_Total_In;
209
 
 
210
 
   ---------------------
211
 
   -- Write_Total_Out --
212
 
   ---------------------
213
 
 
214
 
   function Write_Total_Out (Stream : in Stream_Type) return Count is
215
 
   begin
216
 
      return Total_Out (Stream.Writer);
217
 
   end Write_Total_Out;
218
 
 
219
 
end ZLib.Streams;