rewrite `rename' and `rmdir' to properly invalidate the cache

[unix-history] / usr / src / sys / vax / inline / langpats.c

#ifndef lint
static char sccsid[] = "@(#)langpats.c	1.2 (Berkeley) %G%";
#endif

/*
 * In-line assembly code expander for
 * the kernel.  This code is based on
 * pc2 and the old asm.sed script.
 */
#include <stdio.h>
#include <ctype.h>

/*
 * The hash table must be at least twice as big as the number
 * of patterns, preferably bigger. It must also be a prime number
 */
#define HSHSIZ	139

/*
 * Pattern table.
 */
struct pats {
	char	*name;
	char	*replace;
} ptab[] = {
	{ "_spl0\n",
"	mfpr	$18,r0\n\
	mtpr	$0,$18\n" },

	{ "_spl1\n",
"	mfpr	$18,r0\n\
	mtpr	$1,$18\n" },

	{ "_splsoftclock\n",
"	mfpr	$18,r0\n\
	mtpr	$0x8,$18\n" },

	{ "_splnet\n",
"	mfpr	$18,r0\n\
	mtpr	$0xc,$18\n" },

	{ "_splimp\n",
"	mfpr	$18,r0\n\
	mtpr	$0x16,$18\n" },

	{ "_spl4\n",
"	mfpr	$18,r0\n\
	mtpr	$0x14,$18\n" },

	{ "_splbio\n",
"	mfpr	$18,r0\n\
	mtpr	$0x15,$18\n" },

	{ "_spltty\n",
"	mfpr	$18,r0\n\
	mtpr	$0x15,$18\n" },

	{ "_spl5\n",
"	mfpr	$18,r0\n\
	mtpr	$0x15,$18\n" },

	{ "_splclock\n",
"	mfpr	$18,r0\n\
	mtpr	$0x18,$18\n" },

	{ "_spl6\n",
"	mfpr	$18,r0\n\
	mtpr	$0x18,$18\n" },

	{ "_spl7\n",
"	mfpr	$18,r0\n\
	mtpr	$0x1f,$18\n" },

	{ "_splx\n",
"	mfpr	$18,r0\n\
	mtpr	(sp)+,$18\n" },

	{ "_mfpr\n",
"	mfpr	(sp)+,r0\n" },

	{ "_mtpr\n",
"	mtpr	4(sp),(sp)\n\
	addl2	$8,sp\n" },

	{ "_setsoftclock\n",
"	mtpr	$0x8,$0x14\n" },

	{ "_resume\n",
"	ashl	$9,(sp)+,r0 \n\
	movpsl	-(sp) \n\
	jsb	_Resume\n" },

	{ "_bcopy\n", 
"	movc3	8(sp),*(sp),*4(sp)\n\
	addl2	$12,sp\n" },

	{ "_ovbcopy\n",
"	movc3	8(sp),*(sp),*4(sp)\n\
	addl2	$12,sp\n" },

	{ "_bzero\n",
"	movc5	$0,(r0),$0,4(sp),*(sp)\n\
	addl2	$8,sp\n" },

	{ "_bcmp\n",
"	popr	$0x7\n\
	cmpc3	r2,(r0),(r1)\n" },

	{ "_strncmp\n",
"	cmpc3	8(sp),*(sp),*4(sp)\n\
	addl2	$12,sp\n" },

	{ "_blkclr\n",
"	movl	(sp)+,r3\n\
	jbr	2f\n\
1:\n\
	subl2	r0,(sp)\n\
	movc5	$0,(r3),$0,r0,(r3)\n\
2:\n\
	movzwl	$65535,r0\n\
	cmpl	(sp),r0\n\
	jgtr	1b\n\
	movl	(sp)+,r0\n\
	movc5	$0,(r3),$0,r0,(r3)\n" },

	{ "_strlen\n",
"	movl	(sp),r1\n\
1:\n\
	locc	$0,$65535,(r1)\n\
	jeql	1b\n\
	subl3	(sp)+,r1,r0\n" },

	{ "_scanc\n",
"	popr	$0xf\n\
	scanc	r0,(r1),(r2),r3\n" },

	{ "_copyin\n",
"	jsb	_Copyin\n\
	addl2	$12,sp\n" },

	{ "_copyout\n",
"	jsb	_Copyout\n\
	addl2	$12,sp\n" },

	{ "_fubyte\n",
"	movl	(sp)+,r0\n\
	jsb	_Fubyte\n" },

	{ "_fuibyte\n",
"	movl (sp)+,r0\n\
	jsb	_Fubyte\n" },

	{ "_fuword\n",
"	movl (sp)+,r0\n\
	jsb	_Fuword\n" },

	{ "_fuiword\n",
"	movl (sp)+,r0\n\
	jsb	_Fuword\n" },

	{ "_subyte\n",
"	movl	(sp)+,r0\n\
	movl	(sp)+,r1\n\
	jsb	_Subyte\n" },

	{ "_suibyte\n",
"	movl (sp)+,r0\n\
	movl	(sp)+,r1\n\
	jsb	_Subyte\n" },

	{ "_suword\n",
"	movl (sp)+,r0\n\
	movl	(sp)+,r1\n\
	jsb	_Suword\n" },

	{ "_suiword\n",
"	movl (sp)+,r0\n\
	movl	(sp)+,r1\n\
	jsb	_Suword\n" },

	{ "_setrq\n",
"	movl	(sp)+,r0 \n\
	jsb	_Setrq\n" },

	{ "_remrq\n",
"	movl	(sp)+,r0 \n\
	jsb	_Remrq\n" },

	{ "_swtch\n",
"	movpsl	-(sp)\n\
	jsb	_Swtch\n" },

	{ "_setjmp\n",
"	movl	(sp)+,r0 \n\
	jsb	_Setjmp\n" },

	{ "_longjmp\n",
"	movl	(sp)+,r0 \n\
	jsb	_Longjmp\n" },

	{ "_ffs\n",
"	movl	(sp)+,r1\n\
	ffs	$0,$32,r1,r0 \n\
	bneq	1f \n\
	mnegl	$1,r0 \n\
1: \n\
	incl	r0\n" },

	{ "_htons\n",
"	rotl	$8,(sp),r0\n\
	movb	1(sp),r0\n\
	movzwl	r0,r0\n\
	addl2	$4,sp\n" },

	{ "_ntohs\n",
"	rotl	$8,(sp),r0\n\
	movb	1(sp),r0\n\
	movzwl	r0,r0\n\
	addl2	$4,sp\n" },

	{ "_htonl\n",
"	rotl	$-8,(sp),r0\n\
	insv	r0,$16,$8,r0\n\
	movb	3(sp),r0\n\
	addl2	$4,sp\n" },

	{ "_ntohl\n",
"	rotl	$-8,(sp),r0\n\
	insv	r0,$16,$8,r0\n\
	movb	3(sp),r0\n\
	addl2	$4,sp\n" },

	{ "__insque\n",
"	insque	*(sp)+,*(sp)+\n" },

	{ "__remque\n",
"	remque	*(sp)+,r0\n" },

	{ "__queue\n",
"	movl	(sp)+,r0\n\
	movl	(sp)+,r1\n\
	insque	r1,*4(r0)\n" },

	{ "__dequeue\n",
"	movl	(sp)+,r0\n\
	remque	*(r0),r0\n" },
};
struct pats *htbl[HSHSIZ];

