{
/* Stream on which to print the dependency information. */
FILE *deps_stream = 0;
- const char *deps_mode = deps_append ? "a" : "w";
+ const char *const deps_mode = deps_append ? "a" : "w";
if (deps_file == 0)
deps_stream = stdout;
newline_fix (bp)
U_CHAR *bp;
{
- register U_CHAR *p = bp;
- register int count = 0;
+ U_CHAR *p = bp;
+ int count = 0;
/* First count the backslash-newline pairs here. */
name_newline_fix (bp)
U_CHAR *bp;
{
- register U_CHAR *p = bp;
- register int count = 0;
+ U_CHAR *p = bp;
+ int count = 0;
/* First count the backslash-newline pairs here. */
int output_marks;
{
/* Character being scanned in main loop. */
- register U_CHAR c;
+ U_CHAR c;
/* Length of pending accumulated identifier. */
- register int ident_length = 0;
+ int ident_length = 0;
/* Hash code of pending accumulated identifier. */
- register int hash = 0;
+ int hash = 0;
/* Current input level (&instack[indepth]). */
FILE_BUF *ip;
/* Pointer for scanning input. */
- register U_CHAR *ibp;
+ U_CHAR *ibp;
/* Pointer to end of input. End of scan is controlled by LIMIT. */
- register U_CHAR *limit;
+ U_CHAR *limit;
/* Pointer for storing output. */
- register U_CHAR *obp;
+ U_CHAR *obp;
/* REDO_CHAR is nonzero if we are processing an identifier
after backing up over the terminating character.
randomchar:
if (ident_length > 0) {
- register HASHNODE *hp;
+ HASHNODE *hp;
/* We have just seen an identifier end. If it's a macro, expand it.
/* obufp_before_macroname is used only in this block,
but it has to be global because of RECACHE. */
int op_lineno_before_macroname;
- register int i = ident_length;
- register U_CHAR *p = hp->name;
- register U_CHAR *q = obp - i;
+ int i = ident_length;
+ U_CHAR *p = hp->name;
+ U_CHAR *q = obp - i;
if (! redo_char)
q--;
const U_CHAR *buf, *limit;
int output_marks;
{
- register FILE_BUF *ip;
+ FILE_BUF *ip;
FILE_BUF obuf;
int length = limit - buf;
U_CHAR *buf1;
buf1 = (U_CHAR *) alloca (length + 1);
{
- register const U_CHAR *p1 = buf;
- register U_CHAR *p2 = buf1;
+ const U_CHAR *p1 = buf;
+ U_CHAR *p2 = buf1;
while (p1 != limit)
*p2++ = *p1++;
handle_directive (ip, op)
FILE_BUF *ip, *op;
{
- register U_CHAR *bp, *cp;
- register struct directive *kt;
- register int ident_length;
+ U_CHAR *bp, *cp;
+ struct directive *kt;
+ int ident_length;
U_CHAR *resume_p;
/* Nonzero means we must copy the entire command
for (kt = directive_table; kt->length > 0; kt++) {
if (kt->length == ident_length
&& !strncmp (kt->name, (const char *)ident, ident_length)) {
- register U_CHAR *buf;
- register U_CHAR *limit = ip->buf + ip->length;
+ U_CHAR *buf;
+ U_CHAR *limit = ip->buf + ip->length;
int unterminated = 0;
/* Nonzero means do not delete comments within the directive.
buf = bp = after_ident;
while (bp < limit) {
- register U_CHAR c = *bp++;
+ U_CHAR c = *bp++;
switch (c) {
case '\\':
if (bp < limit) {
A comment may come between. */
if (copy_command) {
- register U_CHAR *xp = buf;
+ U_CHAR *xp = buf;
/* Need to copy entire command into temp buffer before dispatching */
cp = (U_CHAR *) alloca (bp - buf + 5); /* room for cmd plus
and backslash-newlines (and whitespace surrounding the latter). */
while (xp < bp) {
- register U_CHAR c = *xp++;
+ U_CHAR c = *xp++;
*cp++ = c;
switch (c) {
while (cp != buf && is_space(cp[-1])) cp--;
cp++;
SKIP_WHITE_SPACE (xp);
- } else if (is_space (*xp)) {
+ } else if (is_nvspace (*xp)) {
*cp++ = *xp++;
SKIP_WHITE_SPACE (xp);
}
case '\'':
case '\"':
{
- register const U_CHAR *bp1
+ const U_CHAR *bp1
= skip_quoted_string (xp - 1, limit, ip->lineno, 0, 0, 0);
while (xp != bp1)
*cp++ = *xp++;
compare_defs (d1, d2)
DEFINITION *d1, *d2;
{
- register struct reflist *a1, *a2;
- register U_CHAR *p1 = d1->expansion;
- register U_CHAR *p2 = d2->expansion;
+ struct reflist *a1, *a2;
+ U_CHAR *p1 = d1->expansion;
+ U_CHAR *p2 = d2->expansion;
int first = 1;
if (d1->nargs != d2->nargs)
int len1, len2;
int last;
{
- register const U_CHAR *end1 = beg1 + len1;
- register const U_CHAR *end2 = beg2 + len2;
+ const U_CHAR *end1 = beg1 + len1;
+ const U_CHAR *end2 = beg2 + len2;
if (first) {
while (beg1 != end1 && is_space (*beg1)) beg1++;
while (beg2 != end2 && is_space (*beg2)) beg2++;
struct arglist *arglist;
{
DEFINITION *defn;
- register U_CHAR *p, *limit, *lastp, *exp_p;
+ U_CHAR *p, *limit, *lastp, *exp_p;
struct reflist *endpat = NULL;
/* Pointer to first nonspace after last ## seen. */
U_CHAR *concat = 0;
/* Process the main body of the definition. */
while (p < limit) {
int skipped_arg = 0;
- register U_CHAR c = *p++;
+ U_CHAR c = *p++;
*exp_p++ = c;
id_len = p - id_beg;
if (is_idstart (c)) {
- register struct arglist *arg;
+ struct arglist *arg;
for (arg = arglist; arg != NULL; arg = arg->next) {
struct reflist *tpat;
tpat->argno = arg->argno;
tpat->nchars = exp_p - lastp;
{
- register U_CHAR *p1 = p;
+ U_CHAR *p1 = p;
SKIP_WHITE_SPACE (p1);
if (p1 + 2 <= limit && p1[0] == '#' && p1[1] == '#')
tpat->raw_after = 1;
/* If this was not a macro arg, copy it into the expansion. */
if (! skipped_arg) {
- register U_CHAR *lim1 = p;
+ U_CHAR *lim1 = p;
p = id_beg;
while (p != lim1)
*exp_p++ = *p++;
U_CHAR *buf, *limit;
FILE_BUF *op;
{
- register U_CHAR *bp;
+ U_CHAR *bp;
FILE_BUF *ip = &instack[indepth];
FILE_BUF tem;
int new_lineno;
FILE_BUF *ip;
int any;
{
- register U_CHAR *bp = ip->bufp, *cp;
- register U_CHAR *endb = ip->buf + ip->length;
+ U_CHAR *bp = ip->bufp, *cp;
+ U_CHAR *endb = ip->buf + ip->length;
struct directive *kt;
IF_STACK_FRAME *save_if_stack = if_stack; /* don't pop past here */
U_CHAR *beg_of_line = bp;
*/
static U_CHAR *
skip_to_end_of_comment (ip, line_counter)
- register FILE_BUF *ip;
+ FILE_BUF *ip;
int *line_counter; /* place to remember newlines, or NULL */
{
- register U_CHAR *limit = ip->buf + ip->length;
- register U_CHAR *bp = ip->bufp;
+ U_CHAR *limit = ip->buf + ip->length;
+ U_CHAR *bp = ip->bufp;
FILE_BUF *op = &outbuf; /* JF */
int output = put_out_comments && !line_counter;
*/
static U_CHAR *
skip_quoted_string (bp, limit, start_line, count_newlines, backslash_newlines_p, eofp)
- register const U_CHAR *bp;
- register const U_CHAR *limit;
+ const U_CHAR *bp;
+ const U_CHAR *limit;
int start_line;
int *count_newlines;
int *backslash_newlines_p;
int *eofp;
{
- register U_CHAR c, match;
+ U_CHAR c, match;
match = *bp++;
while (1) {
{
int nargs;
DEFINITION *defn = hp->value.defn;
- register U_CHAR *xbuf;
+ U_CHAR *xbuf;
int xbuf_len;
int start_line = instack[indepth].lineno;
nargs = defn->nargs;
if (nargs >= 0) {
- register int i;
+ int i;
struct argdata *args;
const char *parse_error = 0;
/* If we got one arg but it was just whitespace, call that 0 args. */
if (i == 1) {
- register const U_CHAR *bp = args[0].raw;
- register const U_CHAR *lim = bp + args[0].raw_length;
+ const U_CHAR *bp = args[0].raw;
+ const U_CHAR *lim = bp + args[0].raw_length;
while (bp != lim && is_space (*bp)) bp++;
if (bp == lim)
i = 0;
xbuf = defn->expansion;
xbuf_len = defn->length;
} else {
- register U_CHAR *exp = defn->expansion;
- register int offset; /* offset in expansion,
+ U_CHAR *exp = defn->expansion;
+ int offset; /* offset in expansion,
copied a piece at a time */
- register int totlen; /* total amount of exp buffer filled so far */
+ int totlen; /* total amount of exp buffer filled so far */
- register struct reflist *ap;
+ struct reflist *ap;
/* Macro really takes args. Compute the expansion of this call. */
of where we are copying from. */
offset = totlen = 0;
for (ap = defn->pattern; ap != NULL; ap = ap->next) {
- register struct argdata *arg = &args[ap->argno];
+ struct argdata *arg = &args[ap->argno];
for (i = 0; i < ap->nchars; i++)
xbuf[totlen++] = exp[offset++];
/* Now put the expansion on the input stack
so our caller will commence reading from it. */
{
- register FILE_BUF *ip2;
+ FILE_BUF *ip2;
ip2 = &instack[++indepth];
static const char *
macarg (argptr)
- register struct argdata *argptr;
+ struct argdata *argptr;
{
FILE_BUF *ip = &instack[indepth];
int paren = 0;
if (argptr != 0) {
FILE_BUF obuf;
- register const U_CHAR *buf, *lim;
- register int totlen;
+ const U_CHAR *buf, *lim;
+ int totlen;
obuf = expand_to_temp_buffer (argptr->raw,
argptr->raw + argptr->raw_length,
totlen = 0;
while (buf != lim) {
- register U_CHAR c = *buf++;
+ U_CHAR c = *buf++;
totlen++;
/* Internal sequences of whitespace are replaced by one space
in most cases, but not always. So count all the whitespace
static U_CHAR *
macarg1 (start, limit, depthptr, newlines, comments)
U_CHAR *start;
- register const U_CHAR *limit;
+ const U_CHAR *limit;
int *depthptr, *newlines, *comments;
{
- register U_CHAR *bp = start;
+ U_CHAR *bp = start;
while (bp < limit) {
switch (*bp) {
int length;
int newlines;
{
- register U_CHAR *ibp;
- register U_CHAR *obp;
- register const U_CHAR *limit;
- register int c;
+ U_CHAR *ibp;
+ U_CHAR *obp;
+ const U_CHAR *limit;
+ int c;
/* If we have newlines to duplicate, copy everything
that many characters up. Then, in the second part,
static void
grow_outbuf (obuf, needed)
- register FILE_BUF *obuf;
- register int needed;
+ FILE_BUF *obuf;
+ int needed;
{
- register U_CHAR *p;
+ U_CHAR *p;
int minsize;
if (obuf->length - (obuf->bufp - obuf->buf) > needed)
int hash;
/* watch out here if sizeof (U_CHAR *) != sizeof (int) */
{
- register HASHNODE *hp;
- register int bucket;
- register const U_CHAR *p;
+ HASHNODE *hp;
+ int bucket;
+ const U_CHAR *p;
U_CHAR *q;
if (len < 0) {
int len;
int hash;
{
- register const U_CHAR *bp;
- register HASHNODE *bucket;
+ const U_CHAR *bp;
+ HASHNODE *bucket;
if (len < 0) {
for (bp = name; is_idchar (*bp); bp++) ;
*/
static int
hashf (name, len, hashsize)
- register const U_CHAR *name;
- register int len;
+ const U_CHAR *name;
+ int len;
int hashsize;
{
- register int r = 0;
+ int r = 0;
while (len--)
r = HASHSTEP (r, *name++);
int bucket;
for (bucket = 0; bucket < HASHSIZE; bucket++) {
- register HASHNODE *hp;
+ HASHNODE *hp;
for (hp = hashtab[bucket]; hp; hp= hp->next) {
if (hp->type == T_MACRO) {
- register DEFINITION *defn = hp->value.defn;
+ DEFINITION *defn = hp->value.defn;
struct reflist *ap;
int offset;
int concat;
DEFINITION *defn;
int argnum;
{
- register const U_CHAR *p = defn->argnames;
+ const U_CHAR *p = defn->argnames;
while (argnum + 1 < defn->nargs) {
p = (const U_CHAR *) strchr ((const char *)p, ' ') + 1;
argnum++;
OSDN Git Service
