bool composed;
/* blocked */
- if (iscontig && cc_pos || /* discontiguous combination */
- curCC != 0 && preCC == curCC || /* blocked by same CC */
+ if ((iscontig && cc_pos) || /* discontiguous combination */
+ (curCC != 0 && preCC == curCC) || /* blocked by same CC */
preCC > curCC) /* blocked by higher CC: revised D2 */
composed = FALSE;
*/
p = strchr(left, '/');
s = p ? p : left + left_len;
- if (s - left >= sizeof(next_token)) {
+ if ((STRLEN)(s - left) >= (STRLEN)sizeof(next_token)) {
errno = ENAMETOOLONG;
return (NULL);
}
*/
if (p != NULL) {
if (symlink[slen - 1] != '/') {
- if (slen + 1 >= sizeof(symlink)) {
+ if ((STRLEN)(slen + 1) >= (STRLEN)sizeof(symlink)) {
errno = ENAMETOOLONG;
return (NULL);
}
keysv = svp ? *svp : sv_mortalcopy(&PL_sv_undef);
key = SvPV(keysv, keylen);
svp = hv_fetch((HV*)ival, key,
- SvUTF8(keysv) ? -(I32)keylen : keylen, 0);
+ SvUTF8(keysv) ? -(I32)keylen : (I32)keylen, 0);
hval = svp ? *svp : sv_mortalcopy(&PL_sv_undef);
}
else {
STATIC int
len(const char* const s, int const l){
+ PERL_UNUSED_ARG(s);
return l;
}
myabs(...)
OVERLOAD: abs
CODE:
+ PERL_UNUSED_VAR(items);
RETVAL = 42;
OUTPUT:
RETVAL
int xsusage_two() { return 2; }
int xsusage_three() { return 3; }
int xsusage_four() { return 4; }
-int xsusage_five(int i) { return 5; }
-int xsusage_six(int i) { return 6; }
+int xsusage_five(int i) { PERL_UNUSED_ARG(i); return 5; }
+int xsusage_six(int i) { PERL_UNUSED_ARG(i); return 6; }
MODULE = XSUsage PACKAGE = XSUsage PREFIX = xsusage_
#endif
gv = (GV*)SvREFCNT_inc(newGVgen(packname));
if (gv)
- hv_delete(GvSTASH(gv), GvNAME(gv), GvNAMELEN(gv), G_DISCARD);
+ (void) hv_delete(GvSTASH(gv), GvNAME(gv), GvNAMELEN(gv), G_DISCARD);
if (gv && do_open(gv, "+>&", 3, FALSE, 0, 0, fp)) {
ST(0) = sv_2mortal(newRV((SV*)gv));
sv_bless(ST(0), gv_stashpv(packname, TRUE));
const char *method)
{
const char *hvname = HvNAME_get(pkg);
+ PERL_UNUSED_ARG(method);
(void) hv_store(cache,
hvname, strlen(hvname), newSVsv(&PL_sv_undef), 0);
}
const char *method)
{
const char *hvname = HvNAME_get(pkg);
+ PERL_UNUSED_ARG(method);
(void) hv_delete(cache, hvname, strlen(hvname), G_DISCARD);
}
SV *key;
if (!he)
- CROAK(("Hash %p inconsistent - expected %d keys, %dth is NULL", hv, len, i));
+ CROAK(("Hash %p inconsistent - expected %d keys, %dth is NULL", hv, (int)len, (int)i));
key = hv_iterkeysv(he);
av_store(av, AvFILLp(av)+1, key); /* av_push(), really */
}
*/
static SV *retrieve_other(pTHX_ stcxt_t *cxt, const char *cname)
{
+ PERL_UNUSED_ARG(cname);
if (
cxt->ver_major != STORABLE_BIN_MAJOR &&
cxt->ver_minor != STORABLE_BIN_MINOR
SV **sva;
SV *sv;
+ PERL_UNUSED_ARG(cname);
TRACEME(("retrieve_idx_blessed (#%d)", cxt->tagnum));
ASSERT(!cname, ("no bless-into class given here, got %s", cname));
char *classname = buf;
char *malloced_classname = NULL;
+ PERL_UNUSED_ARG(cname);
TRACEME(("retrieve_blessed (#%d)", cxt->tagnum));
ASSERT(!cname, ("no bless-into class given here, got %s", cname));
char mtype = '\0';
unsigned int extra_type = 0;
+ PERL_UNUSED_ARG(cname);
TRACEME(("retrieve_hook (#%d)", cxt->tagnum));
ASSERT(!cname, ("no bless-into class given here, got %s", cname));
SV *sv;
int c;
+ PERL_UNUSED_ARG(cname);
TRACEME(("old_retrieve_array (#%d)", cxt->tagnum));
/*
int c;
SV *sv_h_undef = (SV *) 0; /* hv_store() bug */
+ PERL_UNUSED_ARG(cname);
TRACEME(("old_retrieve_hash (#%d)", cxt->tagnum));
/*
void
recursive_lock_acquire(pTHX_ recursive_lock_t *lock, char *file, int line)
{
+ PERL_UNUSED_ARG(file);
+ PERL_UNUSED_ARG(line);
assert(aTHX);
MUTEX_LOCK(&lock->mutex);
if (lock->owner == aTHX) {
sharedsv_userlock_free(pTHX_ SV *sv, MAGIC *mg)
{
user_lock *ul = (user_lock *) mg->mg_ptr;
+ PERL_UNUSED_ARG(sv);
assert(aTHX == PL_sharedsv_space);
if (ul) {
recursive_lock_destroy(aTHX_ &ul->lock);
int
sharedsv_scalar_mg_free(pTHX_ SV *sv, MAGIC *mg)
{
+ PERL_UNUSED_ARG(sv);
S_sharedsv_dec(aTHX_ (SV*)mg->mg_ptr);
return (0);
}
int
sharedsv_scalar_mg_dup(pTHX_ MAGIC *mg, CLONE_PARAMS *param)
{
+ PERL_UNUSED_ARG(param);
SvREFCNT_inc_void(mg->mg_ptr);
return (0);
}
}
}
SHARED_CONTEXT;
- hv_delete((HV*) saggregate, key, len, G_DISCARD);
+ (void) hv_delete((HV*) saggregate, key, len, G_DISCARD);
}
CALLER_CONTEXT;
LEAVE_LOCK;
int
sharedsv_elem_mg_dup(pTHX_ MAGIC *mg, CLONE_PARAMS *param)
{
+ PERL_UNUSED_ARG(param);
SvREFCNT_inc_void(S_sharedsv_from_obj(aTHX_ mg->mg_obj));
assert(mg->mg_flags & MGf_DUP);
return (0);
dTHXc;
SV *ssv = (SV *) mg->mg_ptr;
U32 val;
+ PERL_UNUSED_ARG(sv);
SHARED_EDIT;
if (SvTYPE(ssv) == SVt_PVAV) {
val = av_len((AV*) ssv);
{
dTHXc;
SV *ssv = (SV *) mg->mg_ptr;
+ PERL_UNUSED_ARG(sv);
SHARED_EDIT;
if (SvTYPE(ssv) == SVt_PVAV) {
av_clear((AV*) ssv);
int
sharedsv_array_mg_free(pTHX_ SV *sv, MAGIC *mg)
{
+ PERL_UNUSED_ARG(sv);
S_sharedsv_dec(aTHX_ (SV*)mg->mg_ptr);
return (0);
}
MAGIC *nmg = sv_magicext(nsv,mg->mg_obj,
toLOWER(mg->mg_type),&sharedsv_elem_vtbl,
name, namlen);
+ PERL_UNUSED_ARG(sv);
nmg->mg_flags |= MGf_DUP;
return (1);
}
int
sharedsv_array_mg_dup(pTHX_ MAGIC *mg, CLONE_PARAMS *param)
{
+ PERL_UNUSED_ARG(param);
SvREFCNT_inc_void((SV*)mg->mg_ptr);
assert(mg->mg_flags & MGf_DUP);
return (0);
ithread_mg_free(pTHX_ SV *sv, MAGIC *mg)
{
ithread *thread = (ithread *)mg->mg_ptr;
+ PERL_UNUSED_ARG(sv);
MUTEX_LOCK(&thread->mutex);
S_ithread_free(aTHX_ thread); /* Releases MUTEX */
return (0);
int
ithread_mg_dup(pTHX_ MAGIC *mg, CLONE_PARAMS *param)
{
+ PERL_UNUSED_ARG(param);
S_ithread_count_inc(aTHX_ (ithread *)mg->mg_ptr);
return (0);
}
IV iv;
dMY_CXT;
- for (iv = 0; iv < sizeof(specialsv_list)/sizeof(SV*); iv++) {
+ for (iv = 0; iv < (IV)(sizeof(specialsv_list)/sizeof(SV*)); iv++) {
if (sv == specialsv_list[iv]) {
type = "B::SPECIAL";
break;
ret = sv_2mortal(newSVpv(*((char **)ptr), 0));
break;
#endif
+ default:
+ croak("Illegal alias 0x%08x for B::*next", (unsigned)ix);
+
}
ST(0) = ret;
XSRETURN(1);
case (U8)(sv_U16p >> 16):
ret = sv_2mortal(newSVuv(*((U16 *)ptr)));
break;
+ default:
+ croak("Illegal alias 0x%08x for B::*IVX", (unsigned)ix);
}
ST(0) = ret;
XSRETURN(1);
case (U8)(line_tp >> 16):
ret = sv_2mortal(newSVuv(*((line_t *)ptr)));
break;
+ default:
+ croak("Illegal alias 0x%08x for B::*SV", (unsigned)ix);
}
ST(0) = ret;
XSRETURN(1);
static void
fill_mstats(SV *sv, int level)
{
+ PERL_UNUSED_ARG(sv);
+ PERL_UNUSED_ARG(level);
croak("Cannot report mstats without Perl malloc");
}
static void
mstats_fillhash(SV *sv, int level)
{
+ PERL_UNUSED_ARG(sv);
+ PERL_UNUSED_ARG(level);
croak("Cannot report mstats without Perl malloc");
}
static void
mstats2hash(SV *sv, SV *rv, int level)
{
+ PERL_UNUSED_ARG(sv);
+ PERL_UNUSED_ARG(rv);
+ PERL_UNUSED_ARG(level);
croak("Cannot report mstats without Perl malloc");
}
#endif /* defined(MYMALLOC) */
mode = &PL_sv_undef;
EXTEND(SP, 1);
}
- PUSHs(((SvUV(mode) & S_IFMT) == ix) ? &PL_sv_yes : &PL_sv_no);
+ PUSHs(((SvUV(mode) & S_IFMT) == (UV)ix) ? &PL_sv_yes : &PL_sv_no);
PUTBACK;
}
#else
static int
errfunc(const char *foo, int bar) {
+ PERL_UNUSED_ARG(foo);
return !(bar == EACCES || bar == ENOENT || bar == ENOTDIR);
}
#endif
* the uf_set field of the uvar magic of a trigger.
*/
I32 HUF_destroy_obj(pTHX_ IV index, SV* trigger) {
+ PERL_UNUSED_ARG(index);
/* Do nothing if the weakref wasn't undef'd. Also don't bother
* during global destruction. (MY_CXT.ob_reg is sometimes funny there) */
if (!SvROK(trigger) && (!PL_in_clean_all)) {
HV* field_tab = (HV*) *av_fetch(cont, 1, 0);
HE* ent;
hv_iterinit(field_tab);
- while (ent = hv_iternext(field_tab)) {
+ while ((ent = hv_iternext(field_tab))) {
SV* field_ref = HeVAL(ent);
SV* field = SvRV(field_ref);
- hv_delete_ent((HV*)field, ob_id, 0, 0);
+ (void) hv_delete_ent((HV*)field, ob_id, 0, 0);
}
/* make it safe in case we must run in global clenaup, after all */
if (PL_in_clean_all)
HUF_global(HUF_RESET); /* shoudn't be needed */
- hv_delete_ent(MY_CXT.ob_reg, ob_id, 0, 0);
+ (void) hv_delete_ent(MY_CXT.ob_reg, ob_id, 0, 0);
}
return 0;
}
av_store(cont, 0, SvREFCNT_inc(ob_id));
av_store(cont, 1, (SV*)newHV());
HUF_add_uvar_magic(trigger, NULL, &HUF_destroy_obj, 0, (SV*)cont);
- hv_store_ent(MY_CXT.ob_reg, ob_id, trigger, 0);
+ (void) hv_store_ent(MY_CXT.ob_reg, ob_id, trigger, 0);
return trigger;
}
SV* HUF_ask_trigger(SV* ob_id) {
dMY_CXT;
HE* ent;
- if (ent = hv_fetch_ent(MY_CXT.ob_reg, ob_id, 0, 0))
+ if ((ent = hv_fetch_ent(MY_CXT.ob_reg, ob_id, 0, 0)))
return HeVAL(ent);
return NULL;
}
HV* field_tab = (HV*) *av_fetch(cont, 1, 0);
SV* field_ref = newRV_inc(field);
UV field_addr = PTR2UV(field);
- hv_store(field_tab, (char *)&field_addr, sizeof(field_addr), field_ref, 0);
+ (void) hv_store(field_tab, (char *)&field_addr, sizeof(field_addr), field_ref, 0);
}
/* Determine, from the value of action, whether this call may create a new
} else if (HUF_WOULD_CREATE_KEY(action)) { /* string key */
/* registered as object id? */
SV* trigger;
- if ( trigger = HUF_ask_trigger(keysv))
+ if (( trigger = HUF_ask_trigger(keysv)))
HUF_mark_field( trigger, field);
}
} else {
I32 HUF_watch_key_id(pTHX_ IV action, SV* field) {
MAGIC* mg = mg_find(field, PERL_MAGIC_uvar);
SV* keysv;
+ PERL_UNUSED_ARG(action);
if (mg && (keysv = mg->mg_obj)) {
if (SvROK(keysv)) /* ref key */
mg->mg_obj = HUF_obj_id(keysv); /* key replacement */
HE* ent;
SV* old_id = *av_fetch(cont, 0, 0);
hv_iterinit(field_tab);
- while (ent = hv_iternext(field_tab)) {
+ while ((ent = hv_iternext(field_tab))) {
SV* field_ref = HeVAL(ent);
HV* field = (HV*)SvRV(field_ref);
UV field_addr = PTR2UV(field);
SV* val;
/* recreate field tab entry */
- hv_store(new_tab, (char *)&field_addr, sizeof(field_addr), SvREFCNT_inc(field_ref), 0);
+ (void) hv_store(new_tab, (char *)&field_addr, sizeof(field_addr), SvREFCNT_inc(field_ref), 0);
/* recreate field entry, if any */
- if (val = hv_delete_ent(field, old_id, 0, 0))
- hv_store_ent(field, new_id, SvREFCNT_inc(val), 0);
+ if ((val = hv_delete_ent(field, old_id, 0, 0)))
+ (void) hv_store_ent(field, new_id, SvREFCNT_inc(val), 0);
}
/* update the trigger */
av_store(cont, 0, SvREFCNT_inc(new_id));
HE* ent;
AV* oblist = (AV*)sv_2mortal((SV*)newAV());
hv_iterinit(MY_CXT.ob_reg);
- while(ent = hv_iternext(MY_CXT.ob_reg))
+ while((ent = hv_iternext(MY_CXT.ob_reg)))
av_push(oblist, SvREFCNT_inc(hv_iterkeysv(ent)));
len = av_len(oblist);
for (i = 0; i <= len; ++i) {
}
HUF_fix_trigger(trigger, new_id);
- hv_store_ent(MY_CXT.ob_reg, new_id, SvREFCNT_inc(trigger), 0);
+ (void) hv_store_ent(MY_CXT.ob_reg, new_id, SvREFCNT_inc(trigger), 0);
}
}
static SV* counter;
I32 HUF_inc_var(pTHX_ IV index, SV* which) {
+ PERL_UNUSED_ARG(index);
+ PERL_UNUSED_ARG(which);
sv_setiv(counter, 1 + SvIV(counter));
return 0;
}
HV* field_tab = (HV*) *av_fetch(cont, 1, 0);
HE* ent;
hv_iterinit(field_tab);
- while (ent = hv_iternext(field_tab)) {
+ while ((ent = hv_iternext(field_tab))) {
HV* field = (HV*)SvRV(HeVAL(ent));
if (hv_exists_ent(field, ob_id, 0))
XPUSHs(sv_2mortal(newRV_inc((SV*)field)));
for(i=0; i < PL_maxo; ++i) {
SV * const sv = newSViv(i);
SvREADONLY_on(sv);
- hv_store(op_named_bits, op_names[i], strlen(op_names[i]), sv, 0);
+ (void) hv_store(op_named_bits, op_names[i], strlen(op_names[i]), sv, 0);
}
put_op_bitspec(aTHX_ STR_WITH_LEN(":none"), sv_2mortal(new_opset(aTHX_ Nullsv)));
if (strNE(HvNAME_get(hv),"main")) {
/* make it think it's in main:: */
hv_name_set(hv, "main", 4, 0);
- hv_store(hv,"_",1,(SV *)PL_defgv,0); /* connect _ to global */
+ (void) hv_store(hv,"_",1,(SV *)PL_defgv,0); /* connect _ to global */
SvREFCNT_inc((SV *)PL_defgv); /* want to keep _ around! */
}
LEAVE;
#endif
break;
default:
- Perl_croak(aTHX_ "Illegal alias %d for POSIX::W*", ix);
+ Perl_croak(aTHX_ "Illegal alias %d for POSIX::W*", (int)ix);
}
OUTPUT:
RETVAL
if ((lcbuf = localeconv())) {
/* the strings */
if (lcbuf->decimal_point && *lcbuf->decimal_point)
- hv_store(RETVAL, "decimal_point", 13,
+ (void) hv_store(RETVAL, "decimal_point", 13,
newSVpv(lcbuf->decimal_point, 0), 0);
if (lcbuf->thousands_sep && *lcbuf->thousands_sep)
- hv_store(RETVAL, "thousands_sep", 13,
+ (void) hv_store(RETVAL, "thousands_sep", 13,
newSVpv(lcbuf->thousands_sep, 0), 0);
#ifndef NO_LOCALECONV_GROUPING
if (lcbuf->grouping && *lcbuf->grouping)
- hv_store(RETVAL, "grouping", 8,
+ (void) hv_store(RETVAL, "grouping", 8,
newSVpv(lcbuf->grouping, 0), 0);
#endif
if (lcbuf->int_curr_symbol && *lcbuf->int_curr_symbol)
- hv_store(RETVAL, "int_curr_symbol", 15,
+ (void) hv_store(RETVAL, "int_curr_symbol", 15,
newSVpv(lcbuf->int_curr_symbol, 0), 0);
if (lcbuf->currency_symbol && *lcbuf->currency_symbol)
- hv_store(RETVAL, "currency_symbol", 15,
+ (void) hv_store(RETVAL, "currency_symbol", 15,
newSVpv(lcbuf->currency_symbol, 0), 0);
if (lcbuf->mon_decimal_point && *lcbuf->mon_decimal_point)
- hv_store(RETVAL, "mon_decimal_point", 17,
+ (void) hv_store(RETVAL, "mon_decimal_point", 17,
newSVpv(lcbuf->mon_decimal_point, 0), 0);
#ifndef NO_LOCALECONV_MON_THOUSANDS_SEP
if (lcbuf->mon_thousands_sep && *lcbuf->mon_thousands_sep)
- hv_store(RETVAL, "mon_thousands_sep", 17,
+ (void) hv_store(RETVAL, "mon_thousands_sep", 17,
newSVpv(lcbuf->mon_thousands_sep, 0), 0);
#endif
#ifndef NO_LOCALECONV_MON_GROUPING
if (lcbuf->mon_grouping && *lcbuf->mon_grouping)
- hv_store(RETVAL, "mon_grouping", 12,
+ (void) hv_store(RETVAL, "mon_grouping", 12,
newSVpv(lcbuf->mon_grouping, 0), 0);
#endif
if (lcbuf->positive_sign && *lcbuf->positive_sign)
- hv_store(RETVAL, "positive_sign", 13,
+ (void) hv_store(RETVAL, "positive_sign", 13,
newSVpv(lcbuf->positive_sign, 0), 0);
if (lcbuf->negative_sign && *lcbuf->negative_sign)
- hv_store(RETVAL, "negative_sign", 13,
+ (void) hv_store(RETVAL, "negative_sign", 13,
newSVpv(lcbuf->negative_sign, 0), 0);
/* the integers */
if (lcbuf->int_frac_digits != CHAR_MAX)
- hv_store(RETVAL, "int_frac_digits", 15,
+ (void) hv_store(RETVAL, "int_frac_digits", 15,
newSViv(lcbuf->int_frac_digits), 0);
if (lcbuf->frac_digits != CHAR_MAX)
- hv_store(RETVAL, "frac_digits", 11,
+ (void) hv_store(RETVAL, "frac_digits", 11,
newSViv(lcbuf->frac_digits), 0);
if (lcbuf->p_cs_precedes != CHAR_MAX)
- hv_store(RETVAL, "p_cs_precedes", 13,
+ (void) hv_store(RETVAL, "p_cs_precedes", 13,
newSViv(lcbuf->p_cs_precedes), 0);
if (lcbuf->p_sep_by_space != CHAR_MAX)
- hv_store(RETVAL, "p_sep_by_space", 14,
+ (void) hv_store(RETVAL, "p_sep_by_space", 14,
newSViv(lcbuf->p_sep_by_space), 0);
if (lcbuf->n_cs_precedes != CHAR_MAX)
- hv_store(RETVAL, "n_cs_precedes", 13,
+ (void) hv_store(RETVAL, "n_cs_precedes", 13,
newSViv(lcbuf->n_cs_precedes), 0);
if (lcbuf->n_sep_by_space != CHAR_MAX)
- hv_store(RETVAL, "n_sep_by_space", 14,
+ (void) hv_store(RETVAL, "n_sep_by_space", 14,
newSViv(lcbuf->n_sep_by_space), 0);
if (lcbuf->p_sign_posn != CHAR_MAX)
- hv_store(RETVAL, "p_sign_posn", 11,
+ (void) hv_store(RETVAL, "p_sign_posn", 11,
newSViv(lcbuf->p_sign_posn), 0);
if (lcbuf->n_sign_posn != CHAR_MAX)
- hv_store(RETVAL, "n_sign_posn", 11,
+ (void) hv_store(RETVAL, "n_sign_posn", 11,
newSViv(lcbuf->n_sign_posn), 0);
}
#else
{
PerlIOEncode *e = PerlIOSelf(f, PerlIOEncode);
SV *sv = &PL_sv_undef;
+ PERL_UNUSED_ARG(param);
+ PERL_UNUSED_ARG(flags);
if (e->enc) {
dSP;
/* Not 100% sure stack swap is right thing to do during dup ... */
IV
PerlIOScalar_fileno(pTHX_ PerlIO * f)
{
+ PERL_UNUSED_ARG(f);
return -1;
}
got = len - (STRLEN)(s->posn);
if (got <= 0)
return 0;
- if (got > (STRLEN)count)
+ if ((STRLEN)got > (STRLEN)count)
got = (STRLEN)count;
Copy(p + (STRLEN)(s->posn), vbuf, got, STDCHAR);
s->posn += (Off_t)got;
IV
PerlIOScalar_fill(pTHX_ PerlIO * f)
{
+ PERL_UNUSED_ARG(f);
return -1;
}
IV
PerlIOScalar_flush(pTHX_ PerlIO * f)
{
+ PERL_UNUSED_ARG(f);
return 0;
}
PerlIOScalar_set_ptrcnt(pTHX_ PerlIO * f, STDCHAR * ptr, SSize_t cnt)
{
PerlIOScalar *s = PerlIOSelf(f, PerlIOScalar);
+ PERL_UNUSED_ARG(ptr);
SvGETMAGIC(s->var);
s->posn = SvCUR(s->var) - cnt;
}
PerlIO * f, int narg, SV ** args)
{
SV *arg = (narg > 0) ? *args : PerlIOArg;
+ PERL_UNUSED_ARG(fd);
+ PERL_UNUSED_ARG(imode);
+ PERL_UNUSED_ARG(perm);
if (SvROK(arg) || SvPOK(arg)) {
if (!f) {
f = PerlIO_allocate(aTHX);
s->io = GvIOp(gv);
if (gv) {
/* shamelessly stolen from IO::File's new_tmpfile() */
- hv_delete(GvSTASH(gv), GvNAME(gv), GvNAMELEN(gv), G_DISCARD);
+ (void) hv_delete(GvSTASH(gv), GvNAME(gv), GvNAMELEN(gv), G_DISCARD);
}
}
IoIFP(s->io) = PerlIONext(f);
PerlIOVia_set_ptrcnt(pTHX_ PerlIO * f, STDCHAR * ptr, SSize_t cnt)
{
PerlIOVia *s = PerlIOSelf(f, PerlIOVia);
+ PERL_UNUSED_ARG(ptr);
s->cnt = cnt;
}
PerlIOVia_getarg(pTHX_ PerlIO * f, CLONE_PARAMS * param, int flags)
{
PerlIOVia *s = PerlIOSelf(f, PerlIOVia);
+ PERL_UNUSED_ARG(param);
+ PERL_UNUSED_ARG(flags);
return PerlIOVia_method(aTHX_ f, MYMethod(GETARG), G_SCALAR, Nullsv);
}
register int off;
register short *ino = (short *) pag;
- if ((n = ino[0]) < 0 || n > PBLKSIZ / sizeof(short))
+ if ((n = ino[0]) < 0 || n > (int)(PBLKSIZ / sizeof(short)))
return 0;
if (n > 0) {
addr_len = (char *)&addr - (char *)&(addr.sun_path) + sockaddrlen;
} else {
for (addr_len = 0; addr.sun_path[addr_len]
- && addr_len < sizeof addr.sun_path; addr_len++);
+ && addr_len < (int)sizeof(addr.sun_path); addr_len++);
}
ST(0) = newSVpvn_flags(addr.sun_path, addr_len, SVs_TEMP);
#else
/* Storing then deleting something should ensure that a hash entry is
available. */
- hv_store(test_hash, "", 0, &PL_sv_yes, 0);
- hv_delete(test_hash, "", 0, 0);
+ (void) hv_store(test_hash, "", 0, &PL_sv_yes, 0);
+ (void) hv_delete(test_hash, "", 0, 0);
/* We need to "inline" new_he here as it's static, and the functions we
test expect to be able to call del_HE on the HE */
i = 0;
do {
mPUSHu(results[i]);
- } while (++i < sizeof(results)/sizeof(results[0]));
+ } while (++i < (int)(sizeof(results)/sizeof(results[0])));
/* Goodbye to our extra reference. */
SvREFCNT_dec(test_scalar);
bitflip_key(pTHX_ IV action, SV *field) {
MAGIC *mg = mg_find(field, PERL_MAGIC_uvar);
SV *keysv;
+ PERL_UNUSED_ARG(action);
if (mg && (keysv = mg->mg_obj)) {
STRLEN len;
const char *p = SvPV(keysv, len);
rot13_key(pTHX_ IV action, SV *field) {
MAGIC *mg = mg_find(field, PERL_MAGIC_uvar);
SV *keysv;
+ PERL_UNUSED_ARG(action);
if (mg && (keysv = mg->mg_obj)) {
STRLEN len;
const char *p = SvPV(keysv, len);
STATIC I32
rmagical_a_dummy(pTHX_ IV idx, SV *sv) {
+ PERL_UNUSED_ARG(idx);
+ PERL_UNUSED_ARG(sv);
return 0;
}
dMY_CXT;
AV *const cur = GvAV(MY_CXT.cscgv);
+ PERL_UNUSED_ARG(full);
SAVEGENERICSV(GvAV(MY_CXT.cscgv));
if (cur) {
{
dMY_CXT;
+ PERL_UNUSED_ARG(o);
/* if we hit the end of a scope we missed the start of, we need to
* unconditionally clear @CSC */
if (GvAV(MY_CXT.cscgv) == MY_CXT.cscav && MY_CXT.cscav) {
{
dMY_CXT;
+ PERL_UNUSED_ARG(o);
if (MY_CXT.bhk_record)
av_push(MY_CXT.bhkav, newSVpvs("pre_end"));
}
{
dMY_CXT;
+ PERL_UNUSED_ARG(o);
if (MY_CXT.bhk_record)
av_push(MY_CXT.bhkav, newSVpvs("post_end"));
}
STATIC OP *
THX_ck_entersub_args_lists(pTHX_ OP *entersubop, GV *namegv, SV *ckobj)
{
+ PERL_UNUSED_ARG(namegv);
+ PERL_UNUSED_ARG(ckobj);
return ck_entersub_args_list(entersubop);
}
THX_ck_entersub_args_scalars(pTHX_ OP *entersubop, GV *namegv, SV *ckobj)
{
OP *aop = cUNOPx(entersubop)->op_first;
+ PERL_UNUSED_ARG(namegv);
+ PERL_UNUSED_ARG(ckobj);
if (!aop->op_sibling)
aop = cUNOPx(aop)->op_first;
for (aop = aop->op_sibling; aop->op_sibling; aop = aop->op_sibling) {
{
OP *sumop = NULL;
OP *pushop = cUNOPx(entersubop)->op_first;
+ PERL_UNUSED_ARG(namegv);
+ PERL_UNUSED_ARG(ckobj);
if (!pushop->op_sibling)
pushop = cUNOPx(pushop)->op_first;
while (1) {
STATIC OP *
THX_ck_entersub_postinc(pTHX_ OP *entersubop, GV *namegv, SV *ckobj)
{
- OP *pushop, *argop, *estop;
+ OP *pushop, *argop;
ck_entersub_args_proto(entersubop, namegv, ckobj);
pushop = cUNOPx(entersubop)->op_first;
if(!pushop->op_sibling) pushop = cUNOPx(pushop)->op_first;
MODULE = XS::APItest:Overload PACKAGE = XS::APItest::Overload
-SV *
+void
amagic_deref_call(sv, what)
SV *sv
int what
# I'd certainly like to discourage the use of this macro, given that we now
# have amagic_deref_call
-SV *
+void
tryAMAGICunDEREF_var(sv, what)
SV *sv
int what
av_push(MY_CXT.xop_record, newSVpvf("NAME:%s", OP_NAME((OP*)unop)));
av_push(MY_CXT.xop_record, newSVpvf("DESC:%s", OP_DESC((OP*)unop)));
- av_push(MY_CXT.xop_record, newSVpvf("CLASS:%d", OP_CLASS((OP*)unop)));
+ av_push(MY_CXT.xop_record, newSVpvf("CLASS:%d", (int)OP_CLASS((OP*)unop)));
PL_rpeepp(aTHX_ kid);
CLONE(...)
CODE:
MY_CXT_CLONE;
+ PERL_UNUSED_VAR(items);
MY_CXT.sv = newSVpv("initial_clone",0);
MY_CXT.cscgv = gv_fetchpvs("XS::APItest::COMPILE_SCOPE_CONTAINER",
GV_ADDMULTI, SVt_PVAV);
establish_cleanup(...)
PROTOTYPE: $
CODE:
+ PERL_UNUSED_VAR(items);
croak("establish_cleanup called as a function");
BOOT:
postinc(...)
PROTOTYPE: $
CODE:
+ PERL_UNUSED_VAR(items);
croak("postinc called as a function");
BOOT:
https://perl5.git.perl.org / perl5.git / commitdiff