| 1 |
|
| /* |
| 2 |
|
| PerlIO-Util/Util.xs |
| 3 |
|
| */ |
| 4 |
|
| |
| 5 |
|
| #include "perlioutil.h" |
| 6 |
|
| |
| 7 |
|
| #ifndef gv_stashpvs |
| 8 |
|
| #define gv_stashpvs(s, c) gv_stashpvn(s "", sizeof(s)-1, c) |
| 9 |
|
| #endif |
| 10 |
|
| |
| 11 |
|
| PerlIO* |
| 12 |
64 |
| PerlIOUtil_openn(pTHX_ PerlIO_funcs* const force_tab, PerlIO_list_t* const layers, IV const n, |
| 13 |
|
| const char* const mode, int const fd, int const imode, int const perm, |
| 14 |
|
| PerlIO* f, int const narg, SV** const args){ |
| 15 |
64 |
| PerlIO_funcs* tab = NULL; |
| 16 |
64 |
| IV i = n; |
| 17 |
|
| |
| 18 |
64 |
▶ | while(--i >= 0){ /* find a layer with Open() */ |
Branch: 1 branch
| Branch | True | False | Total |
| while(--i >= 0){ /* find a layer with Open() */ |
64 |
0 |
64 |
|
| 19 |
64 |
| tab = LayerFetch(layers, i); |
| 20 |
64 |
▶ | if(tab && tab->Open){ |
Branch: 2 branches
| Branch | True | False | Total |
| if(tab && tab->Open){ |
64 |
0 |
64 |
| if(tab && tab->Open){ |
64 |
0 |
64 |
|
| 21 |
64 |
| break; |
| 22 |
|
| } |
| 23 |
|
| } |
| 24 |
|
| |
| 25 |
64 |
▶ | if(force_tab) tab = force_tab; |
Branch: 1 branch
| Branch | True | False | Total |
| if(force_tab) tab = force_tab; |
10 |
54 |
64 |
|
| 26 |
|
| |
| 27 |
64 |
▶ | if(tab && tab->Open){ |
Branch: 2 branches
| Branch | True | False | Total |
| if(tab && tab->Open){ |
64 |
0 |
64 |
| if(tab && tab->Open){ |
64 |
0 |
64 |
|
| 28 |
64 |
| f = tab->Open(aTHX_ tab, layers, i, mode, |
| 29 |
|
| fd, imode, perm, f, narg, args); |
| 30 |
|
| |
| 31 |
|
| /* apply 'upper' layers |
| 32 |
|
| e.g. [ :unix :perlio :utf8 :creat ] |
| 33 |
|
| ~~~~~ |
| 34 |
|
| */ |
| 35 |
|
| |
| 36 |
64 |
▶ | if(f && ++i < n){ |
Branch: 2 branches
| Branch | True | False | Total |
| if(f && ++i < n){ |
55 |
9 |
64 |
| if(f && ++i < n){ |
0 |
55 |
55 |
|
| 37 |
0 |
▶ | if(PerlIO_apply_layera(aTHX_ f, mode, layers, i, n) != 0){ |
Branch: 1 branch
| Branch | True | False | Total |
| if(PerlIO_apply_layera(aTHX_ f, mode, layers, i, n) != 0){ |
0 |
0 |
0 |
|
| 38 |
0 |
| PerlIO_close(f); |
| 39 |
0 |
| f = NULL; |
| 40 |
|
| } |
| 41 |
|
| } |
| 42 |
|
| |
| 43 |
|
| } |
| 44 |
|
| else{ |
| 45 |
0 |
| SETERRNO(EINVAL, LIB_INVARG); |
| 46 |
|
| } |
| 47 |
|
| |
| 48 |
64 |
| return f; |
| 49 |
|
| } |
| 50 |
|
| |
| 51 |
|
| #define PutFlag(c) do{\ |
| 52 |
|
| if(PerlIOBase(f)->flags & (PERLIO_F_##c)){\ |
| 53 |
|
| sv_catpvs(sv, " " #c);\ |
| 54 |
|
| }\ |
| 55 |
|
| }while(0) |
| 56 |
|
| |
| 57 |
|
| SV* |
| 58 |
3 |
| PerlIOUtil_inspect(pTHX_ PerlIO* f, int const level){ |
| 59 |
|
| int i; |
| 60 |
3 |
| SV* const sv = newSVpvs(" "); |
| 61 |
|
| |
| 62 |
3 |
▶ | for(i = 0; i < level; i++) sv_catpvs(sv, " "); |
Branch: 1 branch
| Branch | True | False | Total |
| for(i = 0; i < level; i++) sv_catpvs(sv, " "); |
0 |
3 |
3 |
|
| 63 |
|
| |
| 64 |
3 |
| sv_catpvf(sv, "PerlIO 0x%p\n", f); |
| 65 |
|
| |
| 66 |
3 |
▶ | if(!PerlIOValid(f)){ |
Branch: 2 branches
| Branch | True | False | Total |
| if(!PerlIOValid(f)){ |
3 |
0 |
3 |
| if(!PerlIOValid(f)){ |
1 |
2 |
3 |
|
| 67 |
2 |
▶ | for(i = 0; i <= level; i++) sv_catpvs(sv, " "); |
Branch: 1 branch
| Branch | True | False | Total |
| for(i = 0; i <= level; i++) sv_catpvs(sv, " "); |
1 |
1 |
2 |
|
| 68 |
|
| |
| 69 |
1 |
| sv_catpvs(sv, "(Invalid filehandle)\n"); |
| 70 |
|
| } |
| 71 |
|
| |
| 72 |
7 |
▶ | while(PerlIOValid(f)){ |
Branch: 2 branches
| Branch | True | False | Total |
| while(PerlIOValid(f)){ |
7 |
0 |
7 |
| while(PerlIOValid(f)){ |
4 |
3 |
7 |
|
| 73 |
8 |
▶ | for(i = 0; i <= level; i++) sv_catpv(sv, " "); |
Branch: 1 branch
| Branch | True | False | Total |
| for(i = 0; i <= level; i++) sv_catpv(sv, " "); |
4 |
4 |
8 |
|
| 74 |
|
| |
| 75 |
4 |
| sv_catpvf(sv, "0x%p:%s(%d)", |
| 76 |
|
| *f, PerlIOBase(f)->tab->name, |
| 77 |
|
| (int)PerlIO_fileno(f)); |
| 78 |
4 |
▶ | PutFlag(EOF); |
Branch: 1 branch
| Branch | True | False | Total |
| PutFlag(EOF); |
0 |
4 |
4 |
|
| 79 |
4 |
▶ | PutFlag(CANWRITE); |
Branch: 1 branch
| Branch | True | False | Total |
| PutFlag(CANWRITE); |
0 |
4 |
4 |
|
| 80 |
4 |
▶ | PutFlag(CANREAD); |
Branch: 1 branch
| Branch | True | False | Total |
| PutFlag(CANREAD); |
4 |
0 |
4 |
|
| 81 |
4 |
▶ | PutFlag(ERROR); |
Branch: 1 branch
| Branch | True | False | Total |
| PutFlag(ERROR); |
0 |
4 |
4 |
|
| 82 |
4 |
▶ | PutFlag(TRUNCATE); |
Branch: 1 branch
| Branch | True | False | Total |
| PutFlag(TRUNCATE); |
0 |
4 |
4 |
|
| 83 |
4 |
▶ | PutFlag(APPEND); |
Branch: 1 branch
| Branch | True | False | Total |
| PutFlag(APPEND); |
0 |
4 |
4 |
|
| 84 |
4 |
▶ | PutFlag(CRLF); |
Branch: 1 branch
| Branch | True | False | Total |
| PutFlag(CRLF); |
0 |
4 |
4 |
|
| 85 |
4 |
▶ | PutFlag(UTF8); |
Branch: 1 branch
| Branch | True | False | Total |
| PutFlag(UTF8); |
0 |
4 |
4 |
|
| 86 |
4 |
▶ | PutFlag(UNBUF); |
Branch: 1 branch
| Branch | True | False | Total |
| PutFlag(UNBUF); |
0 |
4 |
4 |
|
| 87 |
|
| |
| 88 |
4 |
▶ | PutFlag(WRBUF); |
Branch: 1 branch
| Branch | True | False | Total |
| PutFlag(WRBUF); |
0 |
4 |
4 |
|
| 89 |
4 |
▶ | if(IOLflag(f, PERLIO_F_WRBUF)){ |
Branch: 1 branch
| Branch | True | False | Total |
| if(IOLflag(f, PERLIO_F_WRBUF)){ |
0 |
4 |
4 |
|
| 90 |
0 |
| sv_catpvf(sv, "(%" IVdf "/%" IVdf ")", |
| 91 |
|
| (IV)PerlIO_get_cnt(f), |
| 92 |
|
| (IV)PerlIO_get_bufsiz(f)); |
| 93 |
|
| } |
| 94 |
4 |
▶ | PutFlag(RDBUF); |
Branch: 1 branch
| Branch | True | False | Total |
| PutFlag(RDBUF); |
1 |
3 |
4 |
|
| 95 |
4 |
▶ | if(IOLflag(f, PERLIO_F_RDBUF)){ |
Branch: 1 branch
| Branch | True | False | Total |
| if(IOLflag(f, PERLIO_F_RDBUF)){ |
1 |
3 |
4 |
|
| 96 |
1 |
| sv_catpvf(sv, "(%" IVdf "/%" IVdf ")", |
| 97 |
|
| (IV)PerlIO_get_cnt(f), |
| 98 |
|
| (IV)PerlIO_get_bufsiz(f)); |
| 99 |
|
| } |
| 100 |
|
| |
| 101 |
4 |
▶ | PutFlag(LINEBUF); |
Branch: 1 branch
| Branch | True | False | Total |
| PutFlag(LINEBUF); |
0 |
4 |
4 |
|
| 102 |
4 |
▶ | PutFlag(TEMP); |
Branch: 1 branch
| Branch | True | False | Total |
| PutFlag(TEMP); |
0 |
4 |
4 |
|
| 103 |
4 |
▶ | PutFlag(OPEN); |
Branch: 1 branch
| Branch | True | False | Total |
| PutFlag(OPEN); |
2 |
2 |
4 |
|
| 104 |
4 |
▶ | PutFlag(FASTGETS); |
Branch: 1 branch
| Branch | True | False | Total |
| PutFlag(FASTGETS); |
2 |
2 |
4 |
|
| 105 |
4 |
▶ | PutFlag(TTY); |
Branch: 1 branch
| Branch | True | False | Total |
| PutFlag(TTY); |
0 |
4 |
4 |
|
| 106 |
4 |
▶ | PutFlag(NOTREG); |
Branch: 1 branch
| Branch | True | False | Total |
| PutFlag(NOTREG); |
0 |
4 |
4 |
|
| 107 |
4 |
| sv_catpvs(sv, "\n"); |
| 108 |
|
| |
| 109 |
4 |
▶ | if( strEQ(PerlIOBase(f)->tab->name, "tee") ){ |
Branch: 1 branch
| Branch | True | False | Total |
| if( strEQ(PerlIOBase(f)->tab->name, "tee") ){ |
0 |
4 |
4 |
|
| 110 |
0 |
| PerlIO* const teeout = PerlIOTee_teeout(aTHX_ f); |
| 111 |
0 |
| SV* const t = PerlIOUtil_inspect(aTHX_ teeout, level+1); |
| 112 |
|
| |
| 113 |
0 |
| sv_catsv(sv, t); |
| 114 |
0 |
| SvREFCNT_dec(t); |
| 115 |
|
| } |
| 116 |
|
| |
| 117 |
4 |
| f = PerlIONext(f); |
| 118 |
|
| } |
| 119 |
|
| |
| 120 |
3 |
| return sv; |
| 121 |
|
| } |
| 122 |
|
| |
| 123 |
|
| void |
| 124 |
9 |
| PerlIOUtil_warnif(pTHX_ U32 const category, const char* const fmt, ...){ |
| 125 |
9 |
▶ | if(ckWARN(category)){ |
Branch: 1 branch
| Branch | True | False | Total |
| if(ckWARN(category)){ |
5 |
4 |
9 |
|
| 126 |
|
| va_list args; |
| 127 |
5 |
| va_start(args, fmt); |
| 128 |
5 |
| vwarner(category, fmt, &args); |
| 129 |
0 |
| va_end(args); |
| 130 |
|
| } |
| 131 |
4 |
| } |
| 132 |
|
| |
| 133 |
|
| MODULE = PerlIO::Util PACKAGE = PerlIO::Util |
| 134 |
|
| |
| 135 |
|
| PROTOTYPES: DISABLE |
| 136 |
|
| |
| 137 |
|
| BOOT: |
| 138 |
17 |
| PerlIO_define_layer(aTHX_ PERLIO_FUNCS_CAST(&PerlIO_flock)); |
| 139 |
17 |
| PerlIO_define_layer(aTHX_ PERLIO_FUNCS_CAST(&PerlIO_creat)); |
| 140 |
17 |
| PerlIO_define_layer(aTHX_ PERLIO_FUNCS_CAST(&PerlIO_excl)); |
| 141 |
17 |
| PerlIO_define_layer(aTHX_ PERLIO_FUNCS_CAST(&PerlIO_tee)); |
| 142 |
17 |
| PerlIO_define_layer(aTHX_ PERLIO_FUNCS_CAST(&PerlIO_dir)); |
| 143 |
17 |
| PerlIO_define_layer(aTHX_ PERLIO_FUNCS_CAST(&PerlIO_reverse)); |
| 144 |
|
| |
| 145 |
|
| void |
| 146 |
|
| known_layers(...) |
| 147 |
|
| PREINIT: |
| 148 |
1 |
| const PerlIO_list_t* const layers = PL_known_layers; |
| 149 |
|
| int i; |
| 150 |
|
| PPCODE: |
| 151 |
1 |
▶ | EXTEND(SP, layers->cur); |
Branch: 2 branches
| Branch | True | False | Total |
| EXTEND(SP, layers->cur); |
1 |
0 |
1 |
| EXTEND(SP, layers->cur); |
0 |
1 |
1 |
|
| 152 |
17 |
▶ | for(i = 0; i < layers->cur; i++){ |
Branch: 1 branch
| Branch | True | False | Total |
| for(i = 0; i < layers->cur; i++){ |
16 |
1 |
17 |
|
| 153 |
16 |
| SV* const name = newSVpv( LayerFetch(layers, i)->name, 0); |
| 154 |
16 |
| PUSHs( sv_2mortal(name) ); |
| 155 |
|
| } |
| 156 |
1 |
| XSRETURN(layers->cur); |
| 157 |
|
| |
| 158 |
|
| SV* |
| 159 |
|
| _gensym_ref(SV* pkg, SV* name) |
| 160 |
|
| PREINIT: |
| 161 |
|
| STRLEN len; |
| 162 |
|
| const char* pv; |
| 163 |
7 |
| GV* const gv = (GV*)newSV(0); |
| 164 |
|
| CODE: |
| 165 |
7 |
| pv = SvPV_const(name, len); |
| 166 |
|
| /* see also pp_rv2gv() in pp.c */ |
| 167 |
7 |
| gv_init(gv, gv_stashsv(pkg, TRUE), pv, len, GV_ADD); |
| 168 |
7 |
| RETVAL = newRV_noinc((SV*)gv); |
| 169 |
|
| |
| 170 |
7 |
| sv_bless(RETVAL, gv_stashpvs("IO::Handle", TRUE)); |
| 171 |
|
| OUTPUT: |
| 172 |
|
| RETVAL |
| 173 |
|
| |
| 174 |
|
| |
| 175 |
|
| MODULE = PerlIO::Util PACKAGE = IO::Handle |
| 176 |
|
| |
| 177 |
|
| |
| 178 |
|
| #define undef (&PL_sv_undef) |
| 179 |
|
| |
| 180 |
|
| void |
| 181 |
|
| push_layer(filehandle, layer, arg = undef) |
| 182 |
|
| PerlIO* filehandle |
| 183 |
|
| SV* layer |
| 184 |
|
| SV* arg |
| 185 |
|
| PREINIT: |
| 186 |
|
| PerlIO_funcs* tab; |
| 187 |
|
| const char* laypv; |
| 188 |
|
| STRLEN laylen; |
| 189 |
|
| PPCODE: |
| 190 |
20 |
| laypv = SvPV_const(layer, laylen); |
| 191 |
20 |
▶ | if(laypv[0] == ':'){ /* ignore a layer prefix */ |
Branch: 1 branch
| Branch | True | False | Total |
| if(laypv[0] == ':'){ /* ignore a layer prefix */ |
1 |
19 |
20 |
|
| 192 |
1 |
| laypv++; |
| 193 |
1 |
| laylen--; |
| 194 |
|
| } |
| 195 |
20 |
| tab = PerlIO_find_layer(aTHX_ laypv, laylen, TRUE); |
| 196 |
20 |
▶ | if(tab){ |
Branch: 1 branch
| Branch | True | False | Total |
| if(tab){ |
19 |
1 |
20 |
|
| 197 |
19 |
▶ | if(!PerlIO_push(aTHX_ filehandle, tab, NULL, arg)){ |
Branch: 1 branch
| Branch | True | False | Total |
| if(!PerlIO_push(aTHX_ filehandle, tab, NULL, arg)){ |
8 |
11 |
19 |
|
| 198 |
14 |
▶ | Perl_croak(aTHX_ "push_layer() failed: %s", |
Branch: 1 branch
| Branch | True | False | Total |
| Perl_croak(aTHX_ "push_layer() failed: %s", |
6 |
2 |
8 |
|
| 199 |
6 |
▶ | PerlIOValid(filehandle) |
Branch: 1 branch
| Branch | True | False | Total |
| PerlIOValid(filehandle) |
5 |
1 |
6 |
|
| 200 |
5 |
| ? Strerror(errno) |
| 201 |
|
| : "Invalid filehandle"); |
| 202 |
|
| } |
| 203 |
|
| } |
| 204 |
|
| else{ |
| 205 |
1 |
| Perl_croak(aTHX_ "Unknown PerlIO layer \"%.*s\"", |
| 206 |
|
| (int)laylen, laypv); |
| 207 |
|
| } |
| 208 |
11 |
| XSRETURN(1); /* returns self */ |
| 209 |
|
| |
| 210 |
|
| void |
| 211 |
|
| pop_layer(filehandle) |
| 212 |
|
| PerlIO* filehandle |
| 213 |
|
| PREINIT: |
| 214 |
|
| const char* popped_layer; |
| 215 |
|
| PPCODE: |
| 216 |
19 |
▶ | if(!PerlIOValid(filehandle)) XSRETURN_EMPTY; |
Branch: 2 branches
| Branch | True | False | Total |
| if(!PerlIOValid(filehandle)) XSRETURN_EMPTY; |
18 |
1 |
19 |
| if(!PerlIOValid(filehandle)) XSRETURN_EMPTY; |
10 |
8 |
18 |
|
| 217 |
8 |
| popped_layer = PerlIOBase(filehandle)->tab->name; |
| 218 |
|
| |
| 219 |
8 |
| PerlIO_flush(filehandle); |
| 220 |
8 |
| PerlIO_pop(aTHX_ filehandle); |
| 221 |
|
| |
| 222 |
8 |
▶ | if(GIMME_V != G_VOID){ |
Branch: 1 branch
| Branch | True | False | Total |
| if(GIMME_V != G_VOID){ |
5 |
3 |
8 |
|
| 223 |
5 |
| XSRETURN_PV(popped_layer); |
| 224 |
|
| } |
| 225 |
|
| |
| 226 |
|
| MODULE = PerlIO::Util PACKAGE = IO::Handle PREFIX = perlio_ |
| 227 |
|
| |
| 228 |
|
| |
| 229 |
|
| SV* |
| 230 |
|
| perlio_inspect(f) |
| 231 |
|
| PerlIO* f |