mirror of
				git://git.code.sf.net/p/cdesktopenv/code
				synced 2025-03-09 15:50:02 +00:00 
			
		
		
		
	dtdocbook: remove register keyword
This commit is contained in:
		
							parent
							
								
									ca7d34b7ff
								
							
						
					
					
						commit
						55a80f00cf
					
				
					 22 changed files with 316 additions and 306 deletions
				
			
		| 
						 | 
				
			
			@ -214,10 +214,10 @@ STATIC int strcspn();
 | 
			
		|||
regexp *
 | 
			
		||||
tpt_regcomp(char *exp)
 | 
			
		||||
{
 | 
			
		||||
	register regexp *r;
 | 
			
		||||
	register char *scan;
 | 
			
		||||
	register char *longest;
 | 
			
		||||
	register int len;
 | 
			
		||||
	regexp *r;
 | 
			
		||||
	char *scan;
 | 
			
		||||
	char *longest;
 | 
			
		||||
	int len;
 | 
			
		||||
	int flags;
 | 
			
		||||
 | 
			
		||||
	if (exp == NULL)
 | 
			
		||||
| 
						 | 
				
			
			@ -303,10 +303,10 @@ int paren,			/* Parenthesized? */
 | 
			
		|||
int *flagp
 | 
			
		||||
)
 | 
			
		||||
{
 | 
			
		||||
	register char *ret;
 | 
			
		||||
	register char *br;
 | 
			
		||||
	register char *ender;
 | 
			
		||||
	register int parno;
 | 
			
		||||
	char *ret;
 | 
			
		||||
	char *br;
 | 
			
		||||
	char *ender;
 | 
			
		||||
	int parno;
 | 
			
		||||
	int flags;
 | 
			
		||||
 | 
			
		||||
	*flagp = HASWIDTH;	/* Tentatively. */
 | 
			
		||||
| 
						 | 
				
			
			@ -373,9 +373,9 @@ int *flagp
 | 
			
		|||
static char *
 | 
			
		||||
regbranch(int *flagp)
 | 
			
		||||
{
 | 
			
		||||
	register char *ret;
 | 
			
		||||
	register char *chain;
 | 
			
		||||
	register char *latest;
 | 
			
		||||
	char *ret;
 | 
			
		||||
	char *chain;
 | 
			
		||||
	char *latest;
 | 
			
		||||
	int flags;
 | 
			
		||||
 | 
			
		||||
	*flagp = WORST;		/* Tentatively. */
 | 
			
		||||
| 
						 | 
				
			
			@ -411,9 +411,9 @@ regbranch(int *flagp)
 | 
			
		|||
static char *
 | 
			
		||||
regpiece(int *flagp)
 | 
			
		||||
{
 | 
			
		||||
	register char *ret;
 | 
			
		||||
	register char op;
 | 
			
		||||
	register char *next;
 | 
			
		||||
	char *ret;
 | 
			
		||||
	char op;
 | 
			
		||||
	char *next;
 | 
			
		||||
	int flags;
 | 
			
		||||
 | 
			
		||||
	ret = regatom(&flags);
 | 
			
		||||
| 
						 | 
				
			
			@ -474,7 +474,7 @@ regpiece(int *flagp)
 | 
			
		|||
static char *
 | 
			
		||||
regatom(int *flagp)
 | 
			
		||||
{
 | 
			
		||||
	register char *ret;
 | 
			
		||||
	char *ret;
 | 
			
		||||
	int flags;
 | 
			
		||||
 | 
			
		||||
	*flagp = WORST;		/* Tentatively. */
 | 
			
		||||
| 
						 | 
				
			
			@ -491,8 +491,8 @@ regatom(int *flagp)
 | 
			
		|||
		*flagp |= HASWIDTH|SIMPLE;
 | 
			
		||||
		break;
 | 
			
		||||
	case '[': {
 | 
			
		||||
			register int class;
 | 
			
		||||
			register int classend;
 | 
			
		||||
			int class;
 | 
			
		||||
			int classend;
 | 
			
		||||
 | 
			
		||||
			if (*regparse == '^') {	/* Complement of range. */
 | 
			
		||||
				ret = regnode(ANYBUT);
 | 
			
		||||
| 
						 | 
				
			
			@ -550,8 +550,8 @@ regatom(int *flagp)
 | 
			
		|||
		*flagp |= HASWIDTH|SIMPLE;
 | 
			
		||||
		break;
 | 
			
		||||
	default: {
 | 
			
		||||
			register int len;
 | 
			
		||||
			register char ender;
 | 
			
		||||
			int len;
 | 
			
		||||
			char ender;
 | 
			
		||||
 | 
			
		||||
			regparse--;
 | 
			
		||||
			len = strcspn(regparse, META);
 | 
			
		||||
| 
						 | 
				
			
			@ -582,8 +582,8 @@ regatom(int *flagp)
 | 
			
		|||
static char *			/* Location. */
 | 
			
		||||
regnode(char op)
 | 
			
		||||
{
 | 
			
		||||
	register char *ret;
 | 
			
		||||
	register char *ptr;
 | 
			
		||||
	char *ret;
 | 
			
		||||
	char *ptr;
 | 
			
		||||
 | 
			
		||||
	ret = regcode;
 | 
			
		||||
	if (ret == ®dummy) {
 | 
			
		||||
| 
						 | 
				
			
			@ -620,9 +620,9 @@ regc(char b)
 | 
			
		|||
static void
 | 
			
		||||
reginsert(char op, char *opnd)
 | 
			
		||||
{
 | 
			
		||||
	register char *src;
 | 
			
		||||
	register char *dst;
 | 
			
		||||
	register char *place;
 | 
			
		||||
	char *src;
 | 
			
		||||
	char *dst;
 | 
			
		||||
	char *place;
 | 
			
		||||
 | 
			
		||||
	if (regcode == ®dummy) {
 | 
			
		||||
		regsize += 3;
 | 
			
		||||
| 
						 | 
				
			
			@ -647,9 +647,9 @@ reginsert(char op, char *opnd)
 | 
			
		|||
static void
 | 
			
		||||
regtail(char *p, char *val)
 | 
			
		||||
{
 | 
			
		||||
	register char *scan;
 | 
			
		||||
	register char *temp;
 | 
			
		||||
	register int offset;
 | 
			
		||||
	char *scan;
 | 
			
		||||
	char *temp;
 | 
			
		||||
	int offset;
 | 
			
		||||
 | 
			
		||||
	if (p == ®dummy)
 | 
			
		||||
		return;
 | 
			
		||||
| 
						 | 
				
			
			@ -712,9 +712,15 @@ STATIC char *regprop();
 | 
			
		|||
 - regexec - match a regexp against a string
 | 
			
		||||
 */
 | 
			
		||||
int
 | 
			
		||||
<<<<<<< ca7d34b7ff5f017e3228714bb583266f7cdf946f
 | 
			
		||||
tpt_regexec(register regexp *prog, register char *string)
 | 
			
		||||
=======
 | 
			
		||||
tpt_regexec(prog, string)
 | 
			
		||||
regexp *prog;
 | 
			
		||||
char *string;
 | 
			
		||||
>>>>>>> dtdocbook: remove register keyword
 | 
			
		||||
{
 | 
			
		||||
	register char *s;
 | 
			
		||||
	char *s;
 | 
			
		||||
 | 
			
		||||
	/* Be paranoid... */
 | 
			
		||||
	if (prog == NULL || string == NULL) {
 | 
			
		||||
| 
						 | 
				
			
			@ -773,9 +779,9 @@ tpt_regexec(register regexp *prog, register char *string)
 | 
			
		|||
static int			/* 0 failure, 1 success */
 | 
			
		||||
regtry(regexp *prog, char *string)
 | 
			
		||||
{
 | 
			
		||||
	register int i;
 | 
			
		||||
	register char **sp;
 | 
			
		||||
	register char **ep;
 | 
			
		||||
	int i;
 | 
			
		||||
	char **sp;
 | 
			
		||||
	char **ep;
 | 
			
		||||
 | 
			
		||||
	reginput = string;
 | 
			
		||||
	regstartp = prog->startp;
 | 
			
		||||
| 
						 | 
				
			
			@ -808,7 +814,7 @@ regtry(regexp *prog, char *string)
 | 
			
		|||
static int			/* 0 failure, 1 success */
 | 
			
		||||
regmatch(char *prog)
 | 
			
		||||
{
 | 
			
		||||
	register char *scan;	/* Current node. */
 | 
			
		||||
	char *scan;	/* Current node. */
 | 
			
		||||
	char *next;		/* Next node. */
 | 
			
		||||
 | 
			
		||||
	scan = prog;
 | 
			
		||||
| 
						 | 
				
			
			@ -838,8 +844,8 @@ regmatch(char *prog)
 | 
			
		|||
			reginput++;
 | 
			
		||||
			break;
 | 
			
		||||
		case EXACTLY: {
 | 
			
		||||
				register int len;
 | 
			
		||||
				register char *opnd;
 | 
			
		||||
				int len;
 | 
			
		||||
				char *opnd;
 | 
			
		||||
 | 
			
		||||
				opnd = OPERAND(scan);
 | 
			
		||||
				/* Inline the first character, for speed. */
 | 
			
		||||
| 
						 | 
				
			
			@ -874,8 +880,8 @@ regmatch(char *prog)
 | 
			
		|||
		case OPEN+7:
 | 
			
		||||
		case OPEN+8:
 | 
			
		||||
		case OPEN+9: {
 | 
			
		||||
				register int no;
 | 
			
		||||
				register char *save;
 | 
			
		||||
				int no;
 | 
			
		||||
				char *save;
 | 
			
		||||
 | 
			
		||||
				no = OP(scan) - OPEN;
 | 
			
		||||
				save = reginput;
 | 
			
		||||
| 
						 | 
				
			
			@ -902,8 +908,8 @@ regmatch(char *prog)
 | 
			
		|||
		case CLOSE+7:
 | 
			
		||||
		case CLOSE+8:
 | 
			
		||||
		case CLOSE+9: {
 | 
			
		||||
				register int no;
 | 
			
		||||
				register char *save;
 | 
			
		||||
				int no;
 | 
			
		||||
				char *save;
 | 
			
		||||
 | 
			
		||||
				no = OP(scan) - CLOSE;
 | 
			
		||||
				save = reginput;
 | 
			
		||||
| 
						 | 
				
			
			@ -922,7 +928,7 @@ regmatch(char *prog)
 | 
			
		|||
			}
 | 
			
		||||
			break;
 | 
			
		||||
		case BRANCH: {
 | 
			
		||||
				register char *save;
 | 
			
		||||
				char *save;
 | 
			
		||||
 | 
			
		||||
				if (OP(next) != BRANCH)		/* No choice. */
 | 
			
		||||
					next = OPERAND(scan);	/* Avoid recursion. */
 | 
			
		||||
| 
						 | 
				
			
			@ -941,10 +947,10 @@ regmatch(char *prog)
 | 
			
		|||
			break;
 | 
			
		||||
		case STAR:
 | 
			
		||||
		case PLUS: {
 | 
			
		||||
				register char nextch;
 | 
			
		||||
				register int no;
 | 
			
		||||
				register char *save;
 | 
			
		||||
				register int min;
 | 
			
		||||
				char nextch;
 | 
			
		||||
				int no;
 | 
			
		||||
				char *save;
 | 
			
		||||
				int min;
 | 
			
		||||
 | 
			
		||||
				/*
 | 
			
		||||
				 * Lookahead to avoid useless match attempts
 | 
			
		||||
| 
						 | 
				
			
			@ -994,9 +1000,9 @@ regmatch(char *prog)
 | 
			
		|||
static int
 | 
			
		||||
regrepeat(char *p)
 | 
			
		||||
{
 | 
			
		||||
	register int count = 0;
 | 
			
		||||
	register char *scan;
 | 
			
		||||
	register char *opnd;
 | 
			
		||||
	int count = 0;
 | 
			
		||||
	char *scan;
 | 
			
		||||
	char *opnd;
 | 
			
		||||
 | 
			
		||||
	scan = reginput;
 | 
			
		||||
	opnd = OPERAND(p);
 | 
			
		||||
| 
						 | 
				
			
			@ -1037,9 +1043,14 @@ regrepeat(char *p)
 | 
			
		|||
 - regnext - dig the "next" pointer out of a node
 | 
			
		||||
 */
 | 
			
		||||
static char *
 | 
			
		||||
<<<<<<< ca7d34b7ff5f017e3228714bb583266f7cdf946f
 | 
			
		||||
regnext(register char *p)
 | 
			
		||||
=======
 | 
			
		||||
regnext(p)
 | 
			
		||||
char *p;
 | 
			
		||||
>>>>>>> dtdocbook: remove register keyword
 | 
			
		||||
{
 | 
			
		||||
	register int offset;
 | 
			
		||||
	int offset;
 | 
			
		||||
 | 
			
		||||
	if (p == ®dummy)
 | 
			
		||||
		return(NULL);
 | 
			
		||||
| 
						 | 
				
			
			@ -1064,9 +1075,9 @@ STATIC char *regprop();
 | 
			
		|||
void
 | 
			
		||||
regdump(regexp *r)
 | 
			
		||||
{
 | 
			
		||||
	register char *s;
 | 
			
		||||
	register char op = EXACTLY;	/* Arbitrary non-END op. */
 | 
			
		||||
	register char *next;
 | 
			
		||||
	char *s;
 | 
			
		||||
	char op = EXACTLY;	/* Arbitrary non-END op. */
 | 
			
		||||
	char *next;
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
	s = r->program + 1;
 | 
			
		||||
| 
						 | 
				
			
			@ -1106,7 +1117,7 @@ regdump(regexp *r)
 | 
			
		|||
static char *
 | 
			
		||||
regprop(char *op)
 | 
			
		||||
{
 | 
			
		||||
	register char *p;
 | 
			
		||||
	char *p;
 | 
			
		||||
	static char buf[50];
 | 
			
		||||
 | 
			
		||||
	(void) strcpy(buf, ":");
 | 
			
		||||
| 
						 | 
				
			
			@ -1197,9 +1208,9 @@ regprop(char *op)
 | 
			
		|||
static int
 | 
			
		||||
strcspn(char *s1, char *s2)
 | 
			
		||||
{
 | 
			
		||||
	register char *scan1;
 | 
			
		||||
	register char *scan2;
 | 
			
		||||
	register int count;
 | 
			
		||||
	char *scan1;
 | 
			
		||||
	char *scan2;
 | 
			
		||||
	int count;
 | 
			
		||||
 | 
			
		||||
	count = 0;
 | 
			
		||||
	for (scan1 = s1; *scan1 != '\0'; scan1++) {
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -57,11 +57,11 @@
 | 
			
		|||
void
 | 
			
		||||
tpt_regsub(regexp *prog, char *source, char *dest)
 | 
			
		||||
{
 | 
			
		||||
	register char *src;
 | 
			
		||||
	register char *dst;
 | 
			
		||||
	register char c;
 | 
			
		||||
	register int no;
 | 
			
		||||
	register int len;
 | 
			
		||||
	char *src;
 | 
			
		||||
	char *dst;
 | 
			
		||||
	char c;
 | 
			
		||||
	int no;
 | 
			
		||||
	int len;
 | 
			
		||||
	extern char *strncpy();
 | 
			
		||||
 | 
			
		||||
	if (prog == NULL || source == NULL || dest == NULL) {
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -135,7 +135,7 @@ int lineno = 0;
 | 
			
		|||
multiple(ncomp, nexec, nsub)
 | 
			
		||||
int ncomp, nexec, nsub;
 | 
			
		||||
{
 | 
			
		||||
	register int i;
 | 
			
		||||
	int i;
 | 
			
		||||
	extern char *strchr();
 | 
			
		||||
 | 
			
		||||
	errreport = 1;
 | 
			
		||||
| 
						 | 
				
			
			@ -151,7 +151,7 @@ int ncomp, nexec, nsub;
 | 
			
		|||
{
 | 
			
		||||
	regexp *r;
 | 
			
		||||
	char dbuf[BUFSIZ];
 | 
			
		||||
	register int i;
 | 
			
		||||
	int i;
 | 
			
		||||
 | 
			
		||||
	errseen = NULL;
 | 
			
		||||
	r = tpt_regcomp(fields.re);
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -58,8 +58,8 @@ char *opts;
 | 
			
		|||
	static char switchar = '\0';
 | 
			
		||||
#endif
 | 
			
		||||
	static int sp = 1;
 | 
			
		||||
	register int c;
 | 
			
		||||
	register char *cp;
 | 
			
		||||
	int c;
 | 
			
		||||
	char *cp;
 | 
			
		||||
	char *message;
 | 
			
		||||
#ifdef SWITCHAR
 | 
			
		||||
	if (switchar == '\0') {
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -923,9 +923,9 @@ int etag()
 | 
			
		|||
*/
 | 
			
		||||
VOID destack()
 | 
			
		||||
{
 | 
			
		||||
     register int ecode = 0;  /* Error code (0=o.k.). */
 | 
			
		||||
     int ecode = 0;  /* Error code (0=o.k.). */
 | 
			
		||||
     UNCH *eparm2 = NULL;     /* Second parameter of error message. */
 | 
			
		||||
     register int minmsgsw;   /* 1=message if tag omitted; 0=no message. */
 | 
			
		||||
     int minmsgsw;   /* 1=message if tag omitted; 0=no message. */
 | 
			
		||||
 | 
			
		||||
     /* If element has a content model (i.e., not a keyword) and there
 | 
			
		||||
        are required tags left, and no CONREF attribute was specified,
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -260,10 +260,10 @@ static int strcspn _ANSI_ARGS_((char *s1, char *s2));
 | 
			
		|||
regexp *
 | 
			
		||||
TclRegComp(char *exp)
 | 
			
		||||
{
 | 
			
		||||
	register regexp *r;
 | 
			
		||||
	register char *scan;
 | 
			
		||||
	register char *longest;
 | 
			
		||||
	register int len;
 | 
			
		||||
	regexp *r;
 | 
			
		||||
	char *scan;
 | 
			
		||||
	char *longest;
 | 
			
		||||
	int len;
 | 
			
		||||
	int flags;
 | 
			
		||||
	struct regcomp_state state;
 | 
			
		||||
	struct regcomp_state *rcstate= &state;
 | 
			
		||||
| 
						 | 
				
			
			@ -348,10 +348,10 @@ TclRegComp(char *exp)
 | 
			
		|||
static char *
 | 
			
		||||
reg(int paren /* Parenthesized? */, int *flagp, struct regcomp_state *rcstate)
 | 
			
		||||
{
 | 
			
		||||
	register char *ret;
 | 
			
		||||
	register char *br;
 | 
			
		||||
	register char *ender;
 | 
			
		||||
	register int parno = 0;
 | 
			
		||||
	char *ret;
 | 
			
		||||
	char *br;
 | 
			
		||||
	char *ender;
 | 
			
		||||
	int parno = 0;
 | 
			
		||||
	int flags;
 | 
			
		||||
 | 
			
		||||
	*flagp = HASWIDTH;	/* Tentatively. */
 | 
			
		||||
| 
						 | 
				
			
			@ -418,9 +418,9 @@ reg(int paren /* Parenthesized? */, int *flagp, struct regcomp_state *rcstate)
 | 
			
		|||
static char *
 | 
			
		||||
regbranch(int *flagp, struct regcomp_state *rcstate)
 | 
			
		||||
{
 | 
			
		||||
	register char *ret;
 | 
			
		||||
	register char *chain;
 | 
			
		||||
	register char *latest;
 | 
			
		||||
	char *ret;
 | 
			
		||||
	char *chain;
 | 
			
		||||
	char *latest;
 | 
			
		||||
	int flags;
 | 
			
		||||
 | 
			
		||||
	*flagp = WORST;		/* Tentatively. */
 | 
			
		||||
| 
						 | 
				
			
			@ -457,9 +457,9 @@ regbranch(int *flagp, struct regcomp_state *rcstate)
 | 
			
		|||
static char *
 | 
			
		||||
regpiece(int *flagp, struct regcomp_state *rcstate)
 | 
			
		||||
{
 | 
			
		||||
	register char *ret;
 | 
			
		||||
	register char op;
 | 
			
		||||
	register char *next;
 | 
			
		||||
	char *ret;
 | 
			
		||||
	char op;
 | 
			
		||||
	char *next;
 | 
			
		||||
	int flags;
 | 
			
		||||
 | 
			
		||||
	ret = regatom(&flags,rcstate);
 | 
			
		||||
| 
						 | 
				
			
			@ -520,7 +520,7 @@ regpiece(int *flagp, struct regcomp_state *rcstate)
 | 
			
		|||
static char *
 | 
			
		||||
regatom(int *flagp, struct regcomp_state *rcstate)
 | 
			
		||||
{
 | 
			
		||||
	register char *ret;
 | 
			
		||||
	char *ret;
 | 
			
		||||
	int flags;
 | 
			
		||||
 | 
			
		||||
	*flagp = WORST;		/* Tentatively. */
 | 
			
		||||
| 
						 | 
				
			
			@ -537,8 +537,8 @@ regatom(int *flagp, struct regcomp_state *rcstate)
 | 
			
		|||
		*flagp |= HASWIDTH|SIMPLE;
 | 
			
		||||
		break;
 | 
			
		||||
	case '[': {
 | 
			
		||||
			register int clss;
 | 
			
		||||
			register int classend;
 | 
			
		||||
			int clss;
 | 
			
		||||
			int classend;
 | 
			
		||||
 | 
			
		||||
			if (*rcstate->regparse == '^') {	/* Complement of range. */
 | 
			
		||||
				ret = regnode(ANYBUT,rcstate);
 | 
			
		||||
| 
						 | 
				
			
			@ -598,8 +598,8 @@ regatom(int *flagp, struct regcomp_state *rcstate)
 | 
			
		|||
		*flagp |= HASWIDTH|SIMPLE;
 | 
			
		||||
		break;
 | 
			
		||||
	default: {
 | 
			
		||||
			register int len;
 | 
			
		||||
			register char ender;
 | 
			
		||||
			int len;
 | 
			
		||||
			char ender;
 | 
			
		||||
 | 
			
		||||
			rcstate->regparse--;
 | 
			
		||||
			len = strcspn(rcstate->regparse, META);
 | 
			
		||||
| 
						 | 
				
			
			@ -630,8 +630,8 @@ regatom(int *flagp, struct regcomp_state *rcstate)
 | 
			
		|||
static char *			/* Location. */
 | 
			
		||||
regnode(int op, struct regcomp_state *rcstate)
 | 
			
		||||
{
 | 
			
		||||
	register char *ret;
 | 
			
		||||
	register char *ptr;
 | 
			
		||||
	char *ret;
 | 
			
		||||
	char *ptr;
 | 
			
		||||
 | 
			
		||||
	ret = rcstate->regcode;
 | 
			
		||||
	if (ret == ®dummy) {
 | 
			
		||||
| 
						 | 
				
			
			@ -668,9 +668,9 @@ regc(int b, struct regcomp_state *rcstate)
 | 
			
		|||
static void
 | 
			
		||||
reginsert(int op, char *opnd, struct regcomp_state *rcstate)
 | 
			
		||||
{
 | 
			
		||||
	register char *src;
 | 
			
		||||
	register char *dst;
 | 
			
		||||
	register char *place;
 | 
			
		||||
	char *src;
 | 
			
		||||
	char *dst;
 | 
			
		||||
	char *place;
 | 
			
		||||
 | 
			
		||||
	if (rcstate->regcode == ®dummy) {
 | 
			
		||||
		rcstate->regsize += 3;
 | 
			
		||||
| 
						 | 
				
			
			@ -695,9 +695,9 @@ reginsert(int op, char *opnd, struct regcomp_state *rcstate)
 | 
			
		|||
static void
 | 
			
		||||
regtail(char *p, char *val)
 | 
			
		||||
{
 | 
			
		||||
	register char *scan;
 | 
			
		||||
	register char *temp;
 | 
			
		||||
	register int offset;
 | 
			
		||||
	char *scan;
 | 
			
		||||
	char *temp;
 | 
			
		||||
	int offset;
 | 
			
		||||
 | 
			
		||||
	if (p == ®dummy)
 | 
			
		||||
		return;
 | 
			
		||||
| 
						 | 
				
			
			@ -765,9 +765,9 @@ static char *regprop _ANSI_ARGS_((char *op));
 | 
			
		|||
 - TclRegExec - match a regexp against a string
 | 
			
		||||
 */
 | 
			
		||||
int
 | 
			
		||||
TclRegExec(register regexp *prog, register char *string, char *start)
 | 
			
		||||
TclRegExec(regexp *prog, char *string, char *start)
 | 
			
		||||
{
 | 
			
		||||
	register char *s;
 | 
			
		||||
	char *s;
 | 
			
		||||
	struct regexec_state state;
 | 
			
		||||
	struct regexec_state *restate= &state;
 | 
			
		||||
 | 
			
		||||
| 
						 | 
				
			
			@ -829,9 +829,9 @@ TclRegExec(register regexp *prog, register char *string, char *start)
 | 
			
		|||
static int			/* 0 failure, 1 success */
 | 
			
		||||
regtry(regexp *prog, char *string, struct regexec_state *restate)
 | 
			
		||||
{
 | 
			
		||||
	register int i;
 | 
			
		||||
	register char **sp;
 | 
			
		||||
	register char **ep;
 | 
			
		||||
	int i;
 | 
			
		||||
	char **sp;
 | 
			
		||||
	char **ep;
 | 
			
		||||
 | 
			
		||||
	restate->reginput = string;
 | 
			
		||||
	restate->regstartp = prog->startp;
 | 
			
		||||
| 
						 | 
				
			
			@ -864,7 +864,7 @@ regtry(regexp *prog, char *string, struct regexec_state *restate)
 | 
			
		|||
static int			/* 0 failure, 1 success */
 | 
			
		||||
regmatch(char *prog, struct regexec_state *restate)
 | 
			
		||||
{
 | 
			
		||||
    register char *scan;	/* Current node. */
 | 
			
		||||
    char *scan;	/* Current node. */
 | 
			
		||||
    char *next;		/* Next node. */
 | 
			
		||||
 | 
			
		||||
    scan = prog;
 | 
			
		||||
| 
						 | 
				
			
			@ -897,8 +897,8 @@ regmatch(char *prog, struct regexec_state *restate)
 | 
			
		|||
		restate->reginput++;
 | 
			
		||||
		break;
 | 
			
		||||
	    case EXACTLY: {
 | 
			
		||||
		register int len;
 | 
			
		||||
		register char *opnd;
 | 
			
		||||
		int len;
 | 
			
		||||
		char *opnd;
 | 
			
		||||
 | 
			
		||||
		opnd = OPERAND(scan);
 | 
			
		||||
		/* Inline the first character, for speed. */
 | 
			
		||||
| 
						 | 
				
			
			@ -940,8 +940,8 @@ regmatch(char *prog, struct regexec_state *restate)
 | 
			
		|||
	    case OPEN+7:
 | 
			
		||||
	    case OPEN+8:
 | 
			
		||||
	    case OPEN+9: {
 | 
			
		||||
		register int no;
 | 
			
		||||
		register char *save;
 | 
			
		||||
		int no;
 | 
			
		||||
		char *save;
 | 
			
		||||
 | 
			
		||||
	doOpen:
 | 
			
		||||
		no = OP(scan) - OPEN;
 | 
			
		||||
| 
						 | 
				
			
			@ -969,8 +969,8 @@ regmatch(char *prog, struct regexec_state *restate)
 | 
			
		|||
	    case CLOSE+7:
 | 
			
		||||
	    case CLOSE+8:
 | 
			
		||||
	    case CLOSE+9: {
 | 
			
		||||
		register int no;
 | 
			
		||||
		register char *save;
 | 
			
		||||
		int no;
 | 
			
		||||
		char *save;
 | 
			
		||||
 | 
			
		||||
	doClose:
 | 
			
		||||
		no = OP(scan) - CLOSE;
 | 
			
		||||
| 
						 | 
				
			
			@ -990,7 +990,7 @@ regmatch(char *prog, struct regexec_state *restate)
 | 
			
		|||
		}
 | 
			
		||||
	    }
 | 
			
		||||
	    case BRANCH: {
 | 
			
		||||
		register char *save;
 | 
			
		||||
		char *save;
 | 
			
		||||
 | 
			
		||||
		if (OP(next) != BRANCH) { /* No choice. */
 | 
			
		||||
		    next = OPERAND(scan); /* Avoid recursion. */
 | 
			
		||||
| 
						 | 
				
			
			@ -1008,10 +1008,10 @@ regmatch(char *prog, struct regexec_state *restate)
 | 
			
		|||
	    }
 | 
			
		||||
	    case STAR:
 | 
			
		||||
	    case PLUS: {
 | 
			
		||||
		register char nextch;
 | 
			
		||||
		register int no;
 | 
			
		||||
		register char *save;
 | 
			
		||||
		register int min;
 | 
			
		||||
		char nextch;
 | 
			
		||||
		int no;
 | 
			
		||||
		char *save;
 | 
			
		||||
		int min;
 | 
			
		||||
 | 
			
		||||
		/*
 | 
			
		||||
		 * Lookahead to avoid useless match attempts
 | 
			
		||||
| 
						 | 
				
			
			@ -1063,9 +1063,9 @@ regmatch(char *prog, struct regexec_state *restate)
 | 
			
		|||
static int
 | 
			
		||||
regrepeat(char *p, struct regexec_state *restate)
 | 
			
		||||
{
 | 
			
		||||
	register int count = 0;
 | 
			
		||||
	register char *scan;
 | 
			
		||||
	register char *opnd;
 | 
			
		||||
	int count = 0;
 | 
			
		||||
	char *scan;
 | 
			
		||||
	char *opnd;
 | 
			
		||||
 | 
			
		||||
	scan = restate->reginput;
 | 
			
		||||
	opnd = OPERAND(p);
 | 
			
		||||
| 
						 | 
				
			
			@ -1106,9 +1106,9 @@ regrepeat(char *p, struct regexec_state *restate)
 | 
			
		|||
 - regnext - dig the "next" pointer out of a node
 | 
			
		||||
 */
 | 
			
		||||
static char *
 | 
			
		||||
regnext(register char *p)
 | 
			
		||||
regnext(char *p)
 | 
			
		||||
{
 | 
			
		||||
	register int offset;
 | 
			
		||||
	int offset;
 | 
			
		||||
 | 
			
		||||
	if (p == ®dummy)
 | 
			
		||||
		return(NULL);
 | 
			
		||||
| 
						 | 
				
			
			@ -1133,9 +1133,9 @@ static char *regprop();
 | 
			
		|||
void
 | 
			
		||||
regdump(regexp *r)
 | 
			
		||||
{
 | 
			
		||||
	register char *s;
 | 
			
		||||
	register char op = EXACTLY;	/* Arbitrary non-END op. */
 | 
			
		||||
	register char *next;
 | 
			
		||||
	char *s;
 | 
			
		||||
	char op = EXACTLY;	/* Arbitrary non-END op. */
 | 
			
		||||
	char *next;
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
	s = r->program + 1;
 | 
			
		||||
| 
						 | 
				
			
			@ -1175,7 +1175,7 @@ regdump(regexp *r)
 | 
			
		|||
static char *
 | 
			
		||||
regprop(char *op)
 | 
			
		||||
{
 | 
			
		||||
	register char *p;
 | 
			
		||||
	char *p;
 | 
			
		||||
	static char buf[50];
 | 
			
		||||
 | 
			
		||||
	(void) strcpy(buf, ":");
 | 
			
		||||
| 
						 | 
				
			
			@ -1275,9 +1275,9 @@ regprop(char *op)
 | 
			
		|||
static int
 | 
			
		||||
strcspn(char *s1, char *s2)
 | 
			
		||||
{
 | 
			
		||||
	register char *scan1;
 | 
			
		||||
	register char *scan2;
 | 
			
		||||
	register int count;
 | 
			
		||||
	char *scan1;
 | 
			
		||||
	char *scan2;
 | 
			
		||||
	int count;
 | 
			
		||||
 | 
			
		||||
	count = 0;
 | 
			
		||||
	for (scan1 = s1; *scan1 != '\0'; scan1++) {
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -190,9 +190,9 @@ static CmdInfo builtInCmds[] = {
 | 
			
		|||
Tcl_Interp *
 | 
			
		||||
Tcl_CreateInterp(void)
 | 
			
		||||
{
 | 
			
		||||
    register Interp *iPtr;
 | 
			
		||||
    register Command *cmdPtr;
 | 
			
		||||
    register CmdInfo *cmdInfoPtr;
 | 
			
		||||
    Interp *iPtr;
 | 
			
		||||
    Command *cmdPtr;
 | 
			
		||||
    CmdInfo *cmdInfoPtr;
 | 
			
		||||
    Tcl_Channel chan;
 | 
			
		||||
    int i;
 | 
			
		||||
 | 
			
		||||
| 
						 | 
				
			
			@ -1172,7 +1172,7 @@ Tcl_Eval(
 | 
			
		|||
    int argc;
 | 
			
		||||
    int argSize = NUM_ARGS;
 | 
			
		||||
 | 
			
		||||
    register char *src;			/* Points to current character
 | 
			
		||||
    char *src;			/* Points to current character
 | 
			
		||||
					 * in cmd. */
 | 
			
		||||
    char termChar;			/* Return when this character is found
 | 
			
		||||
					 * (either ']' or '\0').  Zero means
 | 
			
		||||
| 
						 | 
				
			
			@ -1180,7 +1180,7 @@ Tcl_Eval(
 | 
			
		|||
    int flags;				/* Interp->evalFlags value when the
 | 
			
		||||
					 * procedure was called. */
 | 
			
		||||
    int result;				/* Return value. */
 | 
			
		||||
    register Interp *iPtr = (Interp *) interp;
 | 
			
		||||
    Interp *iPtr = (Interp *) interp;
 | 
			
		||||
    Tcl_HashEntry *hPtr;
 | 
			
		||||
    Command *cmdPtr;
 | 
			
		||||
    char *termPtr;			/* Contains character just after the
 | 
			
		||||
| 
						 | 
				
			
			@ -1193,7 +1193,7 @@ Tcl_Eval(
 | 
			
		|||
					 * all of offending command is included
 | 
			
		||||
					 * in errorInfo.  "" means that the
 | 
			
		||||
					 * command is all there. */
 | 
			
		||||
    register Trace *tracePtr;
 | 
			
		||||
    Trace *tracePtr;
 | 
			
		||||
    int oldCount = iPtr->cmdCount;	/* Used to tell whether any commands
 | 
			
		||||
					 * at all were executed. */
 | 
			
		||||
 | 
			
		||||
| 
						 | 
				
			
			@ -1271,7 +1271,7 @@ Tcl_Eval(
 | 
			
		|||
	 */
 | 
			
		||||
 | 
			
		||||
	while (1) {
 | 
			
		||||
	    register char c = *src;
 | 
			
		||||
	    char c = *src;
 | 
			
		||||
 | 
			
		||||
	    if ((CHAR_TYPE(c) != TCL_SPACE) && (c != ';') && (c != '\n')) {
 | 
			
		||||
		break;
 | 
			
		||||
| 
						 | 
				
			
			@ -1500,7 +1500,7 @@ Tcl_Eval(
 | 
			
		|||
 | 
			
		||||
    if ((result == TCL_ERROR) && !(iPtr->flags & ERR_ALREADY_LOGGED)) {
 | 
			
		||||
	int numChars;
 | 
			
		||||
	register char *p;
 | 
			
		||||
	char *p;
 | 
			
		||||
 | 
			
		||||
	/*
 | 
			
		||||
	 * Compute the line number where the error occurred.
 | 
			
		||||
| 
						 | 
				
			
			@ -1599,8 +1599,8 @@ Tcl_CreateTrace(
 | 
			
		|||
    ClientData clientData	/* Arbitrary one-word value to pass to proc. */
 | 
			
		||||
)
 | 
			
		||||
{
 | 
			
		||||
    register Trace *tracePtr;
 | 
			
		||||
    register Interp *iPtr = (Interp *) interp;
 | 
			
		||||
    Trace *tracePtr;
 | 
			
		||||
    Interp *iPtr = (Interp *) interp;
 | 
			
		||||
 | 
			
		||||
    tracePtr = (Trace *) ckalloc(sizeof(Trace));
 | 
			
		||||
    tracePtr->level = level;
 | 
			
		||||
| 
						 | 
				
			
			@ -1636,9 +1636,9 @@ Tcl_DeleteTrace(
 | 
			
		|||
				 * Tcl_CreateTrace). */
 | 
			
		||||
)
 | 
			
		||||
{
 | 
			
		||||
    register Interp *iPtr = (Interp *) interp;
 | 
			
		||||
    register Trace *tracePtr = (Trace *) trace;
 | 
			
		||||
    register Trace *tracePtr2;
 | 
			
		||||
    Interp *iPtr = (Interp *) interp;
 | 
			
		||||
    Trace *tracePtr = (Trace *) trace;
 | 
			
		||||
    Trace *tracePtr2;
 | 
			
		||||
 | 
			
		||||
    if (iPtr->tracePtr == tracePtr) {
 | 
			
		||||
	iPtr->tracePtr = tracePtr->nextPtr;
 | 
			
		||||
| 
						 | 
				
			
			@ -1681,7 +1681,7 @@ Tcl_AddErrorInfo(
 | 
			
		|||
    char *message		/* Message to record. */
 | 
			
		||||
)
 | 
			
		||||
{
 | 
			
		||||
    register Interp *iPtr = (Interp *) interp;
 | 
			
		||||
    Interp *iPtr = (Interp *) interp;
 | 
			
		||||
 | 
			
		||||
    /*
 | 
			
		||||
     * If an error is already being logged, then the new errorInfo
 | 
			
		||||
| 
						 | 
				
			
			@ -1788,7 +1788,7 @@ Tcl_GlobalEval(
 | 
			
		|||
    char *command		/* Command to evaluate. */
 | 
			
		||||
)
 | 
			
		||||
{
 | 
			
		||||
    register Interp *iPtr = (Interp *) interp;
 | 
			
		||||
    Interp *iPtr = (Interp *) interp;
 | 
			
		||||
    int result;
 | 
			
		||||
    CallFrame *savedVarFramePtr;
 | 
			
		||||
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -147,7 +147,7 @@ Tcl_CaseCmd(
 | 
			
		|||
    for (i = 0; i < caseArgc; i += 2) {
 | 
			
		||||
	int patArgc, j;
 | 
			
		||||
	char **patArgv;
 | 
			
		||||
	register char *p;
 | 
			
		||||
	char *p;
 | 
			
		||||
 | 
			
		||||
	if (i == (caseArgc-1)) {
 | 
			
		||||
	    interp->result = "extra case pattern with no body";
 | 
			
		||||
| 
						 | 
				
			
			@ -1383,7 +1383,7 @@ Tcl_FormatCmd(
 | 
			
		|||
    char **argv				/* Argument strings. */
 | 
			
		||||
)
 | 
			
		||||
{
 | 
			
		||||
    register char *format;	/* Used to read characters from the format
 | 
			
		||||
    char *format;	/* Used to read characters from the format
 | 
			
		||||
				 * string. */
 | 
			
		||||
    char newFormat[40];		/* A new format specifier is generated here. */
 | 
			
		||||
    int width;			/* Field width from field specifier, or 0 if
 | 
			
		||||
| 
						 | 
				
			
			@ -1445,7 +1445,7 @@ Tcl_FormatCmd(
 | 
			
		|||
    }
 | 
			
		||||
    argIndex = 2;
 | 
			
		||||
    for (format = argv[1]; *format != 0; ) {
 | 
			
		||||
	register char *newPtr = newFormat;
 | 
			
		||||
	char *newPtr = newFormat;
 | 
			
		||||
 | 
			
		||||
	width = precision = noPercent = useShort = 0;
 | 
			
		||||
	whichValue = PTR_VALUE;
 | 
			
		||||
| 
						 | 
				
			
			@ -1455,7 +1455,7 @@ Tcl_FormatCmd(
 | 
			
		|||
	 */
 | 
			
		||||
 | 
			
		||||
	if (*format != '%') {
 | 
			
		||||
	    register char *p;
 | 
			
		||||
	    char *p;
 | 
			
		||||
 | 
			
		||||
	    ptrValue = p = format;
 | 
			
		||||
	    while ((*format != '%') && (*format != 0)) {
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -269,7 +269,7 @@ Tcl_InfoCmd(
 | 
			
		|||
    char **argv				/* Argument strings. */
 | 
			
		||||
)
 | 
			
		||||
{
 | 
			
		||||
    register Interp *iPtr = (Interp *) interp;
 | 
			
		||||
    Interp *iPtr = (Interp *) interp;
 | 
			
		||||
    size_t length;
 | 
			
		||||
    int c;
 | 
			
		||||
    Arg *argPtr;
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -179,7 +179,7 @@ Tcl_RegexpCmd(
 | 
			
		|||
     */
 | 
			
		||||
 | 
			
		||||
    if (noCase) {
 | 
			
		||||
	register char *p;
 | 
			
		||||
	char *p;
 | 
			
		||||
 | 
			
		||||
	Tcl_DStringInit(&patternDString);
 | 
			
		||||
	Tcl_DStringAppend(&patternDString, argPtr[0], -1);
 | 
			
		||||
| 
						 | 
				
			
			@ -293,7 +293,7 @@ Tcl_RegsubCmd(
 | 
			
		|||
    char *string, *pattern, *p, *firstChar, *newValue, **argPtr;
 | 
			
		||||
    int match, flags, code, numMatches;
 | 
			
		||||
    char *start, *end, *subStart, *subEnd;
 | 
			
		||||
    register char *src, c;
 | 
			
		||||
    char *src, c;
 | 
			
		||||
    Tcl_DString stringDString, patternDString;
 | 
			
		||||
 | 
			
		||||
    if (argc < 5) {
 | 
			
		||||
| 
						 | 
				
			
			@ -539,7 +539,7 @@ Tcl_RenameCmd(
 | 
			
		|||
    char **argv				/* Argument strings. */
 | 
			
		||||
)
 | 
			
		||||
{
 | 
			
		||||
    register Command *cmdPtr;
 | 
			
		||||
    Command *cmdPtr;
 | 
			
		||||
    Interp *iPtr = (Interp *) interp;
 | 
			
		||||
    Tcl_HashEntry *hPtr;
 | 
			
		||||
    int new;
 | 
			
		||||
| 
						 | 
				
			
			@ -744,7 +744,7 @@ Tcl_ScanCmd(
 | 
			
		|||
    } Field;
 | 
			
		||||
    Field fields[MAX_FIELDS];		/* Info about all the fields in the
 | 
			
		||||
					 * format string. */
 | 
			
		||||
    register Field *curField;
 | 
			
		||||
    Field *curField;
 | 
			
		||||
    int numFields = 0;			/* Number of fields actually
 | 
			
		||||
					 * specified. */
 | 
			
		||||
    int suppress;			/* Current field is assignment-
 | 
			
		||||
| 
						 | 
				
			
			@ -755,7 +755,7 @@ Tcl_ScanCmd(
 | 
			
		|||
					 * Malloced; NULL means not allocated
 | 
			
		||||
					 * yet. */
 | 
			
		||||
    int numScanned;			/* sscanf's result. */
 | 
			
		||||
    register char *fmt;
 | 
			
		||||
    char *fmt;
 | 
			
		||||
    int i, widthSpecified, length, code;
 | 
			
		||||
 | 
			
		||||
    /*
 | 
			
		||||
| 
						 | 
				
			
			@ -766,7 +766,7 @@ Tcl_ScanCmd(
 | 
			
		|||
 | 
			
		||||
#   define STATIC_SIZE 5
 | 
			
		||||
    char copyBuf[STATIC_SIZE], *fmtCopy;
 | 
			
		||||
    register char *dst;
 | 
			
		||||
    char *dst;
 | 
			
		||||
 | 
			
		||||
    if (argc < 3) {
 | 
			
		||||
	Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
 | 
			
		||||
| 
						 | 
				
			
			@ -1066,7 +1066,7 @@ Tcl_SplitCmd(
 | 
			
		|||
)
 | 
			
		||||
{
 | 
			
		||||
    char *splitChars;
 | 
			
		||||
    register char *p, *p2;
 | 
			
		||||
    char *p, *p2;
 | 
			
		||||
    char *elementStart;
 | 
			
		||||
 | 
			
		||||
    if (argc == 2) {
 | 
			
		||||
| 
						 | 
				
			
			@ -1143,7 +1143,7 @@ Tcl_StringCmd(
 | 
			
		|||
)
 | 
			
		||||
{
 | 
			
		||||
    size_t length;
 | 
			
		||||
    register char *p;
 | 
			
		||||
    char *p;
 | 
			
		||||
    int match, c, first;
 | 
			
		||||
    int left = 0, right = 0;
 | 
			
		||||
 | 
			
		||||
| 
						 | 
				
			
			@ -1282,7 +1282,7 @@ Tcl_StringCmd(
 | 
			
		|||
	return TCL_OK;
 | 
			
		||||
    } else if ((c == 't') && (strncmp(argv[1], "tolower", length) == 0)
 | 
			
		||||
	    && (length >= 3)) {
 | 
			
		||||
	register char *p;
 | 
			
		||||
	char *p;
 | 
			
		||||
 | 
			
		||||
	if (argc != 3) {
 | 
			
		||||
	    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
 | 
			
		||||
| 
						 | 
				
			
			@ -1298,7 +1298,7 @@ Tcl_StringCmd(
 | 
			
		|||
	return TCL_OK;
 | 
			
		||||
    } else if ((c == 't') && (strncmp(argv[1], "toupper", length) == 0)
 | 
			
		||||
	    && (length >= 3)) {
 | 
			
		||||
	register char *p;
 | 
			
		||||
	char *p;
 | 
			
		||||
 | 
			
		||||
	if (argc != 3) {
 | 
			
		||||
	    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
 | 
			
		||||
| 
						 | 
				
			
			@ -1315,7 +1315,7 @@ Tcl_StringCmd(
 | 
			
		|||
    } else if ((c == 't') && (strncmp(argv[1], "trim", length) == 0)
 | 
			
		||||
	    && (length == 4)) {
 | 
			
		||||
	char *trimChars;
 | 
			
		||||
	register char *p, *checkPtr;
 | 
			
		||||
	char *p, *checkPtr;
 | 
			
		||||
 | 
			
		||||
	left = right = 1;
 | 
			
		||||
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -535,9 +535,9 @@ RelativeMonth(time_t Start, time_t RelMonth, time_t *TimePtr)
 | 
			
		|||
static int
 | 
			
		||||
LookupWord(char *buff)
 | 
			
		||||
{
 | 
			
		||||
    register char       *p;
 | 
			
		||||
    register char       *q;
 | 
			
		||||
    register TABLE      *tp;
 | 
			
		||||
    char       *p;
 | 
			
		||||
    char       *q;
 | 
			
		||||
    TABLE      *tp;
 | 
			
		||||
    int                 i;
 | 
			
		||||
    int                 abbrev;
 | 
			
		||||
 | 
			
		||||
| 
						 | 
				
			
			@ -654,8 +654,8 @@ LookupWord(char *buff)
 | 
			
		|||
static int
 | 
			
		||||
TclDatelex(void)
 | 
			
		||||
{
 | 
			
		||||
    register char       c;
 | 
			
		||||
    register char       *p;
 | 
			
		||||
    char       c;
 | 
			
		||||
    char       *p;
 | 
			
		||||
    char                buff[20];
 | 
			
		||||
    int                 Count;
 | 
			
		||||
    int                 sign;
 | 
			
		||||
| 
						 | 
				
			
			@ -1039,7 +1039,7 @@ int TclDateparse(void)
 | 
			
		|||
int TclDateparse()
 | 
			
		||||
#endif
 | 
			
		||||
{
 | 
			
		||||
	register YYSTYPE *TclDatepvt;	/* top of value stack for $vars */
 | 
			
		||||
	YYSTYPE *TclDatepvt;	/* top of value stack for $vars */
 | 
			
		||||
 | 
			
		||||
#if defined(__cplusplus) || defined(lint)
 | 
			
		||||
/*
 | 
			
		||||
| 
						 | 
				
			
			@ -1078,10 +1078,10 @@ int TclDateparse()
 | 
			
		|||
#endif
 | 
			
		||||
 | 
			
		||||
	{
 | 
			
		||||
		register YYSTYPE *TclDate_pv;	/* top of value stack */
 | 
			
		||||
		register int *TclDate_ps;		/* top of state stack */
 | 
			
		||||
		register int TclDate_state;		/* current state */
 | 
			
		||||
		register int  TclDate_n;		/* internal state number info */
 | 
			
		||||
		YYSTYPE *TclDate_pv;	/* top of value stack */
 | 
			
		||||
		int *TclDate_ps;		/* top of state stack */
 | 
			
		||||
		int TclDate_state;		/* current state */
 | 
			
		||||
		int  TclDate_n;		/* internal state number info */
 | 
			
		||||
	goto TclDatestack;	/* moved from 6 lines above to here to please C++ */
 | 
			
		||||
 | 
			
		||||
		/*
 | 
			
		||||
| 
						 | 
				
			
			@ -1118,7 +1118,7 @@ int TclDateparse()
 | 
			
		|||
		*/
 | 
			
		||||
		if ( TclDatedebug )
 | 
			
		||||
		{
 | 
			
		||||
			register int TclDate_i;
 | 
			
		||||
			int TclDate_i;
 | 
			
		||||
 | 
			
		||||
			printf( "State %d, token ", TclDate_state );
 | 
			
		||||
			if ( TclDatechar == 0 )
 | 
			
		||||
| 
						 | 
				
			
			@ -1202,7 +1202,7 @@ int TclDateparse()
 | 
			
		|||
#if YYDEBUG
 | 
			
		||||
		if ( TclDatedebug && TclDatetmp )
 | 
			
		||||
		{
 | 
			
		||||
			register int TclDate_i;
 | 
			
		||||
			int TclDate_i;
 | 
			
		||||
 | 
			
		||||
			printf( "Received token " );
 | 
			
		||||
			if ( TclDatechar == 0 )
 | 
			
		||||
| 
						 | 
				
			
			@ -1244,7 +1244,7 @@ int TclDateparse()
 | 
			
		|||
#if YYDEBUG
 | 
			
		||||
			if ( TclDatedebug && TclDatetmp )
 | 
			
		||||
			{
 | 
			
		||||
				register int TclDate_i;
 | 
			
		||||
				int TclDate_i;
 | 
			
		||||
 | 
			
		||||
				printf( "Received token " );
 | 
			
		||||
				if ( TclDatechar == 0 )
 | 
			
		||||
| 
						 | 
				
			
			@ -1271,7 +1271,7 @@ int TclDateparse()
 | 
			
		|||
			** look through exception table
 | 
			
		||||
			*/
 | 
			
		||||
			{
 | 
			
		||||
				register int *TclDatexi = TclDateexca;
 | 
			
		||||
				int *TclDatexi = TclDateexca;
 | 
			
		||||
 | 
			
		||||
				while ( ( *TclDatexi != -1 ) ||
 | 
			
		||||
					( TclDatexi[1] != TclDate_state ) )
 | 
			
		||||
| 
						 | 
				
			
			@ -1356,7 +1356,7 @@ int TclDateparse()
 | 
			
		|||
				*/
 | 
			
		||||
				if ( TclDatedebug )
 | 
			
		||||
				{
 | 
			
		||||
					register int TclDate_i;
 | 
			
		||||
					int TclDate_i;
 | 
			
		||||
 | 
			
		||||
					printf( "Error recovery discards " );
 | 
			
		||||
					if ( TclDatechar == 0 )
 | 
			
		||||
| 
						 | 
				
			
			@ -1416,7 +1416,7 @@ int TclDateparse()
 | 
			
		|||
		*/
 | 
			
		||||
		{
 | 
			
		||||
			/* length of production doubled with extra bit */
 | 
			
		||||
			register int TclDate_len = TclDater2[ TclDate_n ];
 | 
			
		||||
			int TclDate_len = TclDater2[ TclDate_n ];
 | 
			
		||||
 | 
			
		||||
			if ( !( TclDate_len & 01 ) )
 | 
			
		||||
			{
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -196,7 +196,7 @@ FindVariable(
 | 
			
		|||
)
 | 
			
		||||
{
 | 
			
		||||
    int i;
 | 
			
		||||
    register CONST char *p1, *p2;
 | 
			
		||||
    CONST char *p1, *p2;
 | 
			
		||||
 | 
			
		||||
    for (i = 0, p1 = environ[i]; p1 != NULL; i++, p1 = environ[i]) {
 | 
			
		||||
	for (p2 = name; *p2 == *p1; p1++, p2++) {
 | 
			
		||||
| 
						 | 
				
			
			@ -518,7 +518,7 @@ EnvTraceProc(
 | 
			
		|||
     */
 | 
			
		||||
 | 
			
		||||
    if (name2 == NULL) {
 | 
			
		||||
	register EnvInterp *eiPtr, *prevPtr;
 | 
			
		||||
	EnvInterp *eiPtr, *prevPtr;
 | 
			
		||||
 | 
			
		||||
	if ((flags & (TCL_TRACE_UNSETS|TCL_TRACE_DESTROYED))
 | 
			
		||||
		!= (TCL_TRACE_UNSETS|TCL_TRACE_DESTROYED)) {
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -340,7 +340,7 @@ Tcl_CreateFileHandler(
 | 
			
		|||
    ClientData clientData	/* Arbitrary data to pass to proc. */
 | 
			
		||||
)
 | 
			
		||||
{
 | 
			
		||||
    register FileHandler *filePtr;
 | 
			
		||||
    FileHandler *filePtr;
 | 
			
		||||
 | 
			
		||||
    if (!fileEventSourceCreated) {
 | 
			
		||||
	fileEventSourceCreated = 1;
 | 
			
		||||
| 
						 | 
				
			
			@ -647,7 +647,7 @@ Tcl_CreateTimerHandler(
 | 
			
		|||
    ClientData clientData	/* Arbitrary data to pass to proc. */
 | 
			
		||||
)
 | 
			
		||||
{
 | 
			
		||||
    register TimerHandler *timerHandlerPtr, *tPtr2, *prevPtr;
 | 
			
		||||
    TimerHandler *timerHandlerPtr, *tPtr2, *prevPtr;
 | 
			
		||||
    static int id = 0;
 | 
			
		||||
 | 
			
		||||
    if (!timerEventSourceCreated) {
 | 
			
		||||
| 
						 | 
				
			
			@ -727,7 +727,7 @@ Tcl_DeleteTimerHandler(
 | 
			
		|||
				 * Tcl_DeleteTimerHandler. */
 | 
			
		||||
)
 | 
			
		||||
{
 | 
			
		||||
    register TimerHandler *timerHandlerPtr, *prevPtr;
 | 
			
		||||
    TimerHandler *timerHandlerPtr, *prevPtr;
 | 
			
		||||
 | 
			
		||||
    for (timerHandlerPtr = firstTimerHandlerPtr, prevPtr = NULL;
 | 
			
		||||
	    timerHandlerPtr != NULL; prevPtr = timerHandlerPtr,
 | 
			
		||||
| 
						 | 
				
			
			@ -1102,7 +1102,7 @@ Tcl_DoWhenIdle(
 | 
			
		|||
    ClientData clientData	/* Arbitrary value to pass to proc. */
 | 
			
		||||
)
 | 
			
		||||
{
 | 
			
		||||
    register IdleHandler *idlePtr;
 | 
			
		||||
    IdleHandler *idlePtr;
 | 
			
		||||
 | 
			
		||||
    idlePtr = (IdleHandler *) ckalloc(sizeof(IdleHandler));
 | 
			
		||||
    idlePtr->proc = proc;
 | 
			
		||||
| 
						 | 
				
			
			@ -1141,7 +1141,7 @@ Tcl_CancelIdleCall(
 | 
			
		|||
    ClientData clientData	/* Arbitrary value to pass to proc. */
 | 
			
		||||
)
 | 
			
		||||
{
 | 
			
		||||
    register IdleHandler *idlePtr, *prevPtr;
 | 
			
		||||
    IdleHandler *idlePtr, *prevPtr;
 | 
			
		||||
    IdleHandler *nextPtr;
 | 
			
		||||
 | 
			
		||||
    for (prevPtr = NULL, idlePtr = idleList; idlePtr != NULL;
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -458,14 +458,14 @@ static int
 | 
			
		|||
ExprLex(
 | 
			
		||||
    Tcl_Interp *interp,			/* Interpreter to use for error
 | 
			
		||||
					 * reporting. */
 | 
			
		||||
    register ExprInfo *infoPtr,		/* Describes the state of the parse. */
 | 
			
		||||
    register Value *valuePtr		/* Where to store value, if that is
 | 
			
		||||
    ExprInfo *infoPtr,		/* Describes the state of the parse. */
 | 
			
		||||
    Value *valuePtr		/* Where to store value, if that is
 | 
			
		||||
					 * what's parsed from string.  Caller
 | 
			
		||||
					 * must have initialized pv field
 | 
			
		||||
					 * correctly. */
 | 
			
		||||
)
 | 
			
		||||
{
 | 
			
		||||
    register char *p;
 | 
			
		||||
    char *p;
 | 
			
		||||
    char *var, *term;
 | 
			
		||||
    int result;
 | 
			
		||||
 | 
			
		||||
| 
						 | 
				
			
			@ -736,7 +736,7 @@ static int
 | 
			
		|||
ExprGetValue(
 | 
			
		||||
   Tcl_Interp *interp,			/* Interpreter to use for error
 | 
			
		||||
					 * reporting. */
 | 
			
		||||
    register ExprInfo *infoPtr,		/* Describes the state of the parse
 | 
			
		||||
    ExprInfo *infoPtr,		/* Describes the state of the parse
 | 
			
		||||
					 * just before the value (i.e. ExprLex
 | 
			
		||||
					 * will be called to get first token
 | 
			
		||||
					 * of value). */
 | 
			
		||||
| 
						 | 
				
			
			@ -1345,7 +1345,7 @@ static void
 | 
			
		|||
ExprMakeString(
 | 
			
		||||
    Tcl_Interp *interp,			/* Interpreter to use for precision
 | 
			
		||||
					 * information. */
 | 
			
		||||
    register Value *valuePtr		/* Value to be converted. */
 | 
			
		||||
    Value *valuePtr		/* Value to be converted. */
 | 
			
		||||
)
 | 
			
		||||
{
 | 
			
		||||
    int shortfall;
 | 
			
		||||
| 
						 | 
				
			
			@ -1678,11 +1678,11 @@ static int
 | 
			
		|||
ExprMathFunc(
 | 
			
		||||
    Tcl_Interp *interp,			/* Interpreter to use for error
 | 
			
		||||
					 * reporting. */
 | 
			
		||||
    register ExprInfo *infoPtr,		/* Describes the state of the parse.
 | 
			
		||||
    ExprInfo *infoPtr,		/* Describes the state of the parse.
 | 
			
		||||
					 * infoPtr->expr must point to the
 | 
			
		||||
					 * first character of the function's
 | 
			
		||||
					 * name. */
 | 
			
		||||
    register Value *valuePtr		/* Where to store value, if that is
 | 
			
		||||
    Value *valuePtr		/* Where to store value, if that is
 | 
			
		||||
					 * what's parsed from string.  Caller
 | 
			
		||||
					 * must have initialized pv field
 | 
			
		||||
					 * correctly. */
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -947,7 +947,7 @@ Tcl_TranslateFileName(
 | 
			
		|||
				 * not even be initialized. */
 | 
			
		||||
)
 | 
			
		||||
{
 | 
			
		||||
    register char *p;
 | 
			
		||||
    char *p;
 | 
			
		||||
 | 
			
		||||
    /*
 | 
			
		||||
     * Handle tilde substitutions, if needed.
 | 
			
		||||
| 
						 | 
				
			
			@ -1301,7 +1301,7 @@ SkipToChar(
 | 
			
		|||
)
 | 
			
		||||
{
 | 
			
		||||
    int quoted, level;
 | 
			
		||||
    register char *p;
 | 
			
		||||
    char *p;
 | 
			
		||||
 | 
			
		||||
    quoted = 0;
 | 
			
		||||
    level = 0;
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -100,7 +100,7 @@ static Tcl_HashEntry *	OneWordCreate _ANSI_ARGS_((Tcl_HashTable *tablePtr,
 | 
			
		|||
 | 
			
		||||
void
 | 
			
		||||
Tcl_InitHashTable(
 | 
			
		||||
    register Tcl_HashTable *tablePtr,	/* Pointer to table record, which
 | 
			
		||||
    Tcl_HashTable *tablePtr,	/* Pointer to table record, which
 | 
			
		||||
					 * is supplied by the caller. */
 | 
			
		||||
    int keyType				/* Type of keys to use in table:
 | 
			
		||||
					 * TCL_STRING_KEYS, TCL_ONE_WORD_KEYS,
 | 
			
		||||
| 
						 | 
				
			
			@ -152,7 +152,7 @@ Tcl_DeleteHashEntry(
 | 
			
		|||
    Tcl_HashEntry *entryPtr
 | 
			
		||||
)
 | 
			
		||||
{
 | 
			
		||||
    register Tcl_HashEntry *prevPtr;
 | 
			
		||||
    Tcl_HashEntry *prevPtr;
 | 
			
		||||
 | 
			
		||||
    if (*entryPtr->bucketPtr == entryPtr) {
 | 
			
		||||
	*entryPtr->bucketPtr = entryPtr->nextPtr;
 | 
			
		||||
| 
						 | 
				
			
			@ -190,10 +190,10 @@ Tcl_DeleteHashEntry(
 | 
			
		|||
 | 
			
		||||
void
 | 
			
		||||
Tcl_DeleteHashTable(
 | 
			
		||||
    register Tcl_HashTable *tablePtr		/* Table to delete. */
 | 
			
		||||
    Tcl_HashTable *tablePtr		/* Table to delete. */
 | 
			
		||||
)
 | 
			
		||||
{
 | 
			
		||||
    register Tcl_HashEntry *hPtr, *nextPtr;
 | 
			
		||||
    Tcl_HashEntry *hPtr, *nextPtr;
 | 
			
		||||
    int i;
 | 
			
		||||
 | 
			
		||||
    /*
 | 
			
		||||
| 
						 | 
				
			
			@ -282,7 +282,7 @@ Tcl_FirstHashEntry(
 | 
			
		|||
 | 
			
		||||
Tcl_HashEntry *
 | 
			
		||||
Tcl_NextHashEntry(
 | 
			
		||||
    register Tcl_HashSearch *searchPtr	/* Place to store information about
 | 
			
		||||
    Tcl_HashSearch *searchPtr	/* Place to store information about
 | 
			
		||||
					 * progress through the table.  Must
 | 
			
		||||
					 * have been initialized by calling
 | 
			
		||||
					 * Tcl_FirstHashEntry. */
 | 
			
		||||
| 
						 | 
				
			
			@ -330,7 +330,7 @@ Tcl_HashStats(
 | 
			
		|||
#define NUM_COUNTERS 10
 | 
			
		||||
    int count[NUM_COUNTERS], overflow, i, j;
 | 
			
		||||
    double average, tmp;
 | 
			
		||||
    register Tcl_HashEntry *hPtr;
 | 
			
		||||
    Tcl_HashEntry *hPtr;
 | 
			
		||||
    char *result, *p;
 | 
			
		||||
 | 
			
		||||
    /*
 | 
			
		||||
| 
						 | 
				
			
			@ -396,11 +396,11 @@ Tcl_HashStats(
 | 
			
		|||
 | 
			
		||||
static unsigned int
 | 
			
		||||
HashString(
 | 
			
		||||
    register char *string	/* String from which to compute hash value. */
 | 
			
		||||
    char *string	/* String from which to compute hash value. */
 | 
			
		||||
)
 | 
			
		||||
{
 | 
			
		||||
    register unsigned int result;
 | 
			
		||||
    register int c;
 | 
			
		||||
    unsigned int result;
 | 
			
		||||
    int c;
 | 
			
		||||
 | 
			
		||||
    /*
 | 
			
		||||
     * I tried a zillion different hash functions and asked many other
 | 
			
		||||
| 
						 | 
				
			
			@ -454,8 +454,8 @@ StringFind(
 | 
			
		|||
    char *key			/* Key to use to find matching entry. */
 | 
			
		||||
)
 | 
			
		||||
{
 | 
			
		||||
    register Tcl_HashEntry *hPtr;
 | 
			
		||||
    register char *p1, *p2;
 | 
			
		||||
    Tcl_HashEntry *hPtr;
 | 
			
		||||
    char *p1, *p2;
 | 
			
		||||
    int index;
 | 
			
		||||
 | 
			
		||||
    index = HashString(key) & tablePtr->mask;
 | 
			
		||||
| 
						 | 
				
			
			@ -508,8 +508,8 @@ StringCreate(
 | 
			
		|||
				 * entry was created. */
 | 
			
		||||
)
 | 
			
		||||
{
 | 
			
		||||
    register Tcl_HashEntry *hPtr;
 | 
			
		||||
    register char *p1, *p2;
 | 
			
		||||
    Tcl_HashEntry *hPtr;
 | 
			
		||||
    char *p1, *p2;
 | 
			
		||||
    int index;
 | 
			
		||||
 | 
			
		||||
    index = HashString(key) & tablePtr->mask;
 | 
			
		||||
| 
						 | 
				
			
			@ -578,10 +578,10 @@ StringCreate(
 | 
			
		|||
static Tcl_HashEntry *
 | 
			
		||||
OneWordFind(
 | 
			
		||||
    Tcl_HashTable *tablePtr,	/* Table in which to lookup entry. */
 | 
			
		||||
    register char *key		/* Key to use to find matching entry. */
 | 
			
		||||
    char *key		/* Key to use to find matching entry. */
 | 
			
		||||
)
 | 
			
		||||
{
 | 
			
		||||
    register Tcl_HashEntry *hPtr;
 | 
			
		||||
    Tcl_HashEntry *hPtr;
 | 
			
		||||
    int index;
 | 
			
		||||
 | 
			
		||||
    index = RANDOM_INDEX(tablePtr, key);
 | 
			
		||||
| 
						 | 
				
			
			@ -623,13 +623,13 @@ OneWordFind(
 | 
			
		|||
static Tcl_HashEntry *
 | 
			
		||||
OneWordCreate(
 | 
			
		||||
    Tcl_HashTable *tablePtr,	/* Table in which to lookup entry. */
 | 
			
		||||
    register char *key,		/* Key to use to find or create matching
 | 
			
		||||
    char *key,		/* Key to use to find or create matching
 | 
			
		||||
				 * entry. */
 | 
			
		||||
    int *newPtr			/* Store info here telling whether a new
 | 
			
		||||
				 * entry was created. */
 | 
			
		||||
)
 | 
			
		||||
{
 | 
			
		||||
    register Tcl_HashEntry *hPtr;
 | 
			
		||||
    Tcl_HashEntry *hPtr;
 | 
			
		||||
    int index;
 | 
			
		||||
 | 
			
		||||
    index = RANDOM_INDEX(tablePtr, key);
 | 
			
		||||
| 
						 | 
				
			
			@ -695,9 +695,9 @@ ArrayFind(
 | 
			
		|||
    char *key			/* Key to use to find matching entry. */
 | 
			
		||||
)
 | 
			
		||||
{
 | 
			
		||||
    register Tcl_HashEntry *hPtr;
 | 
			
		||||
    Tcl_HashEntry *hPtr;
 | 
			
		||||
    int *arrayPtr = (int *) key;
 | 
			
		||||
    register int *iPtr1, *iPtr2;
 | 
			
		||||
    int *iPtr1, *iPtr2;
 | 
			
		||||
    int index, count;
 | 
			
		||||
 | 
			
		||||
    for (index = 0, count = tablePtr->keyType, iPtr1 = arrayPtr;
 | 
			
		||||
| 
						 | 
				
			
			@ -749,15 +749,15 @@ ArrayFind(
 | 
			
		|||
static Tcl_HashEntry *
 | 
			
		||||
ArrayCreate(
 | 
			
		||||
    Tcl_HashTable *tablePtr,	/* Table in which to lookup entry. */
 | 
			
		||||
    register char *key,		/* Key to use to find or create matching
 | 
			
		||||
    char *key,		/* Key to use to find or create matching
 | 
			
		||||
				 * entry. */
 | 
			
		||||
    int *newPtr			/* Store info here telling whether a new
 | 
			
		||||
				 * entry was created. */
 | 
			
		||||
)
 | 
			
		||||
{
 | 
			
		||||
    register Tcl_HashEntry *hPtr;
 | 
			
		||||
    Tcl_HashEntry *hPtr;
 | 
			
		||||
    int *arrayPtr = (int *) key;
 | 
			
		||||
    register int *iPtr1, *iPtr2;
 | 
			
		||||
    int *iPtr1, *iPtr2;
 | 
			
		||||
    int index, count;
 | 
			
		||||
 | 
			
		||||
    for (index = 0, count = tablePtr->keyType, iPtr1 = arrayPtr;
 | 
			
		||||
| 
						 | 
				
			
			@ -896,13 +896,13 @@ BogusCreate(
 | 
			
		|||
 | 
			
		||||
static void
 | 
			
		||||
RebuildTable(
 | 
			
		||||
    register Tcl_HashTable *tablePtr	/* Table to enlarge. */
 | 
			
		||||
    Tcl_HashTable *tablePtr	/* Table to enlarge. */
 | 
			
		||||
)
 | 
			
		||||
{
 | 
			
		||||
    int oldSize, count, index;
 | 
			
		||||
    Tcl_HashEntry **oldBuckets;
 | 
			
		||||
    register Tcl_HashEntry **oldChainPtr, **newChainPtr;
 | 
			
		||||
    register Tcl_HashEntry *hPtr;
 | 
			
		||||
    Tcl_HashEntry **oldChainPtr, **newChainPtr;
 | 
			
		||||
    Tcl_HashEntry *hPtr;
 | 
			
		||||
 | 
			
		||||
    oldSize = tablePtr->numBuckets;
 | 
			
		||||
    oldBuckets = tablePtr->buckets;
 | 
			
		||||
| 
						 | 
				
			
			@ -935,7 +935,7 @@ RebuildTable(
 | 
			
		|||
	    } else if (tablePtr->keyType == TCL_ONE_WORD_KEYS) {
 | 
			
		||||
		index = RANDOM_INDEX(tablePtr, hPtr->key.oneWordValue);
 | 
			
		||||
	    } else {
 | 
			
		||||
		register int *iPtr;
 | 
			
		||||
		int *iPtr;
 | 
			
		||||
		int count;
 | 
			
		||||
 | 
			
		||||
		for (index = 0, count = tablePtr->keyType,
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -139,7 +139,7 @@ static int		SubsAndEval _ANSI_ARGS_((Interp *iPtr, char *cmd,
 | 
			
		|||
 | 
			
		||||
static void
 | 
			
		||||
InitHistory(
 | 
			
		||||
    register Interp *iPtr		/* Interpreter to initialize. */
 | 
			
		||||
    Interp *iPtr		/* Interpreter to initialize. */
 | 
			
		||||
)
 | 
			
		||||
{
 | 
			
		||||
    int i;
 | 
			
		||||
| 
						 | 
				
			
			@ -193,8 +193,8 @@ Tcl_RecordAndEval(
 | 
			
		|||
				 * instead of Tcl_Eval. */
 | 
			
		||||
)
 | 
			
		||||
{
 | 
			
		||||
    register Interp *iPtr = (Interp *) interp;
 | 
			
		||||
    register HistoryEvent *eventPtr;
 | 
			
		||||
    Interp *iPtr = (Interp *) interp;
 | 
			
		||||
    HistoryEvent *eventPtr;
 | 
			
		||||
    int length, result;
 | 
			
		||||
 | 
			
		||||
    if (iPtr->numEvents == 0) {
 | 
			
		||||
| 
						 | 
				
			
			@ -282,8 +282,8 @@ Tcl_HistoryCmd(
 | 
			
		|||
    char **argv				/* Argument strings. */
 | 
			
		||||
)
 | 
			
		||||
{
 | 
			
		||||
    register Interp *iPtr = (Interp *) interp;
 | 
			
		||||
    register HistoryEvent *eventPtr;
 | 
			
		||||
    Interp *iPtr = (Interp *) interp;
 | 
			
		||||
    HistoryEvent *eventPtr;
 | 
			
		||||
    size_t length;
 | 
			
		||||
    int c;
 | 
			
		||||
 | 
			
		||||
| 
						 | 
				
			
			@ -591,11 +591,11 @@ MakeSpace(
 | 
			
		|||
static void
 | 
			
		||||
InsertRev(
 | 
			
		||||
    Interp *iPtr,			/* Interpreter to use. */
 | 
			
		||||
    register HistoryRev *revPtr		/* Revision to add to iPtr's list. */
 | 
			
		||||
    HistoryRev *revPtr		/* Revision to add to iPtr's list. */
 | 
			
		||||
)
 | 
			
		||||
{
 | 
			
		||||
    register HistoryRev *curPtr;
 | 
			
		||||
    register HistoryRev *prevPtr;
 | 
			
		||||
    HistoryRev *curPtr;
 | 
			
		||||
    HistoryRev *prevPtr;
 | 
			
		||||
 | 
			
		||||
    for (curPtr = iPtr->revPtr, prevPtr = NULL; curPtr != NULL;
 | 
			
		||||
	    prevPtr = curPtr, curPtr = curPtr->nextPtr) {
 | 
			
		||||
| 
						 | 
				
			
			@ -659,12 +659,12 @@ InsertRev(
 | 
			
		|||
 | 
			
		||||
static void
 | 
			
		||||
RevCommand(
 | 
			
		||||
    register Interp *iPtr,	/* Interpreter in which to perform the
 | 
			
		||||
    Interp *iPtr,	/* Interpreter in which to perform the
 | 
			
		||||
				 * substitution. */
 | 
			
		||||
    char *string		/* String to substitute. */
 | 
			
		||||
)
 | 
			
		||||
{
 | 
			
		||||
    register HistoryRev *revPtr;
 | 
			
		||||
    HistoryRev *revPtr;
 | 
			
		||||
 | 
			
		||||
    if ((iPtr->evalFirst == NULL) || (iPtr->revDisables > 0)) {
 | 
			
		||||
	return;
 | 
			
		||||
| 
						 | 
				
			
			@ -698,12 +698,12 @@ RevCommand(
 | 
			
		|||
 | 
			
		||||
static void
 | 
			
		||||
RevResult(
 | 
			
		||||
    register Interp *iPtr,	/* Interpreter in which to perform the
 | 
			
		||||
    Interp *iPtr,	/* Interpreter in which to perform the
 | 
			
		||||
				 * substitution. */
 | 
			
		||||
    char *string		/* String to substitute. */
 | 
			
		||||
)
 | 
			
		||||
{
 | 
			
		||||
    register HistoryRev *revPtr;
 | 
			
		||||
    HistoryRev *revPtr;
 | 
			
		||||
    char *evalFirst, *evalLast;
 | 
			
		||||
    char *argv[2];
 | 
			
		||||
 | 
			
		||||
| 
						 | 
				
			
			@ -765,12 +765,12 @@ RevResult(
 | 
			
		|||
 | 
			
		||||
static void
 | 
			
		||||
DoRevs(
 | 
			
		||||
    register Interp *iPtr	/* Interpreter whose history is to
 | 
			
		||||
    Interp *iPtr	/* Interpreter whose history is to
 | 
			
		||||
				 * be modified. */
 | 
			
		||||
)
 | 
			
		||||
{
 | 
			
		||||
    register HistoryRev *revPtr;
 | 
			
		||||
    register HistoryEvent *eventPtr;
 | 
			
		||||
    HistoryRev *revPtr;
 | 
			
		||||
    HistoryEvent *eventPtr;
 | 
			
		||||
    char *newCommand, *p;
 | 
			
		||||
    unsigned int size;
 | 
			
		||||
    int bytesSeen, count;
 | 
			
		||||
| 
						 | 
				
			
			@ -844,12 +844,12 @@ DoRevs(
 | 
			
		|||
 | 
			
		||||
static HistoryEvent *
 | 
			
		||||
GetEvent(
 | 
			
		||||
    register Interp *iPtr,	/* Interpreter in which to look. */
 | 
			
		||||
    Interp *iPtr,	/* Interpreter in which to look. */
 | 
			
		||||
    char *string		/* Description of event. */
 | 
			
		||||
)
 | 
			
		||||
{
 | 
			
		||||
    int eventNum, index;
 | 
			
		||||
    register HistoryEvent *eventPtr;
 | 
			
		||||
    HistoryEvent *eventPtr;
 | 
			
		||||
    int length;
 | 
			
		||||
 | 
			
		||||
    /*
 | 
			
		||||
| 
						 | 
				
			
			@ -927,7 +927,7 @@ GetEvent(
 | 
			
		|||
 | 
			
		||||
static int
 | 
			
		||||
SubsAndEval(
 | 
			
		||||
    register Interp *iPtr,	/* Interpreter in which to execute
 | 
			
		||||
    Interp *iPtr,	/* Interpreter in which to execute
 | 
			
		||||
				 * new command. */
 | 
			
		||||
    char *cmd,			/* Command in which to substitute. */
 | 
			
		||||
    char *old,			/* String to search for in command. */
 | 
			
		||||
| 
						 | 
				
			
			@ -1010,7 +1010,7 @@ SubsAndEval(
 | 
			
		|||
 | 
			
		||||
static char *
 | 
			
		||||
GetWords(
 | 
			
		||||
    register Interp *iPtr,	/* Tcl interpreter in which to place
 | 
			
		||||
    Interp *iPtr,	/* Tcl interpreter in which to place
 | 
			
		||||
				 * an error message if needed. */
 | 
			
		||||
    char *command,		/* Command string. */
 | 
			
		||||
    char *words			/* Description of which words to extract
 | 
			
		||||
| 
						 | 
				
			
			@ -1020,7 +1020,7 @@ GetWords(
 | 
			
		|||
{
 | 
			
		||||
    char *result;
 | 
			
		||||
    char *start, *end, *dst;
 | 
			
		||||
    register char *next;
 | 
			
		||||
    char *next;
 | 
			
		||||
    int first;			/* First word desired. -1 means last word
 | 
			
		||||
				 * only. */
 | 
			
		||||
    int last;			/* Last word desired.  -1 means use everything
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -92,7 +92,7 @@ static Tcl_File
 | 
			
		|||
FileForRedirect(
 | 
			
		||||
    Tcl_Interp *interp,			/* Intepreter to use for error
 | 
			
		||||
					 * reporting. */
 | 
			
		||||
    register char *spec,			/* Points to character just after
 | 
			
		||||
    char *spec,			/* Points to character just after
 | 
			
		||||
					 * redirection character. */
 | 
			
		||||
    int atOk,				/* Non-zero means '@' notation is
 | 
			
		||||
					 * OK, zero means it isn't. */
 | 
			
		||||
| 
						 | 
				
			
			@ -487,7 +487,7 @@ Tcl_DetachPids(
 | 
			
		|||
    pid_t *pidPtr		/* Array of pids to detach. */
 | 
			
		||||
)
 | 
			
		||||
{
 | 
			
		||||
    register Detached *detPtr;
 | 
			
		||||
    Detached *detPtr;
 | 
			
		||||
    int i;
 | 
			
		||||
 | 
			
		||||
    for (i = 0; i < numPids; i++) {
 | 
			
		||||
| 
						 | 
				
			
			@ -521,7 +521,7 @@ Tcl_DetachPids(
 | 
			
		|||
void
 | 
			
		||||
Tcl_ReapDetachedProcs(void)
 | 
			
		||||
{
 | 
			
		||||
    register Detached *detPtr;
 | 
			
		||||
    Detached *detPtr;
 | 
			
		||||
    Detached *nextPtr, *prevPtr;
 | 
			
		||||
    int status;
 | 
			
		||||
    pid_t pid;
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -199,7 +199,7 @@ Tcl_Backslash(
 | 
			
		|||
				 * from src, unless NULL. */
 | 
			
		||||
)
 | 
			
		||||
{
 | 
			
		||||
    register char *p = src+1;
 | 
			
		||||
    char *p = src+1;
 | 
			
		||||
    char result;
 | 
			
		||||
    int count;
 | 
			
		||||
 | 
			
		||||
| 
						 | 
				
			
			@ -323,7 +323,7 @@ TclParseQuotes(
 | 
			
		|||
				 * fully-substituted result of parse. */
 | 
			
		||||
)
 | 
			
		||||
{
 | 
			
		||||
    register char *src, *dst, c;
 | 
			
		||||
    char *src, *dst, c;
 | 
			
		||||
 | 
			
		||||
    src = string;
 | 
			
		||||
    dst = pvPtr->next;
 | 
			
		||||
| 
						 | 
				
			
			@ -435,7 +435,7 @@ TclParseNestedCmd(
 | 
			
		|||
    int flags,			/* Flags to pass to nested Tcl_Eval. */
 | 
			
		||||
    char **termPtr,		/* Store address of terminating character
 | 
			
		||||
				 * here. */
 | 
			
		||||
    register ParseValue *pvPtr	/* Information about where to place
 | 
			
		||||
    ParseValue *pvPtr	/* Information about where to place
 | 
			
		||||
				 * result of command. */
 | 
			
		||||
)
 | 
			
		||||
{
 | 
			
		||||
| 
						 | 
				
			
			@ -503,13 +503,13 @@ TclParseBraces(
 | 
			
		|||
    char *string,		/* Character just after opening bracket. */
 | 
			
		||||
    char **termPtr,		/* Store address of terminating character
 | 
			
		||||
				* here. */
 | 
			
		||||
    register ParseValue *pvPtr	/* Information about where to place
 | 
			
		||||
    ParseValue *pvPtr	/* Information about where to place
 | 
			
		||||
				 * result of command. */
 | 
			
		||||
)
 | 
			
		||||
{
 | 
			
		||||
    int level;
 | 
			
		||||
    register char *src, *dst, *end;
 | 
			
		||||
    register char c;
 | 
			
		||||
    char *src, *dst, *end;
 | 
			
		||||
    char c;
 | 
			
		||||
 | 
			
		||||
    src = string;
 | 
			
		||||
    dst = pvPtr->next;
 | 
			
		||||
| 
						 | 
				
			
			@ -636,12 +636,12 @@ TclParseWords(
 | 
			
		|||
    int *argcPtr,		/* Filled in with actual number of words
 | 
			
		||||
				 * parsed. */
 | 
			
		||||
    char **argv,		/* Store addresses of individual words here. */
 | 
			
		||||
    register ParseValue *pvPtr	/* Information about where to place
 | 
			
		||||
    ParseValue *pvPtr	/* Information about where to place
 | 
			
		||||
				 * fully-substituted word. */
 | 
			
		||||
)
 | 
			
		||||
{
 | 
			
		||||
    register char *src, *dst;
 | 
			
		||||
    register char c;
 | 
			
		||||
    char *src, *dst;
 | 
			
		||||
    char c;
 | 
			
		||||
    int type, result, argc;
 | 
			
		||||
    char *oldBuffer;		/* Used to detect when pvPtr's buffer gets
 | 
			
		||||
				 * reallocated, so we can adjust all of the
 | 
			
		||||
| 
						 | 
				
			
			@ -881,7 +881,7 @@ TclParseWords(
 | 
			
		|||
 | 
			
		||||
void
 | 
			
		||||
TclExpandParseValue(
 | 
			
		||||
    register ParseValue *pvPtr,		/* Information about buffer that
 | 
			
		||||
    ParseValue *pvPtr,		/* Information about buffer that
 | 
			
		||||
					 * must be expanded.  If the clientData
 | 
			
		||||
					 * in the structure is non-zero, it
 | 
			
		||||
					 * means that the current buffer is
 | 
			
		||||
| 
						 | 
				
			
			@ -953,7 +953,7 @@ TclWordEnd(
 | 
			
		|||
				 * If NULL then ignored. */
 | 
			
		||||
)
 | 
			
		||||
{
 | 
			
		||||
    register char *p;
 | 
			
		||||
    char *p;
 | 
			
		||||
    int count;
 | 
			
		||||
 | 
			
		||||
    if (semiPtr != NULL) {
 | 
			
		||||
| 
						 | 
				
			
			@ -1100,7 +1100,7 @@ QuoteEnd(
 | 
			
		|||
				 * quoted string (e.g. '"' or ')'). */
 | 
			
		||||
)
 | 
			
		||||
{
 | 
			
		||||
    register char *p = string;
 | 
			
		||||
    char *p = string;
 | 
			
		||||
    int count;
 | 
			
		||||
 | 
			
		||||
    while (*p != term) {
 | 
			
		||||
| 
						 | 
				
			
			@ -1155,7 +1155,7 @@ VarNameEnd(
 | 
			
		|||
    char *string		/* Pointer to dollar-sign character. */
 | 
			
		||||
)
 | 
			
		||||
{
 | 
			
		||||
    register char *p = string+1;
 | 
			
		||||
    char *p = string+1;
 | 
			
		||||
 | 
			
		||||
    if (*p == '{') {
 | 
			
		||||
	for (p++; (*p != '}') && (*p != 0); p++) {
 | 
			
		||||
| 
						 | 
				
			
			@ -1273,7 +1273,7 @@ ScriptEnd(
 | 
			
		|||
char *
 | 
			
		||||
Tcl_ParseVar(
 | 
			
		||||
    Tcl_Interp *interp,			/* Context for looking up variable. */
 | 
			
		||||
    register char *string,		/* String containing variable name.
 | 
			
		||||
    char *string,		/* String containing variable name.
 | 
			
		||||
					 * First character must be "$". */
 | 
			
		||||
    char **termPtr			/* If non-NULL, points to word to fill
 | 
			
		||||
					 * in with character just after last
 | 
			
		||||
| 
						 | 
				
			
			@ -1281,7 +1281,7 @@ Tcl_ParseVar(
 | 
			
		|||
)
 | 
			
		||||
{
 | 
			
		||||
    char *name1, *name1End, c, *result;
 | 
			
		||||
    register char *name2;
 | 
			
		||||
    char *name2;
 | 
			
		||||
#define NUM_CHARS 200
 | 
			
		||||
    char copyStorage[NUM_CHARS];
 | 
			
		||||
    ParseValue pv;
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -73,12 +73,12 @@ Tcl_ProcCmd(
 | 
			
		|||
    char **argv				/* Argument strings. */
 | 
			
		||||
)
 | 
			
		||||
{
 | 
			
		||||
    register Interp *iPtr = (Interp *) interp;
 | 
			
		||||
    register Proc *procPtr;
 | 
			
		||||
    Interp *iPtr = (Interp *) interp;
 | 
			
		||||
    Proc *procPtr;
 | 
			
		||||
    int result, argCount, i;
 | 
			
		||||
    char **argArray = NULL;
 | 
			
		||||
    Arg *lastArgPtr;
 | 
			
		||||
    register Arg *argPtr = NULL;	/* Initialization not needed, but
 | 
			
		||||
    Arg *argPtr = NULL;	/* Initialization not needed, but
 | 
			
		||||
					 * prevents compiler warning. */
 | 
			
		||||
 | 
			
		||||
    if (argc != 4) {
 | 
			
		||||
| 
						 | 
				
			
			@ -210,7 +210,7 @@ TclGetFrame(
 | 
			
		|||
				 * if global frame indicated). */
 | 
			
		||||
)
 | 
			
		||||
{
 | 
			
		||||
    register Interp *iPtr = (Interp *) interp;
 | 
			
		||||
    Interp *iPtr = (Interp *) interp;
 | 
			
		||||
    int curLevel, level, result;
 | 
			
		||||
    CallFrame *framePtr;
 | 
			
		||||
 | 
			
		||||
| 
						 | 
				
			
			@ -288,7 +288,7 @@ Tcl_UplevelCmd(
 | 
			
		|||
    char **argv				/* Argument strings. */
 | 
			
		||||
)
 | 
			
		||||
{
 | 
			
		||||
    register Interp *iPtr = (Interp *) interp;
 | 
			
		||||
    Interp *iPtr = (Interp *) interp;
 | 
			
		||||
    int result;
 | 
			
		||||
    CallFrame *savedVarFramePtr, *framePtr;
 | 
			
		||||
 | 
			
		||||
| 
						 | 
				
			
			@ -443,9 +443,9 @@ InterpProc(
 | 
			
		|||
    char **argv			/* Argument values. */
 | 
			
		||||
)
 | 
			
		||||
{
 | 
			
		||||
    register Proc *procPtr = (Proc *) clientData;
 | 
			
		||||
    register Arg *argPtr;
 | 
			
		||||
    register Interp *iPtr;
 | 
			
		||||
    Proc *procPtr = (Proc *) clientData;
 | 
			
		||||
    Arg *argPtr;
 | 
			
		||||
    Interp *iPtr;
 | 
			
		||||
    char **args;
 | 
			
		||||
    CallFrame frame;
 | 
			
		||||
    char *value;
 | 
			
		||||
| 
						 | 
				
			
			@ -630,10 +630,10 @@ ProcDeleteProc(
 | 
			
		|||
 | 
			
		||||
static void
 | 
			
		||||
CleanupProc(
 | 
			
		||||
    register Proc *procPtr		/* Procedure to be deleted. */
 | 
			
		||||
    Proc *procPtr		/* Procedure to be deleted. */
 | 
			
		||||
)
 | 
			
		||||
{
 | 
			
		||||
    register Arg *argPtr;
 | 
			
		||||
    Arg *argPtr;
 | 
			
		||||
 | 
			
		||||
    ckfree((char *) procPtr->command);
 | 
			
		||||
    for (argPtr = procPtr->argPtr; argPtr != NULL; ) {
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -106,7 +106,7 @@ TclFindElement(
 | 
			
		|||
    Tcl_Interp *interp,		/* Interpreter to use for error reporting. 
 | 
			
		||||
				 * If NULL, then no error message is left
 | 
			
		||||
				 * after errors. */
 | 
			
		||||
    register char *list,	/* String containing Tcl list with zero
 | 
			
		||||
    char *list,	/* String containing Tcl list with zero
 | 
			
		||||
				 * or more elements (possibly in braces). */
 | 
			
		||||
    char **elementPtr,		/* Fill in with location of first significant
 | 
			
		||||
				 * character in first element of list. */
 | 
			
		||||
| 
						 | 
				
			
			@ -121,7 +121,7 @@ TclFindElement(
 | 
			
		|||
				 * in braces. */
 | 
			
		||||
)
 | 
			
		||||
{
 | 
			
		||||
    register char *p;
 | 
			
		||||
    char *p;
 | 
			
		||||
    int openBraces = 0;
 | 
			
		||||
    int inQuotes = 0;
 | 
			
		||||
    int size;
 | 
			
		||||
| 
						 | 
				
			
			@ -316,11 +316,11 @@ void
 | 
			
		|||
TclCopyAndCollapse(
 | 
			
		||||
    int count,			/* Total number of characters to copy
 | 
			
		||||
				 * from src. */
 | 
			
		||||
    register char *src,		/* Copy from here... */
 | 
			
		||||
    register char *dst		/* ... to here. */
 | 
			
		||||
    char *src,		/* Copy from here... */
 | 
			
		||||
    char *dst		/* ... to here. */
 | 
			
		||||
)
 | 
			
		||||
{
 | 
			
		||||
    register char c;
 | 
			
		||||
    char c;
 | 
			
		||||
    int numRead;
 | 
			
		||||
 | 
			
		||||
    for (c = *src; count > 0; src++, c = *src, count--) {
 | 
			
		||||
| 
						 | 
				
			
			@ -379,7 +379,7 @@ Tcl_SplitList(
 | 
			
		|||
)
 | 
			
		||||
{
 | 
			
		||||
    char **argv;
 | 
			
		||||
    register char *p;
 | 
			
		||||
    char *p;
 | 
			
		||||
    int size, i, result, elSize, brace;
 | 
			
		||||
    char *element;
 | 
			
		||||
 | 
			
		||||
| 
						 | 
				
			
			@ -465,7 +465,7 @@ Tcl_ScanElement(
 | 
			
		|||
)
 | 
			
		||||
{
 | 
			
		||||
    int flags, nestingLevel;
 | 
			
		||||
    register char *p;
 | 
			
		||||
    char *p;
 | 
			
		||||
 | 
			
		||||
    /*
 | 
			
		||||
     * This procedure and Tcl_ConvertElement together do two things:
 | 
			
		||||
| 
						 | 
				
			
			@ -582,12 +582,12 @@ Tcl_ScanElement(
 | 
			
		|||
 | 
			
		||||
int
 | 
			
		||||
Tcl_ConvertElement(
 | 
			
		||||
    register char *src,		/* Source information for list element. */
 | 
			
		||||
    char *src,		/* Source information for list element. */
 | 
			
		||||
    char *dst,			/* Place to put list-ified element. */
 | 
			
		||||
    int flags			/* Flags produced by Tcl_ScanElement. */
 | 
			
		||||
)
 | 
			
		||||
{
 | 
			
		||||
    register char *p = dst;
 | 
			
		||||
    char *p = dst;
 | 
			
		||||
 | 
			
		||||
    /*
 | 
			
		||||
     * See the comment block at the beginning of the Tcl_ScanElement
 | 
			
		||||
| 
						 | 
				
			
			@ -721,7 +721,7 @@ Tcl_Merge(
 | 
			
		|||
    int localFlags[LOCAL_SIZE], *flagPtr;
 | 
			
		||||
    int numChars;
 | 
			
		||||
    char *result;
 | 
			
		||||
    register char *dst;
 | 
			
		||||
    char *dst;
 | 
			
		||||
    int i;
 | 
			
		||||
 | 
			
		||||
    /*
 | 
			
		||||
| 
						 | 
				
			
			@ -788,7 +788,7 @@ Tcl_Concat(
 | 
			
		|||
)
 | 
			
		||||
{
 | 
			
		||||
    int totalSize, i;
 | 
			
		||||
    register char *p;
 | 
			
		||||
    char *p;
 | 
			
		||||
    char *result;
 | 
			
		||||
 | 
			
		||||
    for (totalSize = 1, i = 0; i < argc; i++) {
 | 
			
		||||
| 
						 | 
				
			
			@ -855,9 +855,8 @@ Tcl_Concat(
 | 
			
		|||
 | 
			
		||||
int
 | 
			
		||||
Tcl_StringMatch(
 | 
			
		||||
    register char *string,	/* String. */
 | 
			
		||||
    register char *pattern	/* Pattern, which may contain
 | 
			
		||||
				 * special characters. */
 | 
			
		||||
    char *string,	/* String. */
 | 
			
		||||
    char *pattern	/* Pattern, which may contain
 | 
			
		||||
)
 | 
			
		||||
{
 | 
			
		||||
    char c2;
 | 
			
		||||
| 
						 | 
				
			
			@ -1000,7 +999,7 @@ Tcl_SetResult(
 | 
			
		|||
				 * of a Tcl_FreeProc such as free. */
 | 
			
		||||
)
 | 
			
		||||
{
 | 
			
		||||
    register Interp *iPtr = (Interp *) interp;
 | 
			
		||||
    Interp *iPtr = (Interp *) interp;
 | 
			
		||||
    int length;
 | 
			
		||||
    Tcl_FreeProc *oldFreeProc = iPtr->freeProc;
 | 
			
		||||
    char *oldResult = iPtr->result;
 | 
			
		||||
| 
						 | 
				
			
			@ -1067,7 +1066,7 @@ void
 | 
			
		|||
Tcl_AppendResult TCL_VARARGS_DEF(Tcl_Interp *,arg1)
 | 
			
		||||
{
 | 
			
		||||
    va_list argList;
 | 
			
		||||
    register Interp *iPtr;
 | 
			
		||||
    Interp *iPtr;
 | 
			
		||||
    char *string;
 | 
			
		||||
    int newSpace;
 | 
			
		||||
 | 
			
		||||
| 
						 | 
				
			
			@ -1145,7 +1144,7 @@ Tcl_AppendElement(
 | 
			
		|||
				 * add to result. */
 | 
			
		||||
)
 | 
			
		||||
{
 | 
			
		||||
    register Interp *iPtr = (Interp *) interp;
 | 
			
		||||
    Interp *iPtr = (Interp *) interp;
 | 
			
		||||
    int size, flags;
 | 
			
		||||
    char *dst;
 | 
			
		||||
 | 
			
		||||
| 
						 | 
				
			
			@ -1195,7 +1194,7 @@ Tcl_AppendElement(
 | 
			
		|||
 | 
			
		||||
static void
 | 
			
		||||
SetupAppendBuffer(
 | 
			
		||||
    register Interp *iPtr,	/* Interpreter whose result is being set up. */
 | 
			
		||||
    Interp *iPtr,	/* Interpreter whose result is being set up. */
 | 
			
		||||
    int newSpace		/* Make sure that at least this many bytes
 | 
			
		||||
				 * of new information may be added. */
 | 
			
		||||
)
 | 
			
		||||
| 
						 | 
				
			
			@ -1277,7 +1276,7 @@ Tcl_ResetResult(
 | 
			
		|||
    Tcl_Interp *interp		/* Interpreter for which to clear result. */
 | 
			
		||||
)
 | 
			
		||||
{
 | 
			
		||||
    register Interp *iPtr = (Interp *) interp;
 | 
			
		||||
    Interp *iPtr = (Interp *) interp;
 | 
			
		||||
 | 
			
		||||
    Tcl_FreeResult(iPtr);
 | 
			
		||||
    iPtr->result = iPtr->resultSpace;
 | 
			
		||||
| 
						 | 
				
			
			@ -1416,7 +1415,7 @@ Tcl_RegExpCompile(
 | 
			
		|||
					 * compiled regular expression. */
 | 
			
		||||
)
 | 
			
		||||
{
 | 
			
		||||
    register Interp *iPtr = (Interp *) interp;
 | 
			
		||||
    Interp *iPtr = (Interp *) interp;
 | 
			
		||||
    int i, length;
 | 
			
		||||
    regexp *result;
 | 
			
		||||
 | 
			
		||||
| 
						 | 
				
			
			@ -1623,7 +1622,7 @@ Tcl_RegExpMatch(
 | 
			
		|||
 | 
			
		||||
void
 | 
			
		||||
Tcl_DStringInit(
 | 
			
		||||
    register Tcl_DString *dsPtr		/* Pointer to structure for
 | 
			
		||||
    Tcl_DString *dsPtr		/* Pointer to structure for
 | 
			
		||||
					 * dynamic string. */
 | 
			
		||||
)
 | 
			
		||||
{
 | 
			
		||||
| 
						 | 
				
			
			@ -1653,7 +1652,7 @@ Tcl_DStringInit(
 | 
			
		|||
 | 
			
		||||
char *
 | 
			
		||||
Tcl_DStringAppend(
 | 
			
		||||
    register Tcl_DString *dsPtr,	/* Structure describing dynamic
 | 
			
		||||
    Tcl_DString *dsPtr,	/* Structure describing dynamic
 | 
			
		||||
					 * string. */
 | 
			
		||||
    char *string,			/* String to append.  If length is
 | 
			
		||||
					 * -1 then this must be
 | 
			
		||||
| 
						 | 
				
			
			@ -1722,7 +1721,7 @@ Tcl_DStringAppend(
 | 
			
		|||
 | 
			
		||||
char *
 | 
			
		||||
Tcl_DStringAppendElement(
 | 
			
		||||
    register Tcl_DString *dsPtr,	/* Structure describing dynamic
 | 
			
		||||
    Tcl_DString *dsPtr,	/* Structure describing dynamic
 | 
			
		||||
					 * string. */
 | 
			
		||||
    char *string			/* String to append.  Must be
 | 
			
		||||
					 * null-terminated. */
 | 
			
		||||
| 
						 | 
				
			
			@ -1790,7 +1789,7 @@ Tcl_DStringAppendElement(
 | 
			
		|||
 | 
			
		||||
void
 | 
			
		||||
Tcl_DStringSetLength(
 | 
			
		||||
    register Tcl_DString *dsPtr,	/* Structure describing dynamic
 | 
			
		||||
    Tcl_DString *dsPtr,	/* Structure describing dynamic
 | 
			
		||||
					 * string. */
 | 
			
		||||
    int length				/* New length for dynamic string. */
 | 
			
		||||
)
 | 
			
		||||
| 
						 | 
				
			
			@ -1841,7 +1840,7 @@ Tcl_DStringSetLength(
 | 
			
		|||
 | 
			
		||||
void
 | 
			
		||||
Tcl_DStringFree(
 | 
			
		||||
    register Tcl_DString *dsPtr		/* Structure describing dynamic
 | 
			
		||||
    Tcl_DString *dsPtr		/* Structure describing dynamic
 | 
			
		||||
					 * string. */
 | 
			
		||||
)
 | 
			
		||||
{
 | 
			
		||||
| 
						 | 
				
			
			@ -2042,7 +2041,7 @@ Tcl_PrintDouble(
 | 
			
		|||
					 * characters. */
 | 
			
		||||
)
 | 
			
		||||
{
 | 
			
		||||
    register char *p;
 | 
			
		||||
    char *p;
 | 
			
		||||
    sprintf(dst, ((Interp *) interp)->pdFormat, value);
 | 
			
		||||
 | 
			
		||||
    /*
 | 
			
		||||
| 
						 | 
				
			
			@ -2091,7 +2090,7 @@ TclPrecTraceProc(
 | 
			
		|||
    int flags			/* Information about what happened. */
 | 
			
		||||
)
 | 
			
		||||
{
 | 
			
		||||
    register Interp *iPtr = (Interp *) interp;
 | 
			
		||||
    Interp *iPtr = (Interp *) interp;
 | 
			
		||||
    char *value, *end;
 | 
			
		||||
    int prec;
 | 
			
		||||
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -494,8 +494,8 @@ Tcl_SetVar2(
 | 
			
		|||
				 * PART1_NOT_PARSED. */
 | 
			
		||||
)
 | 
			
		||||
{
 | 
			
		||||
    register Var *varPtr;
 | 
			
		||||
    register Interp *iPtr = (Interp *) interp;
 | 
			
		||||
    Var *varPtr;
 | 
			
		||||
    Interp *iPtr = (Interp *) interp;
 | 
			
		||||
    int length, listFlags;
 | 
			
		||||
    Var *arrayPtr;
 | 
			
		||||
    char *result;
 | 
			
		||||
| 
						 | 
				
			
			@ -891,7 +891,7 @@ Tcl_TraceVar2(
 | 
			
		|||
)
 | 
			
		||||
{
 | 
			
		||||
    Var *varPtr, *arrayPtr;
 | 
			
		||||
    register VarTrace *tracePtr;
 | 
			
		||||
    VarTrace *tracePtr;
 | 
			
		||||
 | 
			
		||||
    varPtr = LookupVar(interp, part1, part2, (flags | TCL_LEAVE_ERR_MSG),
 | 
			
		||||
	    "trace", CRT_PART1|CRT_PART2, &arrayPtr);
 | 
			
		||||
| 
						 | 
				
			
			@ -982,7 +982,7 @@ Tcl_UntraceVar2(
 | 
			
		|||
    ClientData clientData	/* Arbitrary argument to pass to proc. */
 | 
			
		||||
)
 | 
			
		||||
{
 | 
			
		||||
    register VarTrace *tracePtr;
 | 
			
		||||
    VarTrace *tracePtr;
 | 
			
		||||
    VarTrace *prevPtr;
 | 
			
		||||
    Var *varPtr, *arrayPtr;
 | 
			
		||||
    Interp *iPtr = (Interp *) interp;
 | 
			
		||||
| 
						 | 
				
			
			@ -1114,7 +1114,7 @@ Tcl_VarTraceInfo2(
 | 
			
		|||
				 * first trace. */
 | 
			
		||||
)
 | 
			
		||||
{
 | 
			
		||||
    register VarTrace *tracePtr;
 | 
			
		||||
    VarTrace *tracePtr;
 | 
			
		||||
    Var *varPtr, *arrayPtr;
 | 
			
		||||
 | 
			
		||||
    varPtr = LookupVar(interp, part1, part2,
 | 
			
		||||
| 
						 | 
				
			
			@ -1167,7 +1167,7 @@ Tcl_VarTraceInfo2(
 | 
			
		|||
int
 | 
			
		||||
Tcl_SetCmd(
 | 
			
		||||
    ClientData dummy,			/* Not used. */
 | 
			
		||||
    register Tcl_Interp *interp,	/* Current interpreter. */
 | 
			
		||||
    Tcl_Interp *interp,	/* Current interpreter. */
 | 
			
		||||
    int argc,				/* Number of arguments. */
 | 
			
		||||
    char **argv				/* Argument strings. */
 | 
			
		||||
)
 | 
			
		||||
| 
						 | 
				
			
			@ -1220,7 +1220,7 @@ Tcl_SetCmd(
 | 
			
		|||
int
 | 
			
		||||
Tcl_UnsetCmd(
 | 
			
		||||
    ClientData dummy,			/* Not used. */
 | 
			
		||||
    register Tcl_Interp *interp,	/* Current interpreter. */
 | 
			
		||||
    Tcl_Interp *interp,	/* Current interpreter. */
 | 
			
		||||
    int argc,				/* Number of arguments. */
 | 
			
		||||
    char **argv				/* Argument strings. */
 | 
			
		||||
)
 | 
			
		||||
| 
						 | 
				
			
			@ -1262,7 +1262,7 @@ Tcl_UnsetCmd(
 | 
			
		|||
int
 | 
			
		||||
Tcl_AppendCmd(
 | 
			
		||||
    ClientData dummy,			/* Not used. */
 | 
			
		||||
    register Tcl_Interp *interp,	/* Current interpreter. */
 | 
			
		||||
    Tcl_Interp *interp,	/* Current interpreter. */
 | 
			
		||||
    int argc,				/* Number of arguments. */
 | 
			
		||||
    char **argv				/* Argument strings. */
 | 
			
		||||
)
 | 
			
		||||
| 
						 | 
				
			
			@ -1318,7 +1318,7 @@ Tcl_AppendCmd(
 | 
			
		|||
int
 | 
			
		||||
Tcl_LappendCmd(
 | 
			
		||||
    ClientData dummy,			/* Not used. */
 | 
			
		||||
    register Tcl_Interp *interp,	/* Current interpreter. */
 | 
			
		||||
    Tcl_Interp *interp,	/* Current interpreter. */
 | 
			
		||||
    int argc,				/* Number of arguments. */
 | 
			
		||||
    char **argv				/* Argument strings. */
 | 
			
		||||
)
 | 
			
		||||
| 
						 | 
				
			
			@ -1375,7 +1375,7 @@ Tcl_LappendCmd(
 | 
			
		|||
int
 | 
			
		||||
Tcl_ArrayCmd(
 | 
			
		||||
    ClientData dummy,			/* Not used. */
 | 
			
		||||
    register Tcl_Interp *interp,	/* Current interpreter. */
 | 
			
		||||
    Tcl_Interp *interp,	/* Current interpreter. */
 | 
			
		||||
    int argc,				/* Number of arguments. */
 | 
			
		||||
    char **argv				/* Argument strings. */
 | 
			
		||||
)
 | 
			
		||||
| 
						 | 
				
			
			@ -1808,7 +1808,7 @@ Tcl_UpVar(
 | 
			
		|||
{
 | 
			
		||||
    int result;
 | 
			
		||||
    CallFrame *framePtr;
 | 
			
		||||
    register char *p;
 | 
			
		||||
    char *p;
 | 
			
		||||
 | 
			
		||||
    result = TclGetFrame(interp, frameName, &framePtr);
 | 
			
		||||
    if (result == -1) {
 | 
			
		||||
| 
						 | 
				
			
			@ -1915,7 +1915,7 @@ Tcl_GlobalCmd(
 | 
			
		|||
    char **argv				/* Argument strings. */
 | 
			
		||||
)
 | 
			
		||||
{
 | 
			
		||||
    register Interp *iPtr = (Interp *) interp;
 | 
			
		||||
    Interp *iPtr = (Interp *) interp;
 | 
			
		||||
 | 
			
		||||
    if (argc < 2) {
 | 
			
		||||
	Tcl_AppendResult((Tcl_Interp *) iPtr, "wrong # args: should be \"",
 | 
			
		||||
| 
						 | 
				
			
			@ -1961,10 +1961,10 @@ Tcl_UpvarCmd(
 | 
			
		|||
    char **argv				/* Argument strings. */
 | 
			
		||||
)
 | 
			
		||||
{
 | 
			
		||||
    register Interp *iPtr = (Interp *) interp;
 | 
			
		||||
    Interp *iPtr = (Interp *) interp;
 | 
			
		||||
    int result;
 | 
			
		||||
    CallFrame *framePtr;
 | 
			
		||||
    register char *p;
 | 
			
		||||
    char *p;
 | 
			
		||||
 | 
			
		||||
    if (argc < 3) {
 | 
			
		||||
	upvarSyntax:
 | 
			
		||||
| 
						 | 
				
			
			@ -2055,7 +2055,7 @@ Tcl_UpvarCmd(
 | 
			
		|||
static char *
 | 
			
		||||
CallTraces(
 | 
			
		||||
    Interp *iPtr,			/* Interpreter containing variable. */
 | 
			
		||||
    register Var *arrayPtr,		/* Pointer to array variable that
 | 
			
		||||
    Var *arrayPtr,		/* Pointer to array variable that
 | 
			
		||||
					 * contains the variable, or NULL if
 | 
			
		||||
					 * the variable isn't an element of an
 | 
			
		||||
					 * array. */
 | 
			
		||||
| 
						 | 
				
			
			@ -2072,7 +2072,7 @@ CallTraces(
 | 
			
		|||
					 * to callbacks. */
 | 
			
		||||
)
 | 
			
		||||
{
 | 
			
		||||
    register VarTrace *tracePtr;
 | 
			
		||||
    VarTrace *tracePtr;
 | 
			
		||||
    ActiveVarTrace active;
 | 
			
		||||
    char *result, *openParen, *p;
 | 
			
		||||
    Tcl_DString nameCopy;
 | 
			
		||||
| 
						 | 
				
			
			@ -2218,7 +2218,7 @@ CallTraces(
 | 
			
		|||
static Var *
 | 
			
		||||
NewVar(void)
 | 
			
		||||
{
 | 
			
		||||
    register Var *varPtr;
 | 
			
		||||
    Var *varPtr;
 | 
			
		||||
 | 
			
		||||
    varPtr = (Var *) ckalloc(sizeof(Var));
 | 
			
		||||
    varPtr->valueLength = 0;
 | 
			
		||||
| 
						 | 
				
			
			@ -2322,7 +2322,7 @@ ParseSearchId(
 | 
			
		|||
 | 
			
		||||
static void
 | 
			
		||||
DeleteSearches(
 | 
			
		||||
    register Var *arrayVarPtr		/* Variable whose searches are
 | 
			
		||||
    Var *arrayVarPtr		/* Variable whose searches are
 | 
			
		||||
					 * to be deleted. */
 | 
			
		||||
)
 | 
			
		||||
{
 | 
			
		||||
| 
						 | 
				
			
			@ -2365,7 +2365,7 @@ TclDeleteVars(
 | 
			
		|||
{
 | 
			
		||||
    Tcl_HashSearch search;
 | 
			
		||||
    Tcl_HashEntry *hPtr;
 | 
			
		||||
    register Var *varPtr;
 | 
			
		||||
    Var *varPtr;
 | 
			
		||||
    Var *upvarPtr;
 | 
			
		||||
    int flags;
 | 
			
		||||
    ActiveVarTrace *activePtr;
 | 
			
		||||
| 
						 | 
				
			
			@ -2493,8 +2493,8 @@ DeleteArray(
 | 
			
		|||
)
 | 
			
		||||
{
 | 
			
		||||
    Tcl_HashSearch search;
 | 
			
		||||
    register Tcl_HashEntry *hPtr;
 | 
			
		||||
    register Var *elPtr;
 | 
			
		||||
    Tcl_HashEntry *hPtr;
 | 
			
		||||
    Var *elPtr;
 | 
			
		||||
    ActiveVarTrace *activePtr;
 | 
			
		||||
 | 
			
		||||
    DeleteSearches(varPtr);
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
		Loading…
	
	Add table
		Add a link
		
	
		Reference in a new issue