Lines Matching defs:flags
122 The other difference is that C<gv_fetchfile_flags> has an extra C<flags>
137 const U32 flags)
145 PERL_UNUSED_ARG(flags);
158 GV **gvp = (GV**)hv_fetch(PL_defstash, tmpbuf, tmplen, (flags & GVF_NOADD) ? FALSE : TRUE);
352 C<flags> can be set to C<SVf_UTF8> if C<name> is a UTF-8 string, or
362 has no flags parameter. If the C<multi> parameter is set, the
373 char * and length parameters. C<flags> is currently unused.
379 Perl_gv_init_sv(pTHX_ GV *gv, HV *stash, SV* namesv, U32 flags)
386 flags |= SVf_UTF8;
387 gv_init_pvn(gv, stash, namepv, namelen, flags);
391 Perl_gv_init_pv(pTHX_ GV *gv, HV *stash, const char *name, U32 flags)
394 gv_init_pvn(gv, stash, name, strlen(name), flags);
444 Perl_gv_init_pvn(pTHX_ GV *gv, HV *stash, const char *name, STRLEN len, U32 flags)
512 gv_name_set(gv, name, len, GV_ADD | ( flags & SVf_UTF8 ? SVf_UTF8 : 0 ));
513 if (flags & GV_ADDMULTI || doproto) /* doproto means it */
533 cv = newCONSTSUB_flags(stash, name, len, flags, has_constant);
734 C<GV_SUPER> bit is set in C<flags>, stashes accessible via C<@ISA> are searched
738 C<flags> is not set, C<UNIVERSAL::> is searched.
752 The only other significant value for C<flags> is C<SVf_UTF8>, indicating that
755 Plain C<gv_fetchmeth> lacks a C<flags> parameter, hence always searches in
759 The other forms do have a C<flags> parameter, and differ only in how the glob
778 Perl_gv_fetchmeth_sv(pTHX_ HV *stash, SV *namesv, I32 level, U32 flags)
785 flags | SvUTF8(namesv));
787 if (SvUTF8(namesv)) flags |= SVf_UTF8;
788 return gv_fetchmeth_pvn(stash, namepv, namelen, level, flags);
793 Perl_gv_fetchmeth_pv(pTHX_ HV *stash, const char *name, I32 level, U32 flags)
796 return gv_fetchmeth_internal(stash, NULL, name, strlen(name), level, flags);
802 S_gv_fetchmeth_internal(pTHX_ HV* stash, SV* meth, const char* name, STRLEN len, I32 level, U32 flags)
818 U32 is_utf8 = flags & SVf_UTF8;
838 flags & GV_SUPER ? "SUPER " : "",
843 if (flags & GV_SUPER) {
966 if((level == 0 || level == -1) && !(flags & GV_NOUNIVERSAL)) {
968 flags &~GV_SUPER);
982 if (topgv && GvREFCNT(topgv) == 1 && !(flags & GV_NOUNIVERSAL)) {
991 Perl_gv_fetchmeth_pvn(pTHX_ HV *stash, const char *name, STRLEN len, I32 level, U32 flags)
994 return gv_fetchmeth_internal(stash, NULL, name, len, level, flags);
1000 This is the old form of L</gv_fetchmeth_pvn_autoload>, which has no flags
1012 Perl_gv_fetchmeth_sv_autoload(pTHX_ HV *stash, SV *namesv, I32 level, U32 flags)
1019 flags |= SVf_UTF8;
1020 return gv_fetchmeth_pvn_autoload(stash, namepv, namelen, level, flags);
1033 Perl_gv_fetchmeth_pv_autoload(pTHX_ HV *stash, const char *name, I32 level, U32 flags)
1036 return gv_fetchmeth_pvn_autoload(stash, name, strlen(name), level, flags);
1049 Currently, the only significant value for C<flags> is C<SVf_UTF8>.
1055 Perl_gv_fetchmeth_pvn_autoload(pTHX_ HV *stash, const char *name, STRLEN len, I32 level, U32 flags)
1057 GV *gv = gv_fetchmeth_pvn(stash, name, len, level, flags);
1069 if (!(gv = gv_fetchmeth_pvn(stash, S_autoload, S_autolen, FALSE, flags)))
1076 gv_fetchmeth_pvn(stash, name, len, 0, flags);
1078 (flags & SVf_UTF8) ? -(I32)len : (I32)len, (level >= 0));
1123 Perl_gv_fetchmethod_sv_flags(pTHX_ HV *stash, SV *namesv, U32 flags)
1130 flags |= SVf_UTF8;
1131 return gv_fetchmethod_pvn_flags(stash, namepv, namelen, flags);
1135 Perl_gv_fetchmethod_pv_flags(pTHX_ HV *stash, const char *name, U32 flags)
1138 return gv_fetchmethod_pvn_flags(stash, name, strlen(name), flags);
1142 Perl_gv_fetchmethod_pvn_flags(pTHX_ HV *stash, const char *name, const STRLEN len, U32 flags)
1150 const U32 autoload = flags & GV_AUTOLOAD;
1151 const U32 do_croak = flags & GV_CROAK;
1152 const U32 is_utf8 = flags & SVf_UTF8;
1196 flags |= GV_SUPER;
1204 if (stash) flags |= GV_SUPER;
1213 gv = gv_fetchmeth_pvn(stash, name, name_end - name, 0, flags);
1217 ostash, name, name_end - name, GV_AUTOLOAD_ISMETHOD|flags
1233 gv = gv_fetchmeth_pvn(stash, name, name_end - name, 0, flags);
1318 Perl_gv_autoload_sv(pTHX_ HV *stash, SV* namesv, U32 flags)
1325 flags |= SVf_UTF8;
1326 return gv_autoload_pvn(stash, namepv, namelen, flags);
1330 Perl_gv_autoload_pv(pTHX_ HV *stash, const char *namepv, U32 flags)
1333 return gv_autoload_pvn(stash, namepv, strlen(namepv), flags);
1337 Perl_gv_autoload_pvn(pTHX_ HV *stash, const char *name, STRLEN len, U32 flags)
1345 U32 is_utf8 = flags & SVf_UTF8 ? SVf_UTF8 : 0;
1361 if (flags & GV_SUPER) sv_catpvs(packname, "::SUPER");
1364 is_utf8 | (flags & GV_SUPER))))
1375 !(flags & GV_AUTOLOAD_ISMETHOD)
1398 * If both flags are on, then SvLEN is used to indicate the end of
1478 * "flags": if flag & 1 then save the scalar before loading.
1484 STRLEN len, const U32 flags)
1515 if ( flags & 1 )
1542 #define require_tie_mod_s(gv, varname, name, flags) \
1543 S_require_tie_mod(aTHX_ gv, varname, STR_WITH_LEN(name), flags)
1565 parameter indicates the length of the C<name>, in bytes. C<flags> is passed
1568 C<flags> is 0 (or any other setting that does not create packages) then C<NULL>
1605 S_gv_stashpvn_internal(pTHX_ const char *name, U32 namelen, I32 flags)
1622 tmpgv = gv_fetchpvn_flags(tmpbuf, tmplen, flags, SVt_PVHV);
1628 if (!(flags & ~GV_NOADD_MASK) && !stash) return NULL;
1631 hv_name_set(stash, name, namelen, flags & SVf_UTF8 ? SVf_UTF8 : 0 );
1652 cache; see L<perlapi/C<gv_stashpvn>> for details on the other C<flags>.
1666 Perl_gv_stashsvpvn_cached(pTHX_ SV *namesv, const char *name, U32 namelen, I32 flags)
1675 (flags & SVf_UTF8) ? HVhek_UTF8 : 0, 0, NULL, 0
1686 else if (flags & GV_CACHE_ONLY) return NULL;
1693 flags |= SvUTF8(namesv);
1698 stash = gv_stashpvn_internal(name, namelen, flags);
1703 (flags & SVf_UTF8) ? -(I32)namelen : (I32)namelen, ref, 0);
1710 Perl_gv_stashpvn(pTHX_ const char *name, U32 namelen, I32 flags)
1713 return gv_stashsvpvn_cached(NULL, name, namelen, flags);
1729 Perl_gv_stashsv(pTHX_ SV *sv, I32 flags)
1732 return gv_stashsvpvn_cached(sv, NULL, 0, flags);
1735 Perl_gv_fetchpv(pTHX_ const char *nambeg, I32 flags, const svtype sv_type) {
1737 return gv_fetchpvn_flags(nambeg, strlen(nambeg), flags, sv_type);
1741 Perl_gv_fetchsv(pTHX_ SV *name, I32 flags, const svtype sv_type) {
1744 SvPV_flags_const(name, len, flags & GV_NO_SVGMAGIC ? 0 : SV_GMAGIC);
1746 return gv_fetchpvn_flags(nambeg, len, flags | SvUTF8(name), sv_type);
2514 =for apidoc_item |GV *|gv_fetchpvn|const char * nambeg|STRLEN full_len|I32 flags|const svtype sv_type
2516 =for apidoc_item |GV *|gv_fetchpvs|"name"|I32 flags|const svtype sv_type
2518 =for apidoc_item |GV *|gv_fetchsv_nomg|SV *name|I32 flags|const svtype sv_type
2527 Don't be fooled by the fact that only one form has C<flags> in its name. They
2528 all have a C<flags> parameter in fact, and all the flag bits have the same
2531 If any of the flags C<GV_ADD>, C<GV_ADDMG>, C<GV_ADDWARN>, C<GV_ADDMULTI>, or
2534 For all of these flags except C<GV_NOINIT>, C<L</gv_init_pvn>> is called after
2565 with C<gv_fetchsv_nomg>. Including C<GV_NO_SVGMAGIC> in the C<flags> parameter
2582 Perl_gv_fetchpvn_flags(pTHX_ const char *nambeg, STRLEN full_len, I32 flags,
2590 const I32 no_init = flags & (GV_NOADD_NOINIT | GV_NOINIT);
2591 const I32 no_expand = flags & GV_NOEXPAND;
2592 const I32 add = flags & ~GV_NOADD_MASK;
2593 const U32 is_utf8 = flags & SVf_UTF8;
2594 bool addmg = cBOOL(flags & GV_ADDMG);
2605 if ((flags & GV_NOTQUAL) || !full_len) {
2853 For C<newGVgen> or if C<flags> in C<newGVgen_flags> is 0, C<pack> is to be
2854 considered to be encoded in Latin-1. The only other legal C<flags> value is
2862 Perl_newGVgen_flags(pTHX_ const char *pack, U32 flags)
2865 assert(!(flags & ~SVf_UTF8));
2868 UTF8fARG(flags, strlen(pack), pack),
3170 amt.flags = 0;
3372 Perl_try_amagic_un(pTHX_ int method, int flags)
3382 | (flags & AMGf_numarg))))
3408 if ((flags & AMGf_numeric) && SvROK(arg)) {
3450 C<flags> should be set to AMG_unary for unary operations.
3455 Perl_amagic_applies(pTHX_ SV *sv, int method, int flags)
3458 PERL_UNUSED_VAR(flags);
3486 if (amtp->fallback > AMGfallNEVER && flags & AMGf_unary) {
3530 && !(flags & AMGf_unary)) {
3576 Perl_try_amagic_bin(pTHX_ int method, int flags)
3589 bool mutator = (flags & AMGf_assign) && (PL_op->op_flags & OPf_STACKED);
3593 | (flags & AMGf_numarg));
3645 if (flags & AMGf_numeric) {
3740 C<flags> affects how the operation is performed, as follows:
3766 Perl_amagic_call(pTHX_ SV *left, SV *right, int method, int flags)
3774 int assign = AMGf_assign & flags;
3789 if (!(AMGf_noleft & flags) && SvAMAGIC(left)
3807 if (cvp && amtp->fallback > AMGfallNEVER && flags & AMGf_unary) {
3916 } else if (!(AMGf_noright & flags) && SvAMAGIC(right)
3927 && !(flags & AMGf_unary)) {
3995 (flags & AMGf_unary ? " " : "\n\tleft "),
4004 (flags & AMGf_unary
4100 flags & AMGf_unary? "" :
4102 flags & AMGf_unary? " for argument" : "",
4169 if (flags & AMGf_want_list) {
4195 else if (flags & AMGf_numarg)
4197 if (flags & AMGf_numarg)
4216 if (flags & AMGf_want_list) {
4287 If C<flags> contains C<SVf_UTF8>, the name is treated as being encoded in
4294 Perl_gv_name_set(pTHX_ GV *gv, const char *name, U32 len, U32 flags)
4303 if (!(flags & GV_ADD) && GvNAME_HEK(gv)) {
4308 GvNAME_HEK(gv) = share_hek(name, (flags & SVf_UTF8 ? -(I32)len : (I32)len), hash);