}
-void NWPerlHashList::forAll( register void (*user_fn)(void *, void*), void *data ) const
+void NWPerlHashList::forAll( void (*user_fn)(void *, void*), void *data ) const
{
for(int i=0; i<BUCKET_SIZE; i++)
}
-void NWPerlKeyHashList::forAll( register void (*user_fn)(void *, void*), void *data ) const
+void NWPerlKeyHashList::forAll( void (*user_fn)(void *, void*), void *data ) const
{
for(int i=0; i<BUCKET_SIZE; i++)
void
-Perl_sv_catsv(pTHX_ SV *dstr, register SV *sstr)
+Perl_sv_catsv(pTHX_ SV *dstr, SV *sstr)
{
sv_catsv_flags(dstr, sstr, SV_GMAGIC);
}
}
void
-Perl_sv_setsv(pTHX_ SV *dstr, register SV *sstr)
+Perl_sv_setsv(pTHX_ SV *dstr, SV *sstr)
{
sv_setsv_flags(dstr, sstr, SV_GMAGIC);
}
char *
-Perl_sv_2pv(pTHX_ register SV *sv, STRLEN *lp)
+Perl_sv_2pv(pTHX_ SV *sv, STRLEN *lp)
{
return sv_2pv_flags(sv, lp, SV_GMAGIC);
}
}
SV**
-Perl_av_fetch(pTHX_ register AV *av, I32 key, I32 lval)
+Perl_av_fetch(pTHX_ AV *av, I32 key, I32 lval)
{
dVAR;
*/
SV**
-Perl_av_store(pTHX_ register AV *av, I32 key, SV *val)
+Perl_av_store(pTHX_ AV *av, I32 key, SV *val)
{
dVAR;
SV** ary;
*/
AV *
-Perl_av_make(pTHX_ register I32 size, register SV **strp)
+Perl_av_make(pTHX_ I32 size, SV **strp)
{
AV * const av = MUTABLE_AV(newSV_type(SVt_PVAV));
/* sv_upgrade does AvREAL_only() */
*/
void
-Perl_av_clear(pTHX_ register AV *av)
+Perl_av_clear(pTHX_ AV *av)
{
dVAR;
I32 extra;
*/
void
-Perl_av_undef(pTHX_ register AV *av)
+Perl_av_undef(pTHX_ AV *av)
{
bool real;
*/
void
-Perl_av_push(pTHX_ register AV *av, SV *val)
+Perl_av_push(pTHX_ AV *av, SV *val)
{
dVAR;
MAGIC *mg;
*/
SV *
-Perl_av_pop(pTHX_ register AV *av)
+Perl_av_pop(pTHX_ AV *av)
{
dVAR;
SV *retval;
*/
void
-Perl_av_unshift(pTHX_ register AV *av, register I32 num)
+Perl_av_unshift(pTHX_ AV *av, I32 num)
{
dVAR;
I32 i;
*/
SV *
-Perl_av_shift(pTHX_ register AV *av)
+Perl_av_shift(pTHX_ AV *av)
{
dVAR;
SV *retval;
=cut
*/
void
-Perl_av_fill(pTHX_ register AV *av, I32 fill)
+Perl_av_fill(pTHX_ AV *av, I32 fill)
{
dVAR;
MAGIC *mg;
use Exporter;
use vars qw(@ISA @EXPORT @EXPORT_OK $VERSION);
-$VERSION = '3.39_02';
+$VERSION = '3.39_03';
my $xs_version = $VERSION;
$VERSION =~ tr/_//;
#ifndef getcwd_sv
/* Taken from perl 5.8's util.c */
#define getcwd_sv(a) Perl_getcwd_sv(aTHX_ a)
-int Perl_getcwd_sv(pTHX_ register SV *sv)
+int Perl_getcwd_sv(pTHX_ SV *sv)
{
#ifndef PERL_MICRO
package Data::Dumper;
BEGIN {
- $VERSION = '2.137'; # Don't forget to set version and release
-} # date in POD!
+ $VERSION = '2.138'; # Don't forget to set version and release
+} # date in POD below!
#$| = 1;
=head1 VERSION
-Version 2.137 (October 22 2012)
+Version 2.138 (November 25 2012)
=head1 SEE ALSO
static I32 num_q (const char *s, STRLEN slen);
static I32 esc_q (char *dest, const char *src, STRLEN slen);
static I32 esc_q_utf8 (pTHX_ SV *sv, const char *src, STRLEN slen);
-static I32 needs_quote(register const char *s, STRLEN len);
+static I32 needs_quote(const char *s, STRLEN len);
static SV *sv_x (pTHX_ SV *sv, const char *str, STRLEN len, I32 n);
static I32 DD_dump (pTHX_ SV *val, const char *name, STRLEN namelen, SV *retval,
HV *seenhv, AV *postav, I32 *levelp, I32 indent,
/* does a string need to be protected? */
static I32
-needs_quote(register const char *s, STRLEN len)
+needs_quote(const char *s, STRLEN len)
{
const char *send = s+len;
TOP:
/* count the number of "'"s and "\"s in string */
static I32
-num_q(register const char *s, register STRLEN slen)
+num_q(const char *s, STRLEN slen)
{
I32 ret = 0;
/* slen number of characters in s will be escaped */
/* destination must be long enough for additional chars */
static I32
-esc_q(register char *d, register const char *s, register STRLEN slen)
+esc_q(char *d, const char *s, STRLEN slen)
{
I32 ret = 0;
}
static I32
-esc_q_utf8(pTHX_ SV* sv, register const char *src, register STRLEN slen)
+esc_q_utf8(pTHX_ SV* sv, const char *src, STRLEN slen)
{
char *r, *rstart;
const char *s = src;
#include <signal.h>
bool
-Perl_do_openn(pTHX_ GV *gv, register const char *oname, I32 len, int as_raw,
+Perl_do_openn(pTHX_ GV *gv, const char *oname, I32 len, int as_raw,
int rawmode, int rawperm, PerlIO *supplied_fp, SV **svp,
I32 num_svs)
{
}
PerlIO *
-Perl_nextargv(pTHX_ register GV *gv)
+Perl_nextargv(pTHX_ GV *gv)
{
dVAR;
SV *sv;
#endif /* !HAS_TRUNCATE && !HAS_CHSIZE */
bool
-Perl_do_print(pTHX_ register SV *sv, PerlIO *fp)
+Perl_do_print(pTHX_ SV *sv, PerlIO *fp)
{
dVAR;
}
bool
-Perl_do_aexec5(pTHX_ SV *really, register SV **mark, register SV **sp,
+Perl_do_aexec5(pTHX_ SV *really, SV **mark, SV **sp,
int fd, int do_report)
{
dVAR;
#endif
I32
-Perl_apply(pTHX_ I32 type, register SV **mark, register SV **sp)
+Perl_apply(pTHX_ I32 type, SV **mark, SV **sp)
{
dVAR;
I32 val;
/* Do the permissions allow some operation? Assumes statcache already set. */
#ifndef VMS /* VMS' cando is in vms.c */
bool
-Perl_cando(pTHX_ Mode_t mode, bool effective, register const Stat_t *statbufp)
+Perl_cando(pTHX_ Mode_t mode, bool effective, const Stat_t *statbufp)
/* effective is a flag, true for EUID, or for checking if the effective gid
* is in the list of groups returned from getgroups().
*/
}
void
-Perl_do_join(pTHX_ register SV *sv, SV *delim, register SV **mark, register SV **sp)
+Perl_do_join(pTHX_ SV *sv, SV *delim, SV **mark, SV **sp)
{
dVAR;
SV ** const oldmark = mark;
Pulled from regcomp.c.
*/
PERL_STATIC_INLINE I32
-S_regcurly(pTHX_ register const char *s)
+S_regcurly(pTHX_ const char *s)
{
PERL_ARGS_ASSERT_REGCURLY;
package Devel::Peek;
-$VERSION = '1.10';
+$VERSION = '1.11';
$XS_VERSION = $VERSION;
$VERSION = eval $VERSION;
SV* sva;
SV* sv;
SV* ret = newRV_noinc((SV*)newAV());
- register SV* svend;
+ SV* svend;
int tm = 0, tref = 0, ts = 0, ta = 0, tas = 0;
for (sva = PL_sv_arenaroot; sva; sva = (SV*)SvANY(sva)) {
# Tim.Bunce@ig.co.uk, August 1994
BEGIN {
- $VERSION = '1.17';
+ $VERSION = '1.18';
}
use Config;
{
dTHX;
dMY_CXT;
- register ModulePtr mp;
+ ModulePtr mp;
/*
* Upon the first call register a terminate handler that will
{
dTHX;
dMY_CXT;
- register char *p = s;
+ char *p = s;
while (*p >= '0' && *p <= '9')
p++;
{
dTHX;
dMY_CXT;
- register ModulePtr mp = (ModulePtr)handle;
- register ExportPtr ep;
- register int i;
+ ModulePtr mp = (ModulePtr)handle;
+ ExportPtr ep;
+ int i;
/*
* Could speed up search, but I assume that one assigns
{
dTHX;
dMY_CXT;
- register ModulePtr mp = (ModulePtr)handle;
+ ModulePtr mp = (ModulePtr)handle;
int result;
- register ModulePtr mp1;
+ ModulePtr mp1;
if (--mp->refCnt > 0)
return 0;
strerrorcpy(dl_errbuf, errno);
}
if (mp->exports) {
- register ExportPtr ep;
- register int i;
+ ExportPtr ep;
+ int i;
for (ep = mp->exports, i = mp->nExports; i; i--, ep++)
if (ep->name)
safefree(ep->name);
Char *pattern, Char *pattern_last,
Char *restpattern, Char *restpattern_last, glob_t *pglob, size_t *limitp)
{
- register Direntry_t *dp;
+ Direntry_t *dp;
DIR *dirp;
int err;
int nocase;
else
readdirfunc = (Direntry_t *(*)(DIR *))my_readdir;
while ((dp = (*readdirfunc)(dirp))) {
- register U8 *sc;
- register Char *dc;
+ U8 *sc;
+ Char *dc;
/* Initial BG_DOT must be matched literally. */
if (dp->d_name[0] == BG_DOT && *pattern != BG_DOT)
static int
globextend(const Char *path, glob_t *pglob, size_t *limitp)
{
- register char **pathv;
- register int i;
+ char **pathv;
+ int i;
STRLEN newsize, len;
char *copy;
const Char *p;
* pattern causes a recursion level.
*/
static int
-match(register Char *name, register Char *pat, register Char *patend, int nocase)
+match(Char *name, Char *pat, Char *patend, int nocase)
{
int ok, negate_range;
Char c, k;
void
bsd_globfree(glob_t *pglob)
{
- register int i;
- register char **pp;
+ int i;
+ char **pp;
if (pglob->gl_pathv != NULL) {
pp = pglob->gl_pathv + pglob->gl_offs;
}
static DIR *
-g_opendir(register Char *str, glob_t *pglob)
+g_opendir(Char *str, glob_t *pglob)
{
char buf[MAXPATHLEN];
}
static int
-g_lstat(register Char *fn, Stat_t *sb, glob_t *pglob)
+g_lstat(Char *fn, Stat_t *sb, glob_t *pglob)
{
char buf[MAXPATHLEN];
}
static int
-g_stat(register Char *fn, Stat_t *sb, glob_t *pglob)
+g_stat(Char *fn, Stat_t *sb, glob_t *pglob)
{
char buf[MAXPATHLEN];
}
static int
-g_Ctoc(register const Char *str, char *buf, STRLEN len)
+g_Ctoc(const Char *str, char *buf, STRLEN len)
{
while (len--) {
if ((*buf++ = (char)*str++) == BG_EOS)
#ifdef GLOB_DEBUG
static void
-qprintf(const char *str, register Char *s)
+qprintf(const char *str, Char *s)
{
- register Char *p;
+ Char *p;
(void)printf("%s:\n", str);
for (p = s; *p; p++)
*/
long
dbm_hash(char *str, int len) {
- register unsigned long n = 0;
+ unsigned long n = 0;
while (len--)
n = n * 65599 + *str++;
void
sdump(int pagf)
{
- register b;
- register n = 0;
- register t = 0;
- register o = 0;
- register e;
+ int b;
+ int n = 0;
+ int t = 0;
+ int o = 0;
+ int e;
char pag[PBLKSIZ];
while ((b = read(pagf, pag, PBLKSIZ)) > 0) {
int
pagestat(char *pag)
{
- register n;
- register free;
- register short *ino = (short *) pag;
+ int n;
+ int free;
+ short *ino = (short *) pag;
if (!(n = ino[0]))
printf("no entries.\n");
void
sdump(int pagf)
{
- register r;
- register n = 0;
- register o = 0;
+ int r;
+ int n = 0;
+ int o = 0;
char pag[PBLKSIZ];
while ((r = read(pagf, pag, PBLKSIZ)) > 0) {
int
dispage(char *pag)
{
- register i, n;
- register off;
- register short *ino = (short *) pag;
+ int i, n;
+ int off;
+ int short *ino = (short *) pag;
off = PBLKSIZ;
for (i = 1; i < ino[0]; i += 2) {
void
dispage(char *pag)
{
- register i, n;
- register off;
- register short *ino = (short *) pag;
+ int i, n;
+ int off;
+ short *ino = (short *) pag;
off = PBLKSIZ;
for (i = 1; i < ino[0]; i += 2) {
char
getopt(int argc, char **argv, char *optstring)
{
- register int c;
- register char *place;
+ int c;
+ char *place;
extern char *index();
static int optind = 0;
static char *scan = NULL;
main(int argc, char **argv)
{
int c;
- register cmd *act;
+ cmd *act;
extern int optind;
extern char *optarg;
}
static void
-doit(register cmd *act, char *file)
+doit(cmd *act, char *file)
{
datum key;
datum val;
- register DBM *db;
- register char *op;
- register int n;
+ DBM *db;
+ char *op;
+ int n;
char *line;
#ifdef TIME
long start;
static void
badk(char *word)
{
- register int i;
+ int i;
if (progname)
fprintf(stderr, "%s: ", progname);
}
static cmd *
-parse(register char *str)
+parse(char *str)
{
- register int i = CTABSIZ;
- register cmd *p;
+ int i = CTABSIZ;
+ cmd *p;
for (p = cmds; i--; p++)
if (strcmp(p->sname, str) == 0)
static void
prdatum(FILE *stream, datum d)
{
- register int c;
- register char *p = d.dptr;
- register int n = d.dsize;
+ int c;
+ char *p = d.dptr;
+ int n = d.dsize;
while (n--) {
c = *p++ & 0377;
* 65587 even better.
*/
long
-sdbm_hash(register const char *str, register int len)
+sdbm_hash(const char *str, int len)
{
- register unsigned long n = 0;
+ unsigned long n = 0;
#ifdef DUFF
#define HASHC n = *str++ + 65599 * n
if (len > 0) {
- register int loop = (len + 8 - 1) >> 3;
+ int loop = (len + 8 - 1) >> 3;
switch(len & (8 - 1)) {
case 0: do {
int
fitpair(char *pag, int need)
{
- register int n;
- register int off;
- register int free;
- register short *ino = (short *) pag;
+ int n;
+ int off;
+ int free;
+ short *ino = (short *) pag;
off = ((n = ino[0]) > 0) ? ino[n] : PBLKSIZ;
free = off - (n + 1) * sizeof(short);
void
putpair(char *pag, datum key, datum val)
{
- register int n;
- register int off;
- register short *ino = (short *) pag;
+ int n;
+ int off;
+ short *ino = (short *) pag;
off = ((n = ino[0]) > 0) ? ino[n] : PBLKSIZ;
/*
datum
getpair(char *pag, datum key)
{
- register int i;
- register int n;
+ int i;
+ int n;
datum val;
- register short *ino = (short *) pag;
+ short *ino = (short *) pag;
if ((n = ino[0]) == 0)
return nullitem;
int
exipair(char *pag, datum key)
{
- register short *ino = (short *) pag;
+ short *ino = (short *) pag;
if (ino[0] == 0)
return 0;
int
duppair(char *pag, datum key)
{
- register short *ino = (short *) pag;
+ short *ino = (short *) pag;
return ino[0] > 0 && seepair(pag, ino[0], key.dptr, key.dsize) > 0;
}
#endif
getnkey(char *pag, int num)
{
datum key;
- register int off;
- register short *ino = (short *) pag;
+ int off;
+ short *ino = (short *) pag;
num = num * 2 - 1;
if (ino[0] == 0 || num > ino[0])
int
delpair(char *pag, datum key)
{
- register int n;
- register int i;
- register short *ino = (short *) pag;
+ int n;
+ int i;
+ short *ino = (short *) pag;
if ((n = ino[0]) == 0)
return 0;
* [note: 0 < i < n]
*/
if (i < n - 1) {
- register int m;
- register char *dst = pag + (i == 1 ? PBLKSIZ : ino[i - 1]);
- register char *src = pag + ino[i + 1];
- register int zoo = dst - src;
+ int m;
+ char *dst = pag + (i == 1 ? PBLKSIZ : ino[i - 1]);
+ char *src = pag + ino[i + 1];
+ int zoo = dst - src;
debug(("free-up %d ", zoo));
/*
#define MOVB *--dst = *--src
if (m > 0) {
- register int loop = (m + 8 - 1) >> 3;
+ int loop = (m + 8 - 1) >> 3;
switch (m & (8 - 1)) {
case 0: do {
* return 0 if not found.
*/
static int
-seepair(char *pag, register int n, register const char *key, register int siz)
+seepair(char *pag, int n, const char *key, int siz)
{
- register int i;
- register int off = PBLKSIZ;
- register short *ino = (short *) pag;
+ int i;
+ int off = PBLKSIZ;
+ short *ino = (short *) pag;
for (i = 1; i < n; i += 2) {
if (siz == off - ino[i] &&
datum key;
datum val;
- register int n;
- register int off = PBLKSIZ;
+ int n;
+ int off = PBLKSIZ;
char cur[PBLKSIZ];
- register short *ino = (short *) cur;
+ short *ino = (short *) cur;
(void) memcpy(cur, pag, PBLKSIZ);
(void) memset(pag, 0, PBLKSIZ);
int
chkpage(char *pag)
{
- register int n;
- register int off;
- register short *ino = (short *) pag;
+ int n;
+ int off;
+ short *ino = (short *) pag;
if ((n = ino[0]) < 0 || n > (int)(PBLKSIZ / sizeof(short)))
return 0;
*/
long
dbm_hash(char *str, int len) {
- register unsigned long n = 0;
+ unsigned long n = 0;
while (len--)
n = n * 65599 + *str++;
};
DBM *
-sdbm_open(register char *file, register int flags, register int mode)
+sdbm_open(char *file, int flags, int mode)
{
- register DBM *db;
- register char *dirname;
- register char *pagname;
+ DBM *db;
+ char *dirname;
+ char *pagname;
size_t filelen;
const size_t dirfext_size = sizeof(DIRFEXT "");
const size_t pagfext_size = sizeof(PAGFEXT "");
DBM *
sdbm_prep(char *dirname, char *pagname, int flags, int mode)
{
- register DBM *db;
+ DBM *db;
struct stat dstat;
if ((db = (DBM *) malloc(sizeof(DBM))) == NULL)
}
void
-sdbm_close(register DBM *db)
+sdbm_close(DBM *db)
{
if (db == NULL)
errno = EINVAL;
}
datum
-sdbm_fetch(register DBM *db, datum key)
+sdbm_fetch(DBM *db, datum key)
{
if (db == NULL || bad(key))
return errno = EINVAL, nullitem;
}
int
-sdbm_exists(register DBM *db, datum key)
+sdbm_exists(DBM *db, datum key)
{
if (db == NULL || bad(key))
return errno = EINVAL, -1;
}
int
-sdbm_delete(register DBM *db, datum key)
+sdbm_delete(DBM *db, datum key)
{
if (db == NULL || bad(key))
return errno = EINVAL, -1;
}
int
-sdbm_store(register DBM *db, datum key, datum val, int flags)
+sdbm_store(DBM *db, datum key, datum val, int flags)
{
int need;
- register long hash;
+ long hash;
if (db == NULL || bad(key))
return errno = EINVAL, -1;
* giving up.
*/
static int
-makroom(register DBM *db, long int hash, int need)
+makroom(DBM *db, long int hash, int need)
{
long newp;
char twin[PBLKSIZ];
#endif
char *pag = db->pagbuf;
char *New = twin;
- register int smax = SPLTMAX;
+ int smax = SPLTMAX;
do {
/*
* deletions aren't taken into account. (ndbm bug)
*/
datum
-sdbm_firstkey(register DBM *db)
+sdbm_firstkey(DBM *db)
{
if (db == NULL)
return errno = EINVAL, nullitem;
}
datum
-sdbm_nextkey(register DBM *db)
+sdbm_nextkey(DBM *db)
{
if (db == NULL)
return errno = EINVAL, nullitem;
* all important binary trie traversal
*/
static int
-getpage(register DBM *db, register long int hash)
+getpage(DBM *db, long int hash)
{
- register int hbit;
- register long dbit;
- register long pagb;
+ int hbit;
+ long dbit;
+ long pagb;
dbit = 0;
hbit = 0;
}
static int
-getdbit(register DBM *db, register long int dbit)
+getdbit(DBM *db, long int dbit)
{
- register long c;
- register long dirb;
+ long c;
+ long dirb;
c = dbit / BYTESIZ;
dirb = c / DBLKSIZ;
}
static int
-setdbit(register DBM *db, register long int dbit)
+setdbit(DBM *db, long int dbit)
{
- register long c;
- register long dirb;
+ long c;
+ long dirb;
c = dbit / BYTESIZ;
dirb = c / DBLKSIZ;
* the page, try the next page in sequence
*/
static datum
-getnext(register DBM *db)
+getnext(DBM *db)
{
datum key;
#endif
void
-oops(register char *s1, register char *s2)
+oops(char *s1, char *s2)
{
extern int errno, sys_nerr;
extern char *sys_errlist[];
int
okpage(char *pag)
{
- register unsigned n;
- register off;
- register short *ino = (short *) pag;
+ unsigned n;
+ int off;
+ short *ino = (short *) pag;
if ((n = ino[0]) > PBLKSIZ / sizeof(short))
return 0;
PROTOTYPE: @
CODE:
char *args[8],mode[3] = {'r','\0','\0'}, type = '<';
- register int i, myargc;
+ int i, myargc;
FILE *fp;
SV *fh;
PerlIO *pio_fp;
use warnings;
use Carp;
-our $VERSION = '0.46';
+our $VERSION = '0.47';
require XSLoader;
/* A routine to test hv_delayfree_ent
(which itself is tested by testing on hv_free_ent */
-typedef void (freeent_function)(pTHX_ HV *, register HE *);
+typedef void (freeent_function)(pTHX_ HV *, HE *);
void
test_freeent(freeent_function *f) {
STATIC void ptable_walk(pTHX_ ptable * const t, void (*cb)(pTHX_ ptable_ent *ent, void *userdata), void *userdata) {
#define ptable_walk(T, CB, UD) ptable_walk(aTHX_ (T), (CB), (UD))
if (t && t->items) {
- register ptable_ent ** const array = t->ary;
+ ptable_ent ** const array = t->ary;
UV i = t->max;
do {
ptable_ent *entry;
STATIC void PTABLE_PREFIX(_clear)(pPTBL_ ptable * const t) {
if (t && t->items) {
- register ptable_ent ** const array = t->ary;
+ ptable_ent ** const array = t->ary;
UV i = t->max;
do {
# mro.pm versions < 1.00 reserved for MRO::Compat
# for partial back-compat to 5.[68].x
-our $VERSION = '1.09';
+our $VERSION = '1.10';
sub import {
mro::set_mro(scalar(caller), $_[1]) if $_[1];
PREINIT:
SV* self = ST(0);
const I32 throw_nomethod = SvIVX(ST(1));
- register I32 cxix = cxstack_ix;
- register const PERL_CONTEXT *ccstack = cxstack;
+ I32 cxix = cxstack_ix;
+ const PERL_CONTEXT *ccstack = cxstack;
const PERL_SI *top_si = PL_curstackinfo;
HV* selfstash;
SV *stashname;
require DynaLoader;
@ISA = qw|Exporter DynaLoader|;
- $VERSION = '0.34';
+ $VERSION = '0.35';
$XS_VERSION = $VERSION;
$VERSION = eval $VERSION;
}
static void
-haiku_do_debug_printf(pTHX_ register SV *sv,
+haiku_do_debug_printf(pTHX_ SV *sv,
void (*printfFunc)(const char*,...))
{
dVAR;
void *
Perl_hv_common(pTHX_ HV *hv, SV *keysv, const char *key, STRLEN klen,
- int flags, int action, SV *val, register U32 hash)
+ int flags, int action, SV *val, U32 hash)
{
dVAR;
XPVHV* xhv;
/* like hv_free_ent, but returns the SV rather than freeing it */
STATIC SV*
-S_hv_free_ent_ret(pTHX_ HV *hv, register HE *entry)
+S_hv_free_ent_ret(pTHX_ HV *hv, HE *entry)
{
dVAR;
SV *val;
void
-Perl_hv_free_ent(pTHX_ HV *hv, register HE *entry)
+Perl_hv_free_ent(pTHX_ HV *hv, HE *entry)
{
dVAR;
SV *val;
void
-Perl_hv_delayfree_ent(pTHX_ HV *hv, register HE *entry)
+Perl_hv_delayfree_ent(pTHX_ HV *hv, HE *entry)
{
dVAR;
*/
char *
-Perl_hv_iterkey(pTHX_ register HE *entry, I32 *retlen)
+Perl_hv_iterkey(pTHX_ HE *entry, I32 *retlen)
{
PERL_ARGS_ASSERT_HV_ITERKEY;
*/
SV *
-Perl_hv_iterkeysv(pTHX_ register HE *entry)
+Perl_hv_iterkeysv(pTHX_ HE *entry)
{
PERL_ARGS_ASSERT_HV_ITERKEYSV;
*/
SV *
-Perl_hv_iterval(pTHX_ HV *hv, register HE *entry)
+Perl_hv_iterval(pTHX_ HV *hv, HE *entry)
{
PERL_ARGS_ASSERT_HV_ITERVAL;
* len and hash must both be valid for str.
*/
HEK *
-Perl_share_hek(pTHX_ const char *str, I32 len, register U32 hash)
+Perl_share_hek(pTHX_ const char *str, I32 len, U32 hash)
{
bool is_utf8 = FALSE;
int flags = 0;
}
STATIC HEK *
-S_share_hek_flags(pTHX_ const char *str, I32 len, register U32 hash, int flags)
+S_share_hek_flags(pTHX_ const char *str, I32 len, U32 hash, int flags)
{
dVAR;
HE *entry;
#define PERL_HASH(hash,str,len) \
STMT_START { \
- register const char * const s_PeRlHaSh_tmp = (str); \
- register const unsigned char *s_PeRlHaSh = (const unsigned char *)s_PeRlHaSh_tmp; \
- register const unsigned char *end_PeRlHaSh = (const unsigned char *)s_PeRlHaSh + len; \
- register U32 hash_PeRlHaSh = (PERL_HASH_SEED_U16_x(len & 0xff) << 16) + len; \
+ const char * const s_PeRlHaSh_tmp = (str); \
+ const unsigned char *s_PeRlHaSh = (const unsigned char *)s_PeRlHaSh_tmp; \
+ const unsigned char *end_PeRlHaSh = (const unsigned char *)s_PeRlHaSh + len; \
+ U32 hash_PeRlHaSh = (PERL_HASH_SEED_U16_x(len & 0xff) << 16) + len; \
while (s_PeRlHaSh < end_PeRlHaSh) { \
hash_PeRlHaSh ^= PERL_HASH_SEED_U16_x((U8)*s_PeRlHaSh++); \
hash_PeRlHaSh += BUZZHASH_ROTL32(hash_PeRlHaSh,11); \
#endif
#define PERL_HASH(hash,str,len) \
STMT_START { \
- register const char * const strtmp_PeRlHaSh = (str); \
- register const unsigned char *str_PeRlHaSh = (const unsigned char *)strtmp_PeRlHaSh; \
- register U32 len_PeRlHaSh = (len); \
- register U32 hash_PeRlHaSh = PERL_HASH_SEED_U32 ^ len; \
- register U32 tmp_PeRlHaSh; \
- register int rem_PeRlHaSh= len_PeRlHaSh & 3; \
+ const char * const strtmp_PeRlHaSh = (str); \
+ const unsigned char *str_PeRlHaSh = (const unsigned char *)strtmp_PeRlHaSh; \
+ U32 len_PeRlHaSh = (len); \
+ U32 hash_PeRlHaSh = PERL_HASH_SEED_U32 ^ len; \
+ U32 tmp_PeRlHaSh; \
+ int rem_PeRlHaSh= len_PeRlHaSh & 3; \
len_PeRlHaSh >>= 2; \
\
for (;len_PeRlHaSh > 0; len_PeRlHaSh--) { \
#if defined(UNALIGNED_SAFE)
#define PERL_HASH(hash,str,len) STMT_START { \
- register const char * const s_PeRlHaSh_tmp = (str); \
- register const unsigned char *PeRlHaSh_ptr = (const unsigned char *)s_PeRlHaSh_tmp; \
- register I32 PeRlHaSh_len = len; \
+ const char * const s_PeRlHaSh_tmp = (str); \
+ const unsigned char *PeRlHaSh_ptr = (const unsigned char *)s_PeRlHaSh_tmp; \
+ I32 PeRlHaSh_len = len; \
\
U32 PeRlHaSh_h1 = PERL_HASH_SEED_U32; \
U32 PeRlHaSh_k1; \
} STMT_END
#else
#define PERL_HASH(hash,str,len) STMT_START { \
- register const char * const s_PeRlHaSh_tmp = (str); \
- register const unsigned char *PeRlHaSh_ptr = (const unsigned char *)s_PeRlHaSh_tmp; \
- register I32 PeRlHaSh_len = len; \
+ const char * const s_PeRlHaSh_tmp = (str); \
+ const unsigned char *PeRlHaSh_ptr = (const unsigned char *)s_PeRlHaSh_tmp; \
+ I32 PeRlHaSh_len = len; \
\
U32 PeRlHaSh_h1 = PERL_HASH_SEED_U32; \
U32 PeRlHaSh_k1; \
#define PERL_HASH_SEED_BYTES 4
#define PERL_HASH(hash,str,len) \
STMT_START { \
- register const char * const s_PeRlHaSh_tmp = (str); \
- register const unsigned char *s_PeRlHaSh = (const unsigned char *)s_PeRlHaSh_tmp; \
- register I32 i_PeRlHaSh = len; \
- register U32 hash_PeRlHaSh = PERL_HASH_SEED_U32 ^ len; \
+ const char * const s_PeRlHaSh_tmp = (str); \
+ const unsigned char *s_PeRlHaSh = (const unsigned char *)s_PeRlHaSh_tmp; \
+ I32 i_PeRlHaSh = len; \
+ U32 hash_PeRlHaSh = PERL_HASH_SEED_U32 ^ len; \
while (i_PeRlHaSh--) { \
hash_PeRlHaSh = ((hash_PeRlHaSh << 5) + hash_PeRlHaSh) + *s_PeRlHaSh++; \
} \
#define PERL_HASH_SEED_BYTES 4
#define PERL_HASH(hash,str,len) \
STMT_START { \
- register const char * const s_PeRlHaSh_tmp = (str); \
- register const unsigned char *s_PeRlHaSh = (const unsigned char *)s_PeRlHaSh_tmp; \
- register I32 i_PeRlHaSh = len; \
- register U32 hash_PeRlHaSh = PERL_HASH_SEED_U32 ^ len; \
+ const char * const s_PeRlHaSh_tmp = (str); \
+ const unsigned char *s_PeRlHaSh = (const unsigned char *)s_PeRlHaSh_tmp; \
+ I32 i_PeRlHaSh = len; \
+ U32 hash_PeRlHaSh = PERL_HASH_SEED_U32 ^ len; \
while (i_PeRlHaSh--) { \
hash_PeRlHaSh = (hash_PeRlHaSh << 6) + (hash_PeRlHaSh << 16) - hash_PeRlHaSh + *s_PeRlHaSh++; \
} \
* (http://burtleburtle.net/bob/hash/doobs.html) */
#define PERL_HASH(hash,str,len) \
STMT_START { \
- register const char * const s_PeRlHaSh_tmp = (str); \
- register const unsigned char *s_PeRlHaSh = (const unsigned char *)s_PeRlHaSh_tmp; \
- register I32 i_PeRlHaSh = len; \
- register U32 hash_PeRlHaSh = PERL_HASH_SEED_U32 ^ len; \
+ const char * const s_PeRlHaSh_tmp = (str); \
+ const unsigned char *s_PeRlHaSh = (const unsigned char *)s_PeRlHaSh_tmp; \
+ I32 i_PeRlHaSh = len; \
+ U32 hash_PeRlHaSh = PERL_HASH_SEED_U32 ^ len; \
while (i_PeRlHaSh--) { \
hash_PeRlHaSh += (U8)*s_PeRlHaSh++; \
hash_PeRlHaSh += (hash_PeRlHaSh << 10); \
# define SBRK_FAILURE_PRICE 50
#endif
-static void morecore (register int bucket);
+static void morecore (int bucket);
# if defined(DEBUGGING)
static void botch (const char *diag, const char *s, const char *file, int line);
# endif
* Allocate more memory to the indicated bucket.
*/
static void
-morecore(register int bucket)
+morecore(int bucket)
{
dVAR;
union overhead *ovp;
}
Malloc_t
-Perl_calloc(register size_t elements, register size_t size)
+Perl_calloc(size_t elements, size_t size)
{
long sz = elements * size;
Malloc_t p = Perl_malloc(sz);
PERL_CALLCONV OP * Perl_ref(pTHX_ OP *o, I32 type);
PERL_CALLCONV void Perl_sv_unref(pTHX_ SV *sv);
PERL_CALLCONV void Perl_sv_taint(pTHX_ SV *sv);
-PERL_CALLCONV IV Perl_sv_2iv(pTHX_ register SV *sv);
-PERL_CALLCONV UV Perl_sv_2uv(pTHX_ register SV *sv);
-PERL_CALLCONV NV Perl_sv_2nv(pTHX_ register SV *sv);
-PERL_CALLCONV char * Perl_sv_2pv(pTHX_ register SV *sv, STRLEN *lp);
-PERL_CALLCONV char * Perl_sv_2pv_nolen(pTHX_ register SV *sv);
-PERL_CALLCONV char * Perl_sv_2pvbyte_nolen(pTHX_ register SV *sv);
-PERL_CALLCONV char * Perl_sv_2pvutf8_nolen(pTHX_ register SV *sv);
-PERL_CALLCONV void Perl_sv_force_normal(pTHX_ register SV *sv);
-PERL_CALLCONV void Perl_sv_setsv(pTHX_ SV *dstr, register SV *sstr);
+PERL_CALLCONV IV Perl_sv_2iv(pTHX_ SV *sv);
+PERL_CALLCONV UV Perl_sv_2uv(pTHX_ SV *sv);
+PERL_CALLCONV NV Perl_sv_2nv(pTHX_ SV *sv);
+PERL_CALLCONV char * Perl_sv_2pv(pTHX_ SV *sv, STRLEN *lp);
+PERL_CALLCONV char * Perl_sv_2pv_nolen(pTHX_ SV *sv);
+PERL_CALLCONV char * Perl_sv_2pvbyte_nolen(pTHX_ SV *sv);
+PERL_CALLCONV char * Perl_sv_2pvutf8_nolen(pTHX_ SV *sv);
+PERL_CALLCONV void Perl_sv_force_normal(pTHX_ SV *sv);
+PERL_CALLCONV void Perl_sv_setsv(pTHX_ SV *dstr, SV *sstr);
PERL_CALLCONV void Perl_sv_catpvn(pTHX_ SV *dsv, const char* sstr, STRLEN slen);
-PERL_CALLCONV void Perl_sv_catpvn_mg(pTHX_ register SV *sv, register const char *ptr, register STRLEN len);
-PERL_CALLCONV void Perl_sv_catsv(pTHX_ SV *dstr, register SV *sstr);
-PERL_CALLCONV void Perl_sv_catsv_mg(pTHX_ SV *dsv, register SV *ssv);
+PERL_CALLCONV void Perl_sv_catpvn_mg(pTHX_ SV *sv, const char *ptr, STRLEN len);
+PERL_CALLCONV void Perl_sv_catsv(pTHX_ SV *dstr, SV *sstr);
+PERL_CALLCONV void Perl_sv_catsv_mg(pTHX_ SV *dsv, SV *ssv);
PERL_CALLCONV char * Perl_sv_pv(pTHX_ SV *sv);
PERL_CALLCONV char * Perl_sv_pvn_force(pTHX_ SV *sv, STRLEN *lp);
PERL_CALLCONV char * Perl_sv_pvbyte(pTHX_ SV *sv);
PERL_CALLCONV char * Perl_sv_pvutf8(pTHX_ SV *sv);
-PERL_CALLCONV STRLEN Perl_sv_utf8_upgrade(pTHX_ register SV *sv);
+PERL_CALLCONV STRLEN Perl_sv_utf8_upgrade(pTHX_ SV *sv);
PERL_CALLCONV NV Perl_huge(void);
PERL_CALLCONV void Perl_gv_fullname3(pTHX_ SV *sv, const GV *gv, const char *prefix);
PERL_CALLCONV void Perl_gv_efullname3(pTHX_ SV *sv, const GV *gv, const char *prefix);
PERL_CALLCONV GV * Perl_gv_fetchmethod(pTHX_ HV *stash, const char *name);
PERL_CALLCONV HE * Perl_hv_iternext(pTHX_ HV *hv);
PERL_CALLCONV void Perl_hv_magic(pTHX_ HV *hv, GV *gv, int how);
-PERL_CALLCONV bool Perl_do_open(pTHX_ GV *gv, register const char *name, I32 len, int as_raw, int rawmode, int rawperm, PerlIO *supplied_fp);
-PERL_CALLCONV bool Perl_do_aexec(pTHX_ SV *really, register SV **mark, register SV **sp);
+PERL_CALLCONV bool Perl_do_open(pTHX_ GV *gv, const char *name, I32 len, int as_raw, int rawmode, int rawperm, PerlIO *supplied_fp);
+PERL_CALLCONV bool Perl_do_aexec(pTHX_ SV *really, SV **mark, SV **sp);
PERL_CALLCONV U8 * Perl_uvuni_to_utf8(pTHX_ U8 *d, UV uv);
PERL_CALLCONV bool Perl_is_utf8_string_loc(pTHX_ const U8 *s, STRLEN len, const U8 **ep);
PERL_CALLCONV void Perl_sv_nolocking(pTHX_ SV *sv);
PERL_CALLCONV IO * Perl_newIO(pTHX);
PERL_CALLCONV I32 Perl_my_stat(pTHX);
PERL_CALLCONV I32 Perl_my_lstat(pTHX);
-PERL_CALLCONV I32 Perl_sv_eq(pTHX_ register SV *sv1, register SV *sv2);
+PERL_CALLCONV I32 Perl_sv_eq(pTHX_ SV *sv1, SV *sv2);
PERL_CALLCONV char * Perl_sv_collxfrm(pTHX_ SV *const sv, STRLEN *const nxp);
-PERL_CALLCONV bool Perl_sv_2bool(pTHX_ register SV *const sv);
+PERL_CALLCONV bool Perl_sv_2bool(pTHX_ SV *const sv);
PERL_CALLCONV CV * Perl_newSUB(pTHX_ I32 floor, OP* o, OP* proto, OP* block);
PERL_CALLCONV UV Perl_to_utf8_lower(pTHX_ const U8 *p, U8* ustrp, STRLEN *lenp);
PERL_CALLCONV UV Perl_to_utf8_title(pTHX_ const U8 *p, U8* ustrp, STRLEN *lenp);
*/
IV
-Perl_sv_2iv(pTHX_ register SV *sv)
+Perl_sv_2iv(pTHX_ SV *sv)
{
return sv_2iv_flags(sv, SV_GMAGIC);
}
*/
UV
-Perl_sv_2uv(pTHX_ register SV *sv)
+Perl_sv_2uv(pTHX_ SV *sv)
{
return sv_2uv_flags(sv, SV_GMAGIC);
}
*/
NV
-Perl_sv_2nv(pTHX_ register SV *sv)
+Perl_sv_2nv(pTHX_ SV *sv)
{
return sv_2nv_flags(sv, SV_GMAGIC);
}
*/
char *
-Perl_sv_2pv(pTHX_ register SV *sv, STRLEN *lp)
+Perl_sv_2pv(pTHX_ SV *sv, STRLEN *lp)
{
return sv_2pv_flags(sv, lp, SV_GMAGIC);
}
*/
char *
-Perl_sv_2pv_nolen(pTHX_ register SV *sv)
+Perl_sv_2pv_nolen(pTHX_ SV *sv)
{
PERL_ARGS_ASSERT_SV_2PV_NOLEN;
return sv_2pv(sv, NULL);
*/
char *
-Perl_sv_2pvbyte_nolen(pTHX_ register SV *sv)
+Perl_sv_2pvbyte_nolen(pTHX_ SV *sv)
{
PERL_ARGS_ASSERT_SV_2PVBYTE_NOLEN;
*/
char *
-Perl_sv_2pvutf8_nolen(pTHX_ register SV *sv)
+Perl_sv_2pvutf8_nolen(pTHX_ SV *sv)
{
PERL_ARGS_ASSERT_SV_2PVUTF8_NOLEN;
*/
void
-Perl_sv_force_normal(pTHX_ register SV *sv)
+Perl_sv_force_normal(pTHX_ SV *sv)
{
PERL_ARGS_ASSERT_SV_FORCE_NORMAL;
*/
void
-Perl_sv_setsv(pTHX_ SV *dstr, register SV *sstr)
+Perl_sv_setsv(pTHX_ SV *dstr, SV *sstr)
{
PERL_ARGS_ASSERT_SV_SETSV;
*/
void
-Perl_sv_catpvn_mg(pTHX_ register SV *sv, register const char *ptr, register STRLEN len)
+Perl_sv_catpvn_mg(pTHX_ SV *sv, const char *ptr, STRLEN len)
{
PERL_ARGS_ASSERT_SV_CATPVN_MG;
*/
void
-Perl_sv_catsv(pTHX_ SV *dstr, register SV *sstr)
+Perl_sv_catsv(pTHX_ SV *dstr, SV *sstr)
{
PERL_ARGS_ASSERT_SV_CATSV;
*/
void
-Perl_sv_catsv_mg(pTHX_ SV *dsv, register SV *ssv)
+Perl_sv_catsv_mg(pTHX_ SV *dsv, SV *ssv)
{
PERL_ARGS_ASSERT_SV_CATSV_MG;
*/
IV
-Perl_sv_iv(pTHX_ register SV *sv)
+Perl_sv_iv(pTHX_ SV *sv)
{
PERL_ARGS_ASSERT_SV_IV;
*/
UV
-Perl_sv_uv(pTHX_ register SV *sv)
+Perl_sv_uv(pTHX_ SV *sv)
{
PERL_ARGS_ASSERT_SV_UV;
*/
NV
-Perl_sv_nv(pTHX_ register SV *sv)
+Perl_sv_nv(pTHX_ SV *sv)
{
PERL_ARGS_ASSERT_SV_NV;
char *
-Perl_sv_pvn_nomg(pTHX_ register SV *sv, STRLEN *lp)
+Perl_sv_pvn_nomg(pTHX_ SV *sv, STRLEN *lp)
{
PERL_ARGS_ASSERT_SV_PVN_NOMG;
*/
STRLEN
-Perl_sv_utf8_upgrade(pTHX_ register SV *sv)
+Perl_sv_utf8_upgrade(pTHX_ SV *sv)
{
PERL_ARGS_ASSERT_SV_UTF8_UPGRADE;
}
bool
-Perl_do_open(pTHX_ GV *gv, register const char *name, I32 len, int as_raw,
+Perl_do_open(pTHX_ GV *gv, const char *name, I32 len, int as_raw,
int rawmode, int rawperm, PerlIO *supplied_fp)
{
PERL_ARGS_ASSERT_DO_OPEN;
}
bool
-Perl_do_open9(pTHX_ GV *gv, register const char *name, I32 len, int
+Perl_do_open9(pTHX_ GV *gv, const char *name, I32 len, int
as_raw,
int rawmode, int rawperm, PerlIO *supplied_fp, SV *svs,
I32 num_svs)
#ifndef OS2
bool
-Perl_do_aexec(pTHX_ SV *really, register SV **mark, register SV **sp)
+Perl_do_aexec(pTHX_ SV *really, SV **mark, SV **sp)
{
PERL_ARGS_ASSERT_DO_AEXEC;
}
void
-Perl_save_list(pTHX_ register SV **sarg, I32 maxsarg)
+Perl_save_list(pTHX_ SV **sarg, I32 maxsarg)
{
dVAR;
I32 i;
*/
void
-Perl_pack_cat(pTHX_ SV *cat, const char *pat, const char *patend, register SV **beglist, SV **endlist, SV ***next_in_list, U32 flags)
+Perl_pack_cat(pTHX_ SV *cat, const char *pat, const char *patend, SV **beglist, SV **endlist, SV ***next_in_list, U32 flags)
{
PERL_ARGS_ASSERT_PACK_CAT;
}
GV *
-Perl_gv_HVadd(pTHX_ register GV *gv)
+Perl_gv_HVadd(pTHX_ GV *gv)
{
return gv_HVadd(gv);
}
GV *
-Perl_gv_IOadd(pTHX_ register GV *gv)
+Perl_gv_IOadd(pTHX_ GV *gv)
{
return gv_IOadd(gv);
}
}
I32
-Perl_sv_eq(pTHX_ register SV *sv1, register SV *sv2)
+Perl_sv_eq(pTHX_ SV *sv1, SV *sv2)
{
return sv_eq_flags(sv1, sv2, SV_GMAGIC);
}
#endif
bool
-Perl_sv_2bool(pTHX_ register SV *const sv)
+Perl_sv_2bool(pTHX_ SV *const sv)
{
return sv_2bool_flags(sv, SV_GMAGIC);
}
}
static OP *
-S_fold_constants(pTHX_ register OP *o)
+S_fold_constants(pTHX_ OP *o)
{
dVAR;
OP * VOL curop;
}
static OP *
-S_gen_constant_list(pTHX_ register OP *o)
+S_gen_constant_list(pTHX_ OP *o)
{
dVAR;
OP *curop;
}
STATIC I32
-S_is_list_assignment(pTHX_ register const OP *o)
+S_is_list_assignment(pTHX_ const OP *o)
{
unsigned type;
U8 flags;
const char *ps;
STRLEN ps_len = 0; /* init it to avoid false uninit warning from icc */
U32 ps_utf8 = 0;
- register CV *cv = NULL;
- register CV *compcv = PL_compcv;
+ CV *cv = NULL;
+ CV *compcv = PL_compcv;
SV *const_sv;
PADNAME *name;
PADOFFSET pax = o->op_targ;
}
OP *
-Perl_ck_rvconst(pTHX_ register OP *o)
+Perl_ck_rvconst(pTHX_ OP *o)
{
dVAR;
SVOP * const kid = (SVOP*)cUNOPo->op_first;
* peep() is called */
void
-Perl_rpeep(pTHX_ register OP *o)
+Perl_rpeep(pTHX_ OP *o)
{
dVAR;
OP* oldop = NULL;
}
void
-Perl_peep(pTHX_ register OP *o)
+Perl_peep(pTHX_ OP *o)
{
CALL_RPEEP(o);
}
/* Array spawn/exec. */
int
-os2_aspawn_4(pTHX_ SV *really, register SV **args, I32 cnt, int execing)
+os2_aspawn_4(pTHX_ SV *really, SV **args, I32 cnt, int execing)
{
SV **argp = (SV **)args;
SV **last = argp + cnt;
/* Array spawn. */
int
-os2_do_aspawn(pTHX_ SV *really, register SV **vmark, register SV **vsp)
+os2_do_aspawn(pTHX_ SV *really, SV **vmark, SV **vsp)
{
return os2_aspawn_4(aTHX_ really, vmark + 1, vsp - vmark, ASPAWN_WAIT);
}
#endif /* USE_ITHREADS */
PAD **
-Perl_padlist_store(pTHX_ register PADLIST *padlist, I32 key, PAD *val)
+Perl_padlist_store(pTHX_ PADLIST *padlist, I32 key, PAD *val)
{
dVAR;
PAD **ary;
*/
I32
-Perl_call_argv(pTHX_ const char *sub_name, I32 flags, register char **argv)
+Perl_call_argv(pTHX_ const char *sub_name, I32 flags, char **argv)
/* See G_* flags in cop.h */
/* null terminated arg list */
}
void
-Perl_init_argv_symbols(pTHX_ register int argc, register char **argv)
+Perl_init_argv_symbols(pTHX_ int argc, char **argv)
{
dVAR;
}
STATIC void
-S_init_postdump_symbols(pTHX_ register int argc, register char **argv, register char **env)
+S_init_postdump_symbols(pTHX_ int argc, char **argv, char **env)
{
dVAR;
GV* tmpgv;
# endif
#endif
-#define pVAR register struct perl_vars* my_vars PERL_UNUSED_DECL
+#define pVAR struct perl_vars* my_vars PERL_UNUSED_DECL
#ifdef PERL_GLOBAL_STRUCT
# define dVAR pVAR = (struct perl_vars*)PERL_GET_VARS()
# define MULTIPLICITY
# endif
# define tTHX PerlInterpreter*
-# define pTHX register tTHX my_perl PERL_UNUSED_DECL
+# define pTHX tTHX my_perl PERL_UNUSED_DECL
# define aTHX my_perl
# define aTHXa(a) aTHX = (tTHX)a
# ifdef PERL_GLOBAL_STRUCT
#endif
#ifndef pTHXx
-# define pTHXx register PerlInterpreter *my_perl
+# define pTHXx PerlInterpreter *my_perl
# define pTHXx_ pTHXx,
# define aTHXx my_perl
# define aTHXx_ aTHXx,
# ifdef __GNUC__
# define stringify_immed(s) #s
# define stringify(s) stringify_immed(s)
-register struct op *Perl_op asm(stringify(OP_IN_REGISTER));
+struct op *Perl_op asm(stringify(OP_IN_REGISTER));
# endif
#endif
I32 call_sv(SV* sv, I32 flags);
I32 call_pv(char *subname, I32 flags);
I32 call_method(char *methname, I32 flags);
- I32 call_argv(char *subname, I32 flags, register char **argv);
+ I32 call_argv(char *subname, I32 flags, char **argv);
The key function is I<call_sv>. All the other functions are
fairly simple wrappers which make it easier to call Perl subroutines in
I32 call_sv(SV*, I32);
I32 call_pv(const char*, I32);
I32 call_method(const char*, I32);
- I32 call_argv(const char*, I32, register char**);
+ I32 call_argv(const char*, I32, char**);
The routine most often used is C<call_sv>. The C<SV*> argument
contains either the name of the Perl subroutine to be called, or a
F<sv.c>
1 void
- 2 Perl_sv_catpvn(pTHX_ register SV *sv, register const char *ptr, register STRLEN len)
+ 2 Perl_sv_catpvn(pTHX_ SV *sv, const char *ptr, STRLEN len)
3 {
4 STRLEN tlen;
5 char *junk;
#define dSP SV **sp = PL_stack_sp
#define djSP dSP
-#define dMARK register SV **mark = PL_stack_base + POPMARK
+#define dMARK SV **mark = PL_stack_base + POPMARK
#define dORIGMARK const I32 origmark = (I32)(mark - PL_stack_base)
#define ORIGMARK (PL_stack_base + origmark)
* returns char pointer to char after match, or NULL
*/
STATIC const char *
-S_group_end(pTHX_ register const char *patptr, register const char *patend, char ender)
+S_group_end(pTHX_ const char *patptr, const char *patend, char ender)
{
PERL_ARGS_ASSERT_GROUP_END;
* Advances char pointer to 1st non-digit char and returns number
*/
STATIC const char *
-S_get_num(pTHX_ register const char *patptr, I32 *lenptr )
+S_get_num(pTHX_ const char *patptr, I32 *lenptr )
{
I32 len = *patptr++ - '0';
*/
void
-Perl_packlist(pTHX_ SV *cat, const char *pat, const char *patend, register SV **beglist, SV **endlist )
+Perl_packlist(pTHX_ SV *cat, const char *pat, const char *patend, SV **beglist, SV **endlist )
{
dVAR;
tempsym_t sym;
#define SORT_NORMAL_RETURN_VALUE(val) (((val) > 0) ? 1 : ((val) ? -1 : 0))
static I32
-S_amagic_ncmp(pTHX_ register SV *const a, register SV *const b)
+S_amagic_ncmp(pTHX_ SV *const a, SV *const b)
{
dVAR;
SV * const tmpsv = tryCALL_AMAGICbin(a,b,ncmp_amg);
}
static I32
-S_amagic_i_ncmp(pTHX_ register SV *const a, register SV *const b)
+S_amagic_i_ncmp(pTHX_ SV *const a, SV *const b)
{
dVAR;
SV * const tmpsv = tryCALL_AMAGICbin(a,b,ncmp_amg);
}
static I32
-S_amagic_cmp(pTHX_ register SV *const str1, register SV *const str2)
+S_amagic_cmp(pTHX_ SV *const str1, SV *const str2)
{
dVAR;
SV * const tmpsv = tryCALL_AMAGICbin(str1,str2,scmp_amg);
}
static I32
-S_amagic_cmp_locale(pTHX_ register SV *const str1, register SV *const str2)
+S_amagic_cmp_locale(pTHX_ SV *const str1, SV *const str2)
{
dVAR;
SV * const tmpsv = tryCALL_AMAGICbin(str1,str2,scmp_amg);
- regnext - dig the "next" pointer out of a node
*/
regnode *
-Perl_regnext(pTHX_ register regnode *p)
+Perl_regnext(pTHX_ regnode *p)
{
dVAR;
I32 offset;
- pregexec - match a regexp against a string
*/
I32
-Perl_pregexec(pTHX_ REGEXP * const prog, char* stringarg, register char *strend,
+Perl_pregexec(pTHX_ REGEXP * const prog, char* stringarg, char *strend,
char *strbeg, I32 minend, SV *screamer, U32 nosave)
/* stringarg: the point in the string at which to begin matching */
/* strend: pointer to null at end of string */
- regexec_flags - match a regexp against a string
*/
I32
-Perl_regexec_flags(pTHX_ REGEXP * const rx, char *stringarg, register char *strend,
+Perl_regexec_flags(pTHX_ REGEXP * const rx, char *stringarg, char *strend,
char *strbeg, I32 minend, SV *sv, void *data, U32 flags)
/* stringarg: the point in the string at which to begin matching */
/* strend: pointer to null at end of string */
{
dVAR;
struct regexp *const prog = ReANY(rx);
- /*register*/ char *s;
+ char *s;
regnode *c;
- /*register*/ char *startpos = stringarg;
+ char *startpos = stringarg;
I32 minlen; /* must match at least this many chars */
I32 dontbother = 0; /* how many characters not to try at end */
I32 end_shift = 0; /* Same for the end. */ /* CC */
If <altsvp> is non-null, will return NULL in it, for back-compat.
*/
SV *
-Perl_regclass_swash(pTHX_ const regexp *prog, register const regnode* node, bool doinit, SV** listsvp, SV **altsvp)
+Perl_regclass_swash(pTHX_ const regexp *prog, const regnode* node, bool doinit, SV** listsvp, SV **altsvp)
{
PERL_ARGS_ASSERT_REGCLASS_SWASH;
#endif
STATIC SV *
-S_core_regclass_swash(pTHX_ const regexp *prog, register const regnode* node, bool doinit, SV** listsvp)
+S_core_regclass_swash(pTHX_ const regexp *prog, const regnode* node, bool doinit, SV** listsvp)
{
/* Returns the swash for the input 'node' in the regex 'prog'.
* If <doinit> is true, will attempt to create the swash if not already
*/
STATIC bool
-S_reginclass(pTHX_ const regexp * const prog, register const regnode * const n, register const U8* const p, register const bool utf8_target)
+S_reginclass(pTHX_ const regexp * const prog, const regnode * const n, const U8* const p, const bool utf8_target)
{
dVAR;
const char flags = ANYOF_FLAGS(n);
}
STATIC void
-S_to_utf8_substr(pTHX_ register regexp *prog)
+S_to_utf8_substr(pTHX_ regexp *prog)
{
/* Converts substr fields in prog from bytes to UTF-8, calling fbm_compile
* on the converted value */
}
STATIC bool
-S_to_byte_substr(pTHX_ register regexp *prog)
+S_to_byte_substr(pTHX_ regexp *prog)
{
/* Converts substr fields in prog from UTF-8 to bytes, calling fbm_compile
* on the converted value; returns FALSE if can't be converted. */
}
void
-Perl_save_item(pTHX_ register SV *item)
+Perl_save_item(pTHX_ SV *item)
{
dVAR;
SV * const sv = newSVsv(item);
*/
void
-Perl_sv_upgrade(pTHX_ register SV *const sv, svtype new_type)
+Perl_sv_upgrade(pTHX_ SV *const sv, svtype new_type)
{
dVAR;
void* old_body;
*/
int
-Perl_sv_backoff(pTHX_ register SV *const sv)
+Perl_sv_backoff(pTHX_ SV *const sv)
{
STRLEN delta;
const char * const s = SvPVX_const(sv);
*/
char *
-Perl_sv_grow(pTHX_ register SV *const sv, register STRLEN newlen)
+Perl_sv_grow(pTHX_ SV *const sv, STRLEN newlen)
{
char *s;
*/
void
-Perl_sv_setiv(pTHX_ register SV *const sv, const IV i)
+Perl_sv_setiv(pTHX_ SV *const sv, const IV i)
{
dVAR;
*/
void
-Perl_sv_setiv_mg(pTHX_ register SV *const sv, const IV i)
+Perl_sv_setiv_mg(pTHX_ SV *const sv, const IV i)
{
PERL_ARGS_ASSERT_SV_SETIV_MG;
*/
void
-Perl_sv_setuv(pTHX_ register SV *const sv, const UV u)
+Perl_sv_setuv(pTHX_ SV *const sv, const UV u)
{
PERL_ARGS_ASSERT_SV_SETUV;
*/
void
-Perl_sv_setuv_mg(pTHX_ register SV *const sv, const UV u)
+Perl_sv_setuv_mg(pTHX_ SV *const sv, const UV u)
{
PERL_ARGS_ASSERT_SV_SETUV_MG;
*/
void
-Perl_sv_setnv(pTHX_ register SV *const sv, const NV num)
+Perl_sv_setnv(pTHX_ SV *const sv, const NV num)
{
dVAR;
*/
void
-Perl_sv_setnv_mg(pTHX_ register SV *const sv, const NV num)
+Perl_sv_setnv_mg(pTHX_ SV *const sv, const NV num)
{
PERL_ARGS_ASSERT_SV_SETNV_MG;
/* For sv_2nv these three cases are "SvNOK and don't bother casting" */
STATIC int
-S_sv_2iuv_non_preserve(pTHX_ register SV *const sv
+S_sv_2iuv_non_preserve(pTHX_ SV *const sv
# ifdef DEBUGGING
, I32 numtype
# endif
*/
IV
-Perl_sv_2iv_flags(pTHX_ register SV *const sv, const I32 flags)
+Perl_sv_2iv_flags(pTHX_ SV *const sv, const I32 flags)
{
dVAR;
*/
UV
-Perl_sv_2uv_flags(pTHX_ register SV *const sv, const I32 flags)
+Perl_sv_2uv_flags(pTHX_ SV *const sv, const I32 flags)
{
dVAR;
*/
NV
-Perl_sv_2nv_flags(pTHX_ register SV *const sv, const I32 flags)
+Perl_sv_2nv_flags(pTHX_ SV *const sv, const I32 flags)
{
dVAR;
if (!sv)
*/
SV *
-Perl_sv_2num(pTHX_ register SV *const sv)
+Perl_sv_2num(pTHX_ SV *const sv)
{
PERL_ARGS_ASSERT_SV_2NUM;
*/
char *
-Perl_sv_2pv_flags(pTHX_ register SV *const sv, STRLEN *const lp, const I32 flags)
+Perl_sv_2pv_flags(pTHX_ SV *const sv, STRLEN *const lp, const I32 flags)
{
dVAR;
char *s;
*/
void
-Perl_sv_copypv(pTHX_ SV *const dsv, register SV *const ssv)
+Perl_sv_copypv(pTHX_ SV *const dsv, SV *const ssv)
{
PERL_ARGS_ASSERT_SV_COPYPV;
}
void
-Perl_sv_copypv_flags(pTHX_ SV *const dsv, register SV *const ssv, const I32 flags)
+Perl_sv_copypv_flags(pTHX_ SV *const dsv, SV *const ssv, const I32 flags)
{
STRLEN len;
const char *s;
*/
char *
-Perl_sv_2pvbyte(pTHX_ register SV *sv, STRLEN *const lp)
+Perl_sv_2pvbyte(pTHX_ SV *sv, STRLEN *const lp)
{
PERL_ARGS_ASSERT_SV_2PVBYTE;
*/
char *
-Perl_sv_2pvutf8(pTHX_ register SV *sv, STRLEN *const lp)
+Perl_sv_2pvutf8(pTHX_ SV *sv, STRLEN *const lp)
{
PERL_ARGS_ASSERT_SV_2PVUTF8;
*/
bool
-Perl_sv_2bool_flags(pTHX_ register SV *const sv, const I32 flags)
+Perl_sv_2bool_flags(pTHX_ SV *const sv, const I32 flags)
{
dVAR;
*/
STRLEN
-Perl_sv_utf8_upgrade_flags_grow(pTHX_ register SV *const sv, const I32 flags, STRLEN extra)
+Perl_sv_utf8_upgrade_flags_grow(pTHX_ SV *const sv, const I32 flags, STRLEN extra)
{
dVAR;
*/
bool
-Perl_sv_utf8_downgrade(pTHX_ register SV *const sv, const bool fail_ok)
+Perl_sv_utf8_downgrade(pTHX_ SV *const sv, const bool fail_ok)
{
dVAR;
*/
void
-Perl_sv_utf8_encode(pTHX_ register SV *const sv)
+Perl_sv_utf8_encode(pTHX_ SV *const sv)
{
PERL_ARGS_ASSERT_SV_UTF8_ENCODE;
*/
bool
-Perl_sv_utf8_decode(pTHX_ register SV *const sv)
+Perl_sv_utf8_decode(pTHX_ SV *const sv)
{
PERL_ARGS_ASSERT_SV_UTF8_DECODE;
}
void
-Perl_sv_setsv_flags(pTHX_ SV *dstr, register SV* sstr, const I32 flags)
+Perl_sv_setsv_flags(pTHX_ SV *dstr, SV* sstr, const I32 flags)
{
dVAR;
U32 sflags;
*/
void
-Perl_sv_setsv_mg(pTHX_ SV *const dstr, register SV *const sstr)
+Perl_sv_setsv_mg(pTHX_ SV *const dstr, SV *const sstr)
{
PERL_ARGS_ASSERT_SV_SETSV_MG;
*/
void
-Perl_sv_setpvn(pTHX_ register SV *const sv, register const char *const ptr, register const STRLEN len)
+Perl_sv_setpvn(pTHX_ SV *const sv, const char *const ptr, const STRLEN len)
{
dVAR;
char *dptr;
*/
void
-Perl_sv_setpvn_mg(pTHX_ register SV *const sv, register const char *const ptr, register const STRLEN len)
+Perl_sv_setpvn_mg(pTHX_ SV *const sv, const char *const ptr, const STRLEN len)
{
PERL_ARGS_ASSERT_SV_SETPVN_MG;
*/
void
-Perl_sv_setpv(pTHX_ register SV *const sv, register const char *const ptr)
+Perl_sv_setpv(pTHX_ SV *const sv, const char *const ptr)
{
dVAR;
STRLEN len;
*/
void
-Perl_sv_setpv_mg(pTHX_ register SV *const sv, register const char *const ptr)
+Perl_sv_setpv_mg(pTHX_ SV *const sv, const char *const ptr)
{
PERL_ARGS_ASSERT_SV_SETPV_MG;
}
void
-Perl_sv_sethek(pTHX_ register SV *const sv, const HEK *const hek)
+Perl_sv_sethek(pTHX_ SV *const sv, const HEK *const hek)
{
dVAR;
(which it can do by means other than releasing copy-on-write Svs)
or by changing the other copy-on-write SVs in the loop. */
STATIC void
-S_sv_release_COW(pTHX_ register SV *sv, const char *pvx, SV *after)
+S_sv_release_COW(pTHX_ SV *sv, const char *pvx, SV *after)
{
PERL_ARGS_ASSERT_SV_RELEASE_COW;
*/
void
-Perl_sv_force_normal_flags(pTHX_ register SV *const sv, const U32 flags)
+Perl_sv_force_normal_flags(pTHX_ SV *const sv, const U32 flags)
{
dVAR;
*/
void
-Perl_sv_chop(pTHX_ register SV *const sv, register const char *const ptr)
+Perl_sv_chop(pTHX_ SV *const sv, const char *const ptr)
{
STRLEN delta;
STRLEN old_delta;
*/
void
-Perl_sv_catpvn_flags(pTHX_ register SV *const dsv, register const char *sstr, register const STRLEN slen, const I32 flags)
+Perl_sv_catpvn_flags(pTHX_ SV *const dsv, const char *sstr, const STRLEN slen, const I32 flags)
{
dVAR;
STRLEN dlen;
=cut */
void
-Perl_sv_catsv_flags(pTHX_ SV *const dsv, register SV *const ssv, const I32 flags)
+Perl_sv_catsv_flags(pTHX_ SV *const dsv, SV *const ssv, const I32 flags)
{
dVAR;
=cut */
void
-Perl_sv_catpv(pTHX_ register SV *const sv, register const char *ptr)
+Perl_sv_catpv(pTHX_ SV *const sv, const char *ptr)
{
dVAR;
STRLEN len;
*/
void
-Perl_sv_catpv_mg(pTHX_ register SV *const sv, register const char *const ptr)
+Perl_sv_catpv_mg(pTHX_ SV *const sv, const char *const ptr)
{
PERL_ARGS_ASSERT_SV_CATPV_MG;
*/
void
-Perl_sv_magic(pTHX_ register SV *const sv, SV *const obj, const int how,
+Perl_sv_magic(pTHX_ SV *const sv, SV *const obj, const int how,
const char *const name, const I32 namlen)
{
dVAR;
*/
void
-Perl_sv_replace(pTHX_ register SV *const sv, register SV *const nsv)
+Perl_sv_replace(pTHX_ SV *const sv, SV *const nsv)
{
dVAR;
const U32 refcnt = SvREFCNT(sv);
*/
STRLEN
-Perl_sv_len(pTHX_ register SV *const sv)
+Perl_sv_len(pTHX_ SV *const sv)
{
STRLEN len;
*/
STRLEN
-Perl_sv_len_utf8(pTHX_ register SV *const sv)
+Perl_sv_len_utf8(pTHX_ SV *const sv)
{
if (!sv)
return 0;
/* This function is subject to size and sign problems */
void
-Perl_sv_pos_u2b(pTHX_ register SV *const sv, I32 *const offsetp, I32 *const lenp)
+Perl_sv_pos_u2b(pTHX_ SV *const sv, I32 *const offsetp, I32 *const lenp)
{
PERL_ARGS_ASSERT_SV_POS_U2B;
*
*/
void
-Perl_sv_pos_b2u(pTHX_ register SV *const sv, I32 *const offsetp)
+Perl_sv_pos_b2u(pTHX_ SV *const sv, I32 *const offsetp)
{
const U8* s;
const STRLEN byte = *offsetp;
*/
I32
-Perl_sv_eq_flags(pTHX_ register SV *sv1, register SV *sv2, const U32 flags)
+Perl_sv_eq_flags(pTHX_ SV *sv1, SV *sv2, const U32 flags)
{
dVAR;
const char *pv1;
*/
I32
-Perl_sv_cmp(pTHX_ register SV *const sv1, register SV *const sv2)
+Perl_sv_cmp(pTHX_ SV *const sv1, SV *const sv2)
{
return sv_cmp_flags(sv1, sv2, SV_GMAGIC);
}
I32
-Perl_sv_cmp_flags(pTHX_ register SV *const sv1, register SV *const sv2,
+Perl_sv_cmp_flags(pTHX_ SV *const sv1, SV *const sv2,
const U32 flags)
{
dVAR;
*/
I32
-Perl_sv_cmp_locale(pTHX_ register SV *const sv1, register SV *const sv2)
+Perl_sv_cmp_locale(pTHX_ SV *const sv1, SV *const sv2)
{
return sv_cmp_locale_flags(sv1, sv2, SV_GMAGIC);
}
I32
-Perl_sv_cmp_locale_flags(pTHX_ register SV *const sv1, register SV *const sv2,
+Perl_sv_cmp_locale_flags(pTHX_ SV *const sv1, SV *const sv2,
const U32 flags)
{
dVAR;
*/
char *
-Perl_sv_gets(pTHX_ register SV *const sv, register PerlIO *const fp, I32 append)
+Perl_sv_gets(pTHX_ SV *const sv, PerlIO *const fp, I32 append)
{
dVAR;
const char *rsptr;
*/
void
-Perl_sv_inc(pTHX_ register SV *const sv)
+Perl_sv_inc(pTHX_ SV *const sv)
{
if (!sv)
return;
*/
void
-Perl_sv_inc_nomg(pTHX_ register SV *const sv)
+Perl_sv_inc_nomg(pTHX_ SV *const sv)
{
dVAR;
char *d;
*/
void
-Perl_sv_dec(pTHX_ register SV *const sv)
+Perl_sv_dec(pTHX_ SV *const sv)
{
dVAR;
if (!sv)
*/
void
-Perl_sv_dec_nomg(pTHX_ register SV *const sv)
+Perl_sv_dec_nomg(pTHX_ SV *const sv)
{
dVAR;
int flags;
*/
SV *
-Perl_sv_2mortal(pTHX_ register SV *const sv)
+Perl_sv_2mortal(pTHX_ SV *const sv)
{
dVAR;
if (!sv)
*/
SV *
-Perl_newSVsv(pTHX_ register SV *const old)
+Perl_newSVsv(pTHX_ SV *const old)
{
dVAR;
SV *sv;
*/
void
-Perl_sv_reset(pTHX_ register const char *s, HV *const stash)
+Perl_sv_reset(pTHX_ const char *s, HV *const stash)
{
PERL_ARGS_ASSERT_SV_RESET;
*/
I32
-Perl_sv_true(pTHX_ register SV *const sv)
+Perl_sv_true(pTHX_ SV *const sv)
{
if (!sv)
return 0;
*/
SV *
-Perl_sv_ref(pTHX_ register SV *dst, const SV *const sv, const int ob)
+Perl_sv_ref(pTHX_ SV *dst, const SV *const sv, const int ob)
{
PERL_ARGS_ASSERT_SV_REF;
-# This file is the data file for t/porting/podcheck.t.
+# This file is the data file for porting/podcheck.t.
# There are three types of lines.
# Comment lines are white-space only or begin with a '#', like this one. Any
# changes you make to the comment lines will be lost when the file is
pod/perlhurd.pod Verbatim line length including indents exceeds 79 by 2
pod/perlintern.pod ? Should you be using L<...> instead of 5
pod/perlinterp.pod ? Should you be using L<...> instead of 1
-pod/perlinterp.pod Verbatim line length including indents exceeds 79 by 1
pod/perlintro.pod Verbatim line length including indents exceeds 79 by 11
pod/perliol.pod Verbatim line length including indents exceeds 79 by 8
pod/perlipc.pod Apparent broken link 1
/* skip space before PL_thistoken */
STATIC char *
-S_skipspace0(pTHX_ register char *s)
+S_skipspace0(pTHX_ char *s)
{
PERL_ARGS_ASSERT_SKIPSPACE0;
/* skip space after PL_thistoken */
STATIC char *
-S_skipspace1(pTHX_ register char *s)
+S_skipspace1(pTHX_ char *s)
{
const char *start = s;
I32 startoff = start - SvPVX(PL_linestr);
}
STATIC char *
-S_skipspace2(pTHX_ register char *s, SV **svp)
+S_skipspace2(pTHX_ char *s, SV **svp)
{
char *start;
const I32 bufptroff = PL_bufptr - SvPVX(PL_linestr);
*/
STATIC char *
-S_skipspace(pTHX_ register char *s)
+S_skipspace(pTHX_ char *s)
{
#ifdef PERL_MAD
char *start = s;
*/
STATIC char *
-S_force_word(pTHX_ register char *start, int token, int check_keyword, int allow_pack, int allow_initial_tick)
+S_force_word(pTHX_ char *start, int token, int check_keyword, int allow_pack, int allow_initial_tick)
{
dVAR;
char *s;
*/
STATIC void
-S_force_ident(pTHX_ register const char *s, int kind)
+S_force_ident(pTHX_ const char *s, int kind)
{
dVAR;
/* This is the one truly awful dwimmer necessary to conflate C and sed. */
STATIC int
-S_intuit_more(pTHX_ register char *s)
+S_intuit_more(pTHX_ char *s)
{
dVAR;
}
STATIC char *
-S_filter_gets(pTHX_ register SV *sv, STRLEN append)
+S_filter_gets(pTHX_ SV *sv, STRLEN append)
{
dVAR;
*slp
*/
STATIC char *
-S_scan_word(pTHX_ register char *s, char *dest, STRLEN destlen, int allow_package, STRLEN *slp)
+S_scan_word(pTHX_ char *s, char *dest, STRLEN destlen, int allow_package, STRLEN *slp)
{
dVAR;
char *d = dest;
}
STATIC char *
-S_scan_ident(pTHX_ register char *s, register const char *send, char *dest, STRLEN destlen, I32 ck_uni)
+S_scan_ident(pTHX_ char *s, const char *send, char *dest, STRLEN destlen, I32 ck_uni)
{
dVAR;
char *bracket = NULL;
*/
STATIC char *
-S_scan_heredoc(pTHX_ register char *s)
+S_scan_heredoc(pTHX_ char *s)
{
dVAR;
I32 op_type = OP_SCALAR;
}
STATIC char *
-S_scan_formline(pTHX_ register char *s)
+S_scan_formline(pTHX_ char *s)
{
dVAR;
char *eol;
}
bool
-Perl_check_utf8_print(pTHX_ register const U8* s, const STRLEN len)
+Perl_check_utf8_print(pTHX_ const U8* s, const STRLEN len)
{
/* May change: warns if surrogates, non-character code points, or
* non-Unicode code points are in s which has length len bytes. Returns
* FOLDEQ_S2_ALREADY_FOLDED Similarly.
*/
I32
-Perl_foldEQ_utf8_flags(pTHX_ const char *s1, char **pe1, register UV l1, bool u1, const char *s2, char **pe2, register UV l2, bool u2, U32 flags)
+Perl_foldEQ_utf8_flags(pTHX_ const char *s1, char **pe1, UV l1, bool u1, const char *s2, char **pe2, UV l2, bool u2, U32 flags)
{
dVAR;
const U8 *p1 = (const U8*)s1; /* Point to current char */
/* copy a string up to some (non-backslashed) delimiter, if any */
char *
-Perl_delimcpy(register char *to, register const char *toend, register const char *from, register const char *fromend, register int delim, I32 *retlen)
+Perl_delimcpy(char *to, const char *toend, const char *from, const char *fromend, int delim, I32 *retlen)
{
I32 tolen;
/* This routine was donated by Corey Satten. */
char *
-Perl_instr(register const char *big, register const char *little)
+Perl_instr(const char *big, const char *little)
{
I32 first;
/* reverse of the above--find last substring */
char *
-Perl_rninstr(register const char *big, const char *bigend, const char *little, const char *lend)
+Perl_rninstr(const char *big, const char *bigend, const char *little, const char *lend)
{
const char *bigbeg;
const I32 first = *little;
*/
char *
-Perl_fbm_instr(pTHX_ unsigned char *big, register unsigned char *bigend, SV *littlestr, U32 flags)
+Perl_fbm_instr(pTHX_ unsigned char *big, unsigned char *bigend, SV *littlestr, U32 flags)
{
unsigned char *s;
STRLEN l;
I32
-Perl_foldEQ(const char *s1, const char *s2, register I32 len)
+Perl_foldEQ(const char *s1, const char *s2, I32 len)
{
const U8 *a = (const U8 *)s1;
const U8 *b = (const U8 *)s2;
return 1;
}
I32
-Perl_foldEQ_latin1(const char *s1, const char *s2, register I32 len)
+Perl_foldEQ_latin1(const char *s1, const char *s2, I32 len)
{
/* Compare non-utf8 using Unicode (Latin1) semantics. Does not work on
* MICRO_SIGN, LATIN_SMALL_LETTER_SHARP_S, nor
*/
I32
-Perl_foldEQ_locale(const char *s1, const char *s2, register I32 len)
+Perl_foldEQ_locale(const char *s1, const char *s2, I32 len)
{
dVAR;
const U8 *a = (const U8 *)s1;
*/
char *
-Perl_savepvn(pTHX_ const char *pv, register I32 len)
+Perl_savepvn(pTHX_ const char *pv, I32 len)
{
char *newaddr;
PERL_UNUSED_CONTEXT;
/* this is a drop-in replacement for bcopy() */
#if (!defined(HAS_MEMCPY) && !defined(HAS_BCOPY)) || (!defined(HAS_MEMMOVE) && !defined(HAS_SAFE_MEMCPY) && !defined(HAS_SAFE_BCOPY))
char *
-Perl_my_bcopy(register const char *from,register char *to,register I32 len)
+Perl_my_bcopy(const char *from, char *to, I32 len)
{
char * const retval = to;
/* this is a drop-in replacement for memset() */
#ifndef HAS_MEMSET
void *
-Perl_my_memset(register char *loc, register I32 ch, register I32 len)
+Perl_my_memset(char *loc, I32 ch, I32 len)
{
char * const retval = loc;
/* this is a drop-in replacement for bzero() */
#if !defined(HAS_BZERO) && !defined(HAS_MEMSET)
char *
-Perl_my_bzero(register char *loc, register I32 len)
+Perl_my_bzero(char *loc, I32 len)
{
char * const retval = loc;
/* this is a drop-in replacement for memcmp() */
#if !defined(HAS_MEMCMP) || !defined(HAS_SANE_MEMCMP)
I32
-Perl_my_memcmp(const char *s1, const char *s2, register I32 len)
+Perl_my_memcmp(const char *s1, const char *s2, I32 len)
{
const U8 *a = (const U8 *)s1;
const U8 *b = (const U8 *)s2;
#define HTOLE(name,type) \
type \
- name (register type n) \
+ name (type n) \
{ \
union { \
type value; \
char c[sizeof(type)]; \
} u; \
- U32 i; \
- U32 s = 0; \
+ U32 i; \
+ U32 s = 0; \
for (i = 0; i < sizeof(u.c); i++, s += 8) { \
u.c[i] = (n >> s) & 0xFF; \
} \
#define LETOH(name,type) \
type \
- name (register type n) \
+ name (type n) \
{ \
union { \
type value; \
char c[sizeof(type)]; \
} u; \
- U32 i; \
- U32 s = 0; \
+ U32 i; \
+ U32 s = 0; \
u.value = n; \
n = 0; \
for (i = 0; i < sizeof(u.c); i++, s += 8) { \
#define HTOBE(name,type) \
type \
- name (register type n) \
+ name (type n) \
{ \
union { \
type value; \
char c[sizeof(type)]; \
} u; \
- U32 i; \
- U32 s = 8*(sizeof(u.c)-1); \
+ U32 i; \
+ U32 s = 8*(sizeof(u.c)-1); \
for (i = 0; i < sizeof(u.c); i++, s -= 8) { \
u.c[i] = (n >> s) & 0xFF; \
} \
#define BETOH(name,type) \
type \
- name (register type n) \
+ name (type n) \
{ \
union { \
type value; \
char c[sizeof(type)]; \
} u; \
- U32 i; \
- U32 s = 8*(sizeof(u.c)-1); \
+ U32 i; \
+ U32 s = 8*(sizeof(u.c)-1); \
u.value = n; \
n = 0; \
for (i = 0; i < sizeof(u.c); i++, s -= 8) { \
#define NOT_AVAIL(name,type) \
type \
- name (register type n) \
+ name (type n) \
{ \
Perl_croak_nocontext(#name "() not available"); \
return n; /* not reached */ \
#define PERL_REPEATCPY_LINEAR 4
void
-Perl_repeatcpy(register char *to, register const char *from, I32 len, register IV count)
+Perl_repeatcpy(char *to, const char *from, I32 len, IV count)
{
PERL_ARGS_ASSERT_REPEATCPY;
* back into. */
int
-Perl_getcwd_sv(pTHX_ register SV *sv)
+Perl_getcwd_sv(pTHX_ SV *sv)
{
#ifndef PERL_MICRO
dVAR;
#define PERL__TRNENV_JOIN_SEARCHLIST 0x02
/* Handy way to vet calls to VMS system services and RTL routines. */
-#define _ckvmssts(call) STMT_START { register unsigned long int __ckvms_sts; \
+#define _ckvmssts(call) STMT_START { unsigned long int __ckvms_sts; \
if (!((__ckvms_sts=(call))&1)) { \
set_errno(EVMSERR); set_vaxc_errno(__ckvms_sts); \
Perl_croak(aTHX_ "Fatal VMS error (status=%d) at %s, line %d", \
/* Same thing, but don't call back to Perl's croak(); useful for errors
* occurring during startup, before Perl's state is initialized */
-#define _ckvmssts_noperl(call) STMT_START { register unsigned long int __ckvms_sts; \
+#define _ckvmssts_noperl(call) STMT_START { unsigned long int __ckvms_sts; \
if (!((__ckvms_sts=(call))&1)) { \
set_errno(EVMSERR); set_vaxc_errno(__ckvms_sts); \
fprintf(stderr,"Fatal VMS error (status=%d) at %s, line %d", \
int oper3(int type, int arg1, int arg2, int arg3);
int oper4(int type, int arg1, int arg2, int arg3, int arg4);
int oper5(int type, int arg1, int arg2, int arg3, int arg4, int arg5);
-STR *walk(int useval, int level, register int node, int *numericptr, int minprec);
+STR *walk(int useval, int level, int node, int *numericptr, int minprec);
#ifdef NETWARE
char *savestr(char *str);
-char *cpy2(register char *to, register char *from, register int delim);
+char *cpy2(char *to, char *from, int delim);
#endif
#if defined(OS2) || defined(WIN32) || defined(NETWARE)
#endif
int
-main(register int argc, register const char **argv, register const char **env)
+main(int argc, const char **argv, const char **env)
{
STR *str;
int i;
}
char *
-scanpat(register char *s)
+scanpat(char *s)
{
char *d;
}
char *
-scannum(register char *s)
+scannum(char *s)
{
char *d;
#endif
STR *
-hfetch(register HASH *tb, char *key)
+hfetch(HASH *tb, char *key)
{
char *s;
int i;
}
bool
-hstore(register HASH *tb, char *key, STR *val)
+hstore(HASH *tb, char *key, STR *val)
{
char *s;
int i;
}
int
-hiterinit(register HASH *tb)
+hiterinit(HASH *tb)
{
tb->tbl_riter = -1;
tb->tbl_eiter = (HENT*)NULL;
#include "util.h"
void
-str_numset(register STR *str, double num)
+str_numset(STR *str, double num)
{
str->str_nval = num;
str->str_pok = 0; /* invalidate pointer */
}
char *
-str_2ptr(register STR *str)
+str_2ptr(STR *str)
{
char *s;
}
void
-str_sset(STR *dstr, register STR *sstr)
+str_sset(STR *dstr, STR *sstr)
{
if (!sstr)
str_nset(dstr,No,0);
}
void
-str_nset(register STR *str, register const char *ptr, register int len)
+str_nset(STR *str, const char *ptr, int len)
{
GROWSTR(&(str->str_ptr), &(str->str_len), len + 1);
memcpy(str->str_ptr,ptr,len);
}
void
-str_set(register STR *str, register const char *ptr)
+str_set(STR *str, const char *ptr)
{
int len;
}
void
-str_ncat(register STR *str, register const char *ptr, register int len)
+str_ncat(STR *str, const char *ptr, int len)
{
if (!(str->str_pok))
str_2ptr(str);
}
void
-str_scat(STR *dstr, register STR *sstr)
+str_scat(STR *dstr, STR *sstr)
{
if (!(sstr->str_pok))
str_2ptr(sstr);
}
void
-str_cat(register STR *str, register const char *ptr)
+str_cat(STR *str, const char *ptr)
{
int len;
/* make str point to what nstr did */
void
-str_free(register STR *str)
+str_free(STR *str)
{
if (!str)
return;
}
int
-str_len(register STR *str)
+str_len(STR *str)
{
if (!str)
return 0;
}
char *
-str_gets(register STR *str, register FILE *fp)
+str_gets(STR *str, FILE *fp)
{
#if defined(USE_STDIO_PTR) && defined(STDIO_PTR_LVALUE) && defined(STDIO_CNT_LVALUE)
/* Here is some breathtakingly efficient cheating */
/* copy a string up to some (non-backslashed) delimiter, if any */
char *
-cpytill(register char *to, register char *from, register int delim)
+cpytill(char *to, char *from, int delim)
{
for (; *from; from++,to++) {
if (*from == '\\') {
char *
-cpy2(register char *to, register char *from, register int delim)
+cpy2(char *to, char *from, int delim)
{
for (; *from; from++,to++) {
if (*from == '\\')
STR * walk ( int useval, int level, int node, int *numericptr, int minprec );
#ifdef NETWARE
char *savestr(char *str);
-char *cpytill(register char *to, register char *from, register int delim);
+char *cpytill(char *to, char *from, int delim);
char *instr(char *big, const char *little);
#endif
STR *
-walk(int useval, int level, register int node, int *numericptr, int minprec)
+walk(int useval, int level, int node, int *numericptr, int minprec)
{
int len;
STR *str;
}
static void
-tab(register STR *str, register int lvl)
+tab(STR *str, int lvl)
{
while (lvl > 1) {
str_cat(str,"\t");
}
static void
-fixtab(register STR *str, register int lvl)
+fixtab(STR *str, int lvl)
{
char *s;
}
static void
-addsemi(register STR *str)
+addsemi(STR *str)
{
char *s;
}
static void
-emit_split(register STR *str, int level)
+emit_split(STR *str, int level)
{
int i;
}
int
-prewalk(int numit, int level, register int node, int *numericptr)
+prewalk(int numit, int level, int node, int *numericptr)
{
int len;
int type;
}
static void
-numericize(register int node)
+numericize(int node)
{
int len;
int type;
projects / platform / upstream / perl.git / commitdiff