#define HASH(cp, hp) {\
    hash = 0; rehash = 1; ccp = cp; \
    do	{ \
    	hash *= (int)*ccp++; \
    } while (*ccp && *ccp != '\n'); \
    hash >>= 7; hash %= HSHSIZ; hp = &htbl[hash]; size = ccp - cp + 1; \
}

#define REHASH(hp) {\
    hp += rehash; rehash += 2; \
    if (hp >= &htbl[HSHSIZ]) \
    	hp -= HSHSIZ; \
}

main(argc, argv)
	char *argv[];
{
	register struct pats *pp, **hp;
	register char *cp, *ccp, *lp;
	register int hash, rehash, size;
	char line[BUFSIZ];
	extern char *index();

	if (argc > 1)
		freopen(argv[1], "r", stdin);
	if (argc > 2)
		freopen(argv[2], "w", stdout);
	/*
	 * Set up the hash table.
	 */
	for (pp = ptab; pp < &ptab[sizeof (ptab)/sizeof (ptab[0])]; pp++) {
		HASH(pp->name, hp);
		while (*hp)
			REHASH(hp);
		*hp = pp;
	}
	/*
	 * Check each line and replace as appropriate.
	 */
	while (fgets(line, BUFSIZ, stdin)) {
		lp = index(line, ':');
		for (cp = (lp != NULL) ? ++lp : line; *cp == '\t'; )
			cp++;
#define	CALLS	"calls\t"
		if (strncmp(cp, CALLS, sizeof (CALLS) - 1) != 0) {
			fputs(line, stdout);
			continue;
		}
		for (cp += sizeof (CALLS) - 1; *cp && *cp != ','; cp++)
			;
		if (*cp != ',') {
			fputs(line, stdout);
			continue;
		}
		cp++;
		HASH(cp, hp);
		while (*hp) {
			if (strncmp((*hp)->name, cp, size) == NULL) {
				if (lp != NULL) {
					*lp++ = '\n';
					*lp = '\0';
					fputs(line, stdout);
				}
				fputs((*hp)->replace, stdout);
				goto nextline;
			}
			REHASH(hp);
		}
		fputs(line, stdout);
nextline:
		;
	}
	exit(0);
}