reverse.c

filter: Statementstmt 91.8% 135 / 147 Branchbran 78.5% 66 / 84 Conditioncond n/a MC/DCmcdc n/a Subroutinesub n/a Podpod n/a totaltotal 87.0% 201 / 231 CC 0 SCAR 0
CC
0
Cov
0%
CRAP 0
« dir.c ↑ Summary pseudo_layers.c »
1 /*
2 :reverse - Reads lines backward
3 */
4 #include "perlioutil.h"
5  
6 #define IOR(f) (PerlIOSelf(f, PerlIOReverse))
7  
8  
9 #define REV_BUFSIZ 4096
10  
11 #define SEGSV_BUFSIZ 512
12 #define BUFSV_BUFSIZ (REV_BUFSIZ+SEGSV_BUFSIZ)
13  
14  
15 typedef struct{
16 struct _PerlIO base;
17  
18 STDCHAR buffer[ REV_BUFSIZ ]; /* first buffer */
19  
20 SV* segsv; /* broken segment */
21  
22 SV* bufsv; /* reversed buffer */
23 STDCHAR* ptr;
24 STDCHAR* end;
25 } PerlIOReverse;
26  
27 static PerlIO*
28 10 PerlIOReverse_open(pTHX_ PerlIO_funcs* const self, PerlIO_list_t* const layers, IV const n,
29 const char* const mode, int const fd, int const imode, int const perm,
30 PerlIO* f, int const narg, SV** const args){
31 PerlIO_funcs* tab;
32  
33 assert(layers->cur > 0);
34 10 tab = LayerFetch(layers, 0); /* :unix or :scalar */
35  
36 10 ▶ if(!(tab && tab->Open) || PerlIOUnix_oflags(mode) & (O_WRONLY | O_RDWR) ){
Branch: 3 branches
BranchTrueFalseTotal
if(!(tab && tab->Open) || PerlIOUnix_oflags(mode) & (O_WRONLY | O_RDWR) ){ 10 0 10
if(!(tab && tab->Open) || PerlIOUnix_oflags(mode) & (O_WRONLY | O_RDWR) ){ 10 0 10
if(!(tab && tab->Open) || PerlIOUnix_oflags(mode) & (O_WRONLY | O_RDWR) ){ 2 8 10
37 2 SETERRNO(EINVAL, LIB_INVARG);
38 2 return NULL;
39 }
40  
41 8 f = tab->Open(aTHX_ tab, layers, (IV)1, mode, fd, imode, perm, f, narg, args);
42  
43 8 ▶ if(f){
Branch: 1 branch
BranchTrueFalseTotal
if(f){ 7 1 8
44 7 ▶ if(!PerlIO_push(aTHX_ f, self, mode, PerlIOArg)){
Branch: 1 branch
BranchTrueFalseTotal
if(!PerlIO_push(aTHX_ f, self, mode, PerlIOArg)){ 0 7 7
45 0 PerlIO_close(f);
46 0 return NULL;
47 }
48 }
49 8 return f;
50 }
51  
52 static IV
53 14 PerlIOReverse_pushed(pTHX_ PerlIO* const f, const char* const mode, SV* const arg, PerlIO_funcs* const tab){
54 PerlIOReverse* ior;
55 PerlIO* nx;
56 Off_t pos;
57 PerlIO* p;
58  
59 14 ▶ if(!(PerlIOValid(f) && (nx = PerlIONext(f)) && PerlIOValid(nx))){
Branch: 5 branches
BranchTrueFalseTotal
if(!(PerlIOValid(f) && (nx = PerlIONext(f)) && PerlIOValid(nx))){ 14 0 14
if(!(PerlIOValid(f) && (nx = PerlIONext(f)) && PerlIOValid(nx))){ 14 0 14
if(!(PerlIOValid(f) && (nx = PerlIONext(f)) && PerlIOValid(nx))){ 14 0 14
if(!(PerlIOValid(f) && (nx = PerlIONext(f)) && PerlIOValid(nx))){ 14 0 14
if(!(PerlIOValid(f) && (nx = PerlIONext(f)) && PerlIOValid(nx))){ 2 12 14
60 2 SETERRNO(EBADF, SS_IVCHAN);
61 2 return -1;
62 }
63  
64 12 ▶ if(!IOLflag(nx, PERLIO_F_CANREAD)){
Branch: 1 branch
BranchTrueFalseTotal
if(!IOLflag(nx, PERLIO_F_CANREAD)){ 1 11 12
65 1 SETERRNO(EINVAL, LIB_INVARG);
66 1 return -1;
67 }
68  
69 23 ▶ for(p = nx; PerlIOValid(p); p = PerlIONext(p)){
Branch: 2 branches
BranchTrueFalseTotal
for(p = nx; PerlIOValid(p); p = PerlIONext(p)){ 23 0 23
for(p = nx; PerlIOValid(p); p = PerlIONext(p)){ 13 10 23
70 13 ▶ if(!(PerlIOBase(p)->tab->kind & PERLIO_K_RAW)
Branch: 1 branch
BranchTrueFalseTotal
if(!(PerlIOBase(p)->tab->kind & PERLIO_K_RAW) 13 0 13
71 13 ▶ || (PerlIOBase(p)->flags & PERLIO_F_CRLF)){
Branch: 1 branch
BranchTrueFalseTotal
|| (PerlIOBase(p)->flags & PERLIO_F_CRLF)){ 1 12 13
72  
73 1 PerlIOUtil_warnif(aTHX_ packWARN(WARN_LAYER),
74 ":%s is not a raw layer",
75 1 PerlIOBase(p)->tab->name);
76 1 SETERRNO(EINVAL, LIB_INVARG);
77 1 return -1;
78 }
79 }
80  
81 10 pos = PerlIO_tell(nx);
82 10 ▶ if(pos <= 0){
Branch: 1 branch
BranchTrueFalseTotal
if(pos <= 0){ 9 1 10
83 9 ▶ if(pos < 0 || PerlIO_seek(nx, (Off_t)0, SEEK_END) < 0){
Branch: 2 branches
BranchTrueFalseTotal
if(pos < 0 || PerlIO_seek(nx, (Off_t)0, SEEK_END) < 0){ 8 1 9
if(pos < 0 || PerlIO_seek(nx, (Off_t)0, SEEK_END) < 0){ 0 8 8
84 1 return -1;
85 }
86 }
87  
88 9 ior = IOR(f);
89 9 ior->segsv = newSV(SEGSV_BUFSIZ);
90 9 ior->bufsv = newSV(BUFSV_BUFSIZ);
91  
92 assert( ior->bufsv );
93 assert( ior->segsv );
94  
95 9 sv_setpvn(ior->bufsv, "", 0);
96 9 sv_setpvn(ior->segsv, "", 0);
97  
98 9 return PerlIOBase_pushed(aTHX_ f, mode, arg, tab);
99 }
100 static IV
101 14 PerlIOReverse_popped(pTHX_ PerlIO* const f){
102 14 PerlIOReverse* const ior = IOR(f);
103  
104 19 PerlIO_debug("PerlIOReverse_popped:"
105 " bufsv=%ld, segsv=%ld\n",
106 14 ▶ (long)(ior->bufsv ? SvLEN(ior->bufsv) : 0),
Branch: 1 branch
BranchTrueFalseTotal
(long)(ior->bufsv ? SvLEN(ior->bufsv) : 0), 9 5 14
107 14 ▶ (long)(ior->segsv ? SvLEN(ior->segsv) : 0));
Branch: 1 branch
BranchTrueFalseTotal
(long)(ior->segsv ? SvLEN(ior->segsv) : 0)); 9 5 14
108  
109 14 SvREFCNT_dec(ior->bufsv);
110 14 SvREFCNT_dec(ior->segsv);
111  
112 14 return PerlIOBase_popped(aTHX_ f);
113 }
114  
115 #if defined(IOR_DEBUGGING)
116  
117 #define write_buf(s, l, m) PerlIOReverse_debug_write_buf(aTHX_ s, l, m)
118 #define write_bufsv(sv, msg) PerlIOReverse_debug_write_buf(aTHX_ SvPVX(sv), SvCUR(sv), msg)
119  
120 /* to pass -Wmissing-prototypes -Wunused-function */
121 void
122 PerlIOReverse_debug_write_buf(pTHX_ register const STDCHAR*, const Size_t count, const STDCHAR* msg);
123  
124 void
125 PerlIOReverse_debug_write_buf(pTHX_ register const STDCHAR* src, const Size_t count, const STDCHAR* msg){
126 char* buf;
127 char* end;
128 register char* ptr;
129  
130 Newx(buf, count, char);
131  
132 ptr = buf;
133 end = buf + count;
134 /* write the buffer */
135  
136 while(ptr < end){
137 *ptr = (*src == '\0' ? '@' : *src);
138 ptr++;
139 src++;
140 }
141 if(msg){
142 PerlIO_write(PerlIO_stderr(), msg, strlen(msg));
143 }
144 PerlIO_write(PerlIO_stderr(), "[", 1);
145 PerlIO_write(PerlIO_stderr(), buf, count);
146 Perl_warn(aTHX_ "]");
147 //PerlIO_write(PerlIO_stderr(), "]\n", 2);
148  
149 Safefree(buf);
150 }
151 #endif /* IOR_DEBUGGING */
152  
153 static IV
154 18 PerlIOReverse_flush(pTHX_ PerlIO* const f){
155 18 ▶ if(IOLflag(f, PERLIO_F_RDBUF)){
Branch: 1 branch
BranchTrueFalseTotal
if(IOLflag(f, PERLIO_F_RDBUF)){ 12 6 18
156 12 PerlIOReverse* ior = IOR(f);
157 12 Off_t offset = (ior->end - ior->ptr) + SvCUR(ior->segsv);
158 12 SvCUR(ior->bufsv) = SvCUR(ior->segsv) = 0;
159 12 ior->end = ior->ptr = SvPVX(ior->bufsv);
160  
161 12 IOLflag_off(f, PERLIO_F_RDBUF);
162 12 PerlIO_seek(PerlIONext(f), offset , SEEK_CUR);
163 }
164 18 return PerlIO_flush(PerlIONext(f));
165 }
166  
167 static SSize_t
168 26 reverse_read(pTHX_ PerlIO* const f, STDCHAR* const vbuf, SSize_t count){
169 26 PerlIO* const nx = PerlIONext(f);
170 26 SSize_t avail = 0;
171 26 Off_t const pos = PerlIO_tell(nx);
172  
173 assert( pos == (SSize_t)pos ); /* XXX: What should I do? */
174  
175 26 ▶ if(pos <= 0){
Branch: 1 branch
BranchTrueFalseTotal
if(pos <= 0){ 11 15 26
176 11 ▶ IOLflag_on(f, pos < 0 ? PERLIO_F_ERROR : PERLIO_F_EOF);
Branch: 1 branch
BranchTrueFalseTotal
IOLflag_on(f, pos < 0 ? PERLIO_F_ERROR : PERLIO_F_EOF); 0 11 11
177  
178 11 return (SSize_t)pos;
179 }
180  
181 15 ▶ if(pos < count){
Branch: 1 branch
BranchTrueFalseTotal
if(pos < count){ 12 3 15
182 12 count = (SSize_t)pos;
183 }
184  
185 15 ▶ if(PerlIO_seek(nx, (Off_t)-count, SEEK_CUR) < 0){
Branch: 1 branch
BranchTrueFalseTotal
if(PerlIO_seek(nx, (Off_t)-count, SEEK_CUR) < 0){ 0 15 15
186 0 IOLflag_on(f, PERLIO_F_ERROR);
187 0 return -1;
188 }
189  
190 30 ▶ while(avail < count){
Branch: 1 branch
BranchTrueFalseTotal
while(avail < count){ 15 15 30
191 15 SSize_t s = PerlIO_read(nx, vbuf+avail, (Size_t)(count - avail));
192 15 ▶ if(s > 0){
Branch: 1 branch
BranchTrueFalseTotal
if(s > 0){ 15 0 15
193 15 avail += s;
194 }
195 else{
196 0 break;
197 }
198 }
199  
200 15 ▶ if(PerlIO_seek(nx, (Off_t)-avail, SEEK_CUR) < 0){
Branch: 1 branch
BranchTrueFalseTotal
if(PerlIO_seek(nx, (Off_t)-avail, SEEK_CUR) < 0){ 0 15 15
201 0 IOLflag_on(f, PERLIO_F_ERROR);
202  
203 0 return -1;
204 }
205 15 return avail;
206 }
207  
208  
209  
210 static IV
211 25 PerlIOReverse_fill(pTHX_ PerlIO* const f){
212 25 PerlIOReverse* const ior = IOR(f);
213 SSize_t avail;
214  
215 25 SV* const bufsv = ior->bufsv;
216 25 SV* const segsv = ior->segsv;
217 STDCHAR* rbuf;
218  
219 25 STDCHAR* const buf = ior->buffer;
220 STDCHAR* ptr;
221 const STDCHAR* end;
222 const STDCHAR* start;
223  
224 25 SvCUR(bufsv) = 0;
225  
226 26 retry:
227 26 avail = reverse_read(aTHX_ f, buf, REV_BUFSIZ);
228  
229 26 ▶ if(avail < 0){
Branch: 1 branch
BranchTrueFalseTotal
if(avail < 0){ 0 26 26
230 0 return -1;
231 }
232  
233 26 start = ptr = buf;
234 26 end = buf + avail;
235  
236 26 ▶ if(avail == REV_BUFSIZ){ /* not EOF */
Branch: 1 branch
BranchTrueFalseTotal
if(avail == REV_BUFSIZ){ /* not EOF */ 3 23 26
237 11985 ▶ while(ptr < end){
Branch: 1 branch
BranchTrueFalseTotal
while(ptr < end){ 11985 0 11985
238 11985 ▶ if(*(ptr++) == '\n') break;
Branch: 1 branch
BranchTrueFalseTotal
if(*(ptr++) == '\n') break; 3 11982 11985
239 }
240  
241 /* available buffer has no newlines */
242 3 ▶ if(ptr == end){
Branch: 1 branch
BranchTrueFalseTotal
if(ptr == end){ 1 2 3
243 /* fill segment simply */
244 1 sv_insert(segsv, 0, 0, buf, (Size_t)avail);
245  
246 1 goto retry;
247 }
248 }
249  
250 /* solve previous segment */
251 25 ▶ if(SvCUR(segsv) > 0){
Branch: 1 branch
BranchTrueFalseTotal
if(SvCUR(segsv) > 0){ 3 22 25
252 3 const STDCHAR* p = end;
253 610 ▶ while(p >= ptr){
Branch: 1 branch
BranchTrueFalseTotal
while(p >= ptr){ 609 1 610
254 609 ▶ if(*(--p) == '\n') break;
Branch: 1 branch
BranchTrueFalseTotal
if(*(--p) == '\n') break; 2 607 609
255 }
256 3 p++;
257 /* buf[oo\nbar\nba]
258 ^ ^ ^
259 start ptr p
260  
261 seg[z\n]
262 */
263  
264 3 sv_grow(bufsv, (end - ptr) + SvCUR(segsv));
265  
266 3 sv_setpvn(bufsv, p, (Size_t)(end - p));
267 3 sv_catsv( bufsv, segsv);
268 3 end = p;
269 }
270 /*write_buf(start, (Size_t)(ptr - start), "");*/
271  
272 25 sv_setpvn(segsv, start, (Size_t)(ptr - start));
273 25 start = ptr;
274  
275 25 rbuf = SvPVX(bufsv) + SvCUR(bufsv);
276 25 SvCUR(bufsv) += end - start;
277  
278 assert(SvCUR(bufsv) <= SvLEN(bufsv));
279  
280 15116 ▶ while(ptr < end){
Branch: 1 branch
BranchTrueFalseTotal
while(ptr < end){ 15091 25 15116
281 15091 ▶ if(*(ptr++) == '\n'){
Branch: 1 branch
BranchTrueFalseTotal
if(*(ptr++) == '\n'){ 3015 12076 15091
282 /* line length: ptr - start */
283 /* write pos: end - ptr */
284  
285 3015 Copy( start,
286 rbuf + (end - ptr),
287 ptr - start, STDCHAR);
288  
289 3015 start = ptr;
290 }
291 }
292 25 ▶ if(start != end){
Branch: 1 branch
BranchTrueFalseTotal
if(start != end){ 1 24 25
293 1 Copy( start, rbuf + (end - ptr), ptr - start, STDCHAR);
294 }
295  
296  
297 /*
298 write_bufsv(segsv, "segm");
299 write_buf(start, end - start, "buf");
300 write_bufsv(segsv, "rbuf");
301 // */
302 25 ior->ptr = SvPVX(bufsv);
303 25 ior->end = SvPVX(bufsv) + SvCUR(bufsv);
304  
305 25 ▶ if( SvCUR(bufsv) == 0 ){
Branch: 1 branch
BranchTrueFalseTotal
if( SvCUR(bufsv) == 0 ){ 11 14 25
306 11 return -1;
307 }
308  
309 14 IOLflag_on(f, PERLIO_F_RDBUF);
310  
311 14 return 0;
312 }
313  
314 static STDCHAR*
315 0 PerlIOReverse_get_base(pTHX_ PerlIO* const f){
316 0 return SvPVX(IOR(f)->bufsv);
317 }
318  
319 static STDCHAR*
320 1063 PerlIOReverse_get_ptr(pTHX_ PerlIO* const f){
321 1063 return IOR(f)->ptr;
322 }
323  
324 static SSize_t
325 1095 PerlIOReverse_get_cnt(pTHX_ PerlIO* const f){
326 1095 return IOR(f)->end - IOR(f)->ptr;
327 }
328  
329 static Size_t
330 1 PerlIOReverse_bufsiz(pTHX_ PerlIO* const f){
331 1 return SvCUR(IOR(f)->bufsv);
332 }
333  
334 static void
335 1063 PerlIOReverse_set_ptrcnt(pTHX_ PerlIO* const f, STDCHAR* const ptr, SSize_t const cnt){
336 PERL_UNUSED_ARG(cnt);
337  
338 1063 IOR(f)->ptr = ptr;
339 1063 }
340  
341 static IV
342 9 PerlIOReverse_seek(pTHX_ PerlIO* const f, Off_t const offset, int whence){
343 9 PerlIO* const nx = PerlIONext(f);
344  
345 9 PerlIOReverse_flush(aTHX_ f);
346  
347 9 switch(whence){
348 3 case SEEK_SET:
349 3 whence = SEEK_END;
350 3 break;
351 2 case SEEK_END:
352 2 whence = SEEK_SET;
353 2 break;
354 }
355 9 return PerlIO_seek(nx, -offset, whence);
356 }
357 static Off_t
358 7 PerlIOReverse_tell(pTHX_ PerlIO* const f){
359 7 PerlIO* const nx = PerlIONext(f);
360 7 Off_t const current = PerlIO_tell(nx);
361 Off_t end;
362  
363 7 ▶ if(PerlIO_seek(nx, (Off_t)0, SEEK_END) < 0){
Branch: 1 branch
BranchTrueFalseTotal
if(PerlIO_seek(nx, (Off_t)0, SEEK_END) < 0){ 0 7 7
364 0 return -1;
365 }
366 7 end = PerlIO_tell(nx);
367 7 ▶ if(PerlIO_seek(nx, current, SEEK_SET) < 0){
Branch: 1 branch
BranchTrueFalseTotal
if(PerlIO_seek(nx, current, SEEK_SET) < 0){ 0 7 7
368 0 return -1;
369 }
370  
371 /*
372 warn("(end=%d - pos=%d) - (cnt=%d + segsv=%d) = %d",
373 (int)end, (int)current, (int)(IOR(f)->end-IOR(f)->ptr), (int)SvCUR(IOR(f)->segsv),
374 (int)((end - current) - ((IOR(f)->end - IOR(f)->ptr) + SvCUR(IOR(f)->segsv))));
375 */
376 7 return (end - current) - ((IOR(f)->end - IOR(f)->ptr) + SvCUR(IOR(f)->segsv));
377 }
378  
379 PERLIO_FUNCS_DECL(PerlIO_reverse) = {
380 sizeof(PerlIO_funcs),
381 "reverse",
382 sizeof(PerlIOReverse),
383 PERLIO_K_BUFFERED | PERLIO_K_RAW,
384 PerlIOReverse_pushed,
385 PerlIOReverse_popped,
386 PerlIOReverse_open,
387 PerlIOBase_binmode,
388 NULL, /* getarg */
389 NULL, /* fileno */
390 NULL, /* dup */
391 NULL, /* read */
392 NULL, /* unread */
393 NULL, /* write */
394 PerlIOReverse_seek,
395 PerlIOReverse_tell,
396 NULL, /* close */
397 PerlIOReverse_flush,
398 PerlIOReverse_fill,
399 NULL, /* eof */
400 NULL, /* error */
401 NULL, /* clearerr */
402 NULL, /* setlinebuf */
403 PerlIOReverse_get_base,
404 PerlIOReverse_bufsiz,
405 PerlIOReverse_get_ptr,
406 PerlIOReverse_get_cnt,
407 PerlIOReverse_set_ptrcnt
408 };
« dir.c ↑ Summary pseudo_layers.c »