Return to movblk.c CVS log

Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / d / entry

Power 6/32 Unix version 1.2b

#define error_hdl1 error
#define error_str error

extern long scoplp;
extern long force_lp;
extern long ercode;

#define C	0x1
#define V	0x2
#define Z	0x4
#define N	0x8

/*	MOVBLK instruction	*/

#define MAXLINE	100
#define NULL	0

/* Some global variables */
static long flag_msk, psl, len, r2;
static char *r1, *r0, *s_str;

asm(".align 2");
static char srcstr[MAXLINE], *srcptr;

asm(".align 2");
static char d_str[MAXLINE], *dstptr;


movblk()
{
	asm("movl	$3,_no_opr");
	mvblock();
	asm("jmp *return");
}

static mvblock()
{	
	long  exp_psw, ix, exp_r2;
	char *exp_r0, *exp_r1, *cptr;

	cptr = srcstr;
	for(ix=0;ix<95;ix++) {
		*cptr = ' ' + ix; /* make a long string */
		cptr++;
		}
	*cptr = '\0';
	exp_r2 = 0;

	setjmp();
	asm("m1:	movab	m1,_stpc");
	asm("movl	$1,_subtst");
	flag_msk = exp_psw = N|V|C;
	srcptr = (char *)(srcstr + 2);		/* source str begin at word */
	dstptr = (char *)(d_str + 3);		/* Dest. str begin at byte */
	len = 50;
	exp_r0 = srcptr + len;
	exp_r1 = dstptr + len;
	mvblk(exp_r0,exp_r1,exp_r2,exp_psw);

	setjmp();
	asm("m2:	movab	m2,_stpc");
	asm("movl	$2,_subtst");
	flag_msk = exp_psw =  Z;
	srcptr = srcstr;			/* source str begin at lword */
	dstptr = (char *)(d_str + 2);		/* Dest. str begin at word */
	len = 94;
	exp_r0 = srcptr + len;
	exp_r1 = dstptr + len;
	mvblk(exp_r0,exp_r1,exp_r2,exp_psw);

	setjmp();
	asm("m3:	movab	m3,_stpc");
	asm("movl	$3,_subtst");
	flag_msk = exp_psw = N|Z|V|C;
	srcptr = (char *)(srcstr + 1);		/* source str begin at byte */
	dstptr = d_str;				/* Dest. str begin at lword */
	len = 95;
	exp_r0 = srcptr + len;
	exp_r1 = dstptr + len;
	mvblk(exp_r0,exp_r1,exp_r2,exp_psw);

} 

static mvblk(exp_r0,exp_r1,exp_r2,exp_psw)
char *exp_r0, *exp_r1 ;
long exp_psw, exp_r2;
{
	char *msg1, *msg2, *str, saves[MAXLINE], *cptr1, *cptr2;
	int ix;
	long slen, len_op, psw;

flag_msk = flag_msk << 16;
len_op = len;
cptr1 = srcptr+len; cptr2 = dstptr+len;
*cptr1 = *cptr2 = NULL;
for(;;)
     {

	/* CLEAR DESTINATION STRING */
	cptr1 = d_str;
	for(ix=0;ix<MAXLINE;ix++) {
		*cptr1 = '^';
		cptr1++;
		}
	/* SAVE SOURCE STRING	*/
	str = srcptr;
	cptr1 = saves;
	for(slen=0; slen<=len ;slen++) {
		*cptr1 = *str++;
		cptr1++;
		}
	/* set flags */
	len = len_op;
	asm("movl _srcptr,r0");
	asm("movl _dstptr,r1");
	asm("movl _len,r2");
	asm("bicpsw $0xf");		/* clear all flags */
	asm("bispsw _flag_msk");
	asm("movblk");
	asm("movpsl _psl");
	asm("movl r0,_r0");
	asm("movl r1,_r1");
	asm("movl r2,_r2");

	psw = psl & 0xf;

	/* check flags */
	if (psw != exp_psw)
		{
		ercode = 2;
		if (scoplp) longjmp();
		error_hdl1(psw,exp_psw,srcptr,dstptr,len);
		}

	/* CHECK IF SOURCE OPERANDS GET CHANGED	*/
	if (len != len_op)
		{
		ercode = 3;
		if (scoplp) longjmp();
		error_hdl1(len,len_op,srcptr,dstptr,len);
		}

	cptr1 = saves;
	cptr2 = srcptr;
	for(ix=0;ix<len;ix++)
		{
		if ((*cptr2) != (*cptr1)) 
			{
			ercode = 3;
			if (scoplp) longjmp();
			error_str(srcstr,saves,srcptr,dstptr,len);
			}
		cptr1++; 
		cptr2++; 
		}

	/* CHECK DESTINATION STRING	*/
	cptr1 = srcptr;
	cptr2 = dstptr;
	for(ix=0;ix<len;ix++)
		{ 
		if ((*cptr1) != (*cptr2)) 
			{
			ercode = 3;
			if (scoplp) longjmp();
			error_str(d_str,srcstr,srcptr,dstptr,len);
			}
		cptr1++; 
		cptr2++; 
		}

	cptr1 = dstptr+len+1;	
	if (((*cptr1) != '^') && ((*cptr1) != NULL))
		{
		ercode = 3;
		if (scoplp) longjmp();
		error_str(cptr1,dstptr+len+1,d_str,srcstr);
		}

	/* CHECK R0, R1, R2   	*/

	if (r0 != exp_r0)
		{
		ercode = 1;
		if (scoplp) longjmp();
		error_hdl1(r0,exp_r0,srcptr,dstptr,len);
		} 
	if (r1 != exp_r1)
		{
		ercode = 1;
		if (scoplp) longjmp();
		error_hdl1(r1,exp_r1,srcptr,dstptr,len);
		} 
	if (r2 != exp_r2)
		{
		ercode = 1;
		if (scoplp) longjmp();
		error_hdl1(r2,exp_r2,srcptr,dstptr,len);
		} 
/*		if (force_lp) longjmp();  */
		
	break;
    }
}

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.