Example #1
0
static int analop_esil(RAnal *a, RAnalOp *op, ut64 addr, const ut8 *buf, int len, csh *handle, cs_insn *insn) {
	int i;
	char str[32][32];
	r_strbuf_init (&op->esil);
	r_strbuf_set (&op->esil, "");
	switch (insn->detail->arm.cc) {
	case ARM_CC_AL:
		// no condition
		break;
	case ARM_CC_EQ:
		r_strbuf_setf (&op->esil, "zf,0,?,");
		break;
	case ARM_CC_NE:
		r_strbuf_setf (&op->esil, "zf,!,0,?,");
		break;
	case ARM_CC_GT:
	case ARM_CC_LE:
		break;
	default:
		break;
	}
	// TODO: PREFIX CONDITIONAL
	switch (insn->id) {
	case ARM_INS_PUSH:
		// TODO: increment stack
	case ARM_INS_STM:
		for (i=1; i<insn->detail->arm.op_count; i++) {
			r_strbuf_appendf (&op->esil, "%s,%s,%d,+,=[4],",
				REG (i), ARG (0), i*4);
		}
		break;
	case ARM_INS_POP:
		// TODO: decrement stack
	case ARM_INS_LDM:
		for (i=1; i<insn->detail->arm.op_count; i++) {
			r_strbuf_appendf (&op->esil, "%s,%d,+,[4],%s,=",
				ARG (0), i*4, REG (i));
		}
		break;
	case ARM_INS_CMP:
		r_strbuf_appendf (&op->esil, "%s,%s,==", ARG(1), ARG(0));
		break;
	case ARM_INS_LSL:
		// suffix 'S' forces conditional flag to be updated
		r_strbuf_appendf (&op->esil, "%s,%s,<<=", ARG(1), ARG(0));
		break;
	case ARM_INS_LSR:
		// suffix 'S' forces conditional flag to be updated
		r_strbuf_appendf (&op->esil, "%s,%s,>>=", ARG(1), ARG(0));
		break;
	case ARM_INS_B:
		r_strbuf_appendf (&op->esil, "%s,pc,=", ARG(0));
		break;
	case ARM_INS_BL:
	case ARM_INS_BLX:
		r_strbuf_appendf (&op->esil, "4,pc,+,lr,=,%s,pc,=", ARG(0));
		break;
	case ARM_INS_MOV:
	case ARM_INS_MOVS:
		r_strbuf_appendf (&op->esil, "%s,%s,=", ARG(1), REG(0));
		break;
	case ARM_INS_SSUB16:
	case ARM_INS_SSUB8:
	case ARM_INS_SUB:
		r_strbuf_appendf (&op->esil, "%s,%s,-=", ARG(1), ARG(0));
		break;
	case ARM_INS_SADD16:
	case ARM_INS_SADD8:
	case ARM_INS_ADD:
		if (!strcmp (ARG(0),ARG(1))) {
			r_strbuf_appendf (&op->esil, "%s,%s,+=", ARG(2), ARG(0));
		} else if (!strcmp (ARG(2),"0")) {
			r_strbuf_appendf (&op->esil, "%s,%s,=", ARG(1), ARG(0));
		} else {
			r_strbuf_appendf (&op->esil, "%s,%s,+,%s,=", ARG(2), ARG(1), ARG(0));
		}
		break;
	case ARM_INS_STR:
		r_strbuf_appendf (&op->esil, "%s,%s,%d,+,=[4]",
			REG(0), MEMBASE(1), MEMDISP(1));
		break;
	case ARM_INS_STRB:
		r_strbuf_appendf (&op->esil, "%s,%s,%d,+,=[1]",
			REG(0), MEMBASE(1), MEMDISP(1));
		break;
	case ARM_INS_LDR:
		if (MEMDISP(1)<0) {
			if (REGBASE(1) == ARM_REG_PC) {
				r_strbuf_appendf (&op->esil, "8,%s,+,%d,-,[4],%s,=",
						MEMBASE(1), -MEMDISP(1), REG(0));
				switch (a->bits) {
				case 32:
					op->ptr = addr + 8 - MEMDISP(1);
					op->refptr = 4;
					break;
				case 16:
					if ( (addr % 4) == 0 ) {
						op->ptr = addr + 4 - MEMDISP(1);
						op->refptr = 4;
					} else {
						op->ptr = addr + 2 - MEMDISP(1);
						op->refptr = 4;
					}
					break;
				}
			} else {
				r_strbuf_appendf (&op->esil, "%s,%d,-,[4],%s,=",
					MEMBASE(1), -MEMDISP(1), REG(0));
			}
		} else {
			if (REGBASE(1) == ARM_REG_PC) {
				r_strbuf_appendf (&op->esil, "8,%s,+,%d,+,[4],%s,=",
					MEMBASE(1), MEMDISP(1), REG(0));
				if (a->bits==32) {
					op->ptr = addr + 8 + MEMDISP(1);
					op->refptr = 4;
				} else if (a->bits==16) {
					if ( (addr % 4) == 0 ) {
						op->ptr = addr + 4 + MEMDISP(1);
						op->refptr = 4;
					} else {
						op->ptr = addr + 2 + MEMDISP(1);
						op->refptr = 4;
					}
				}
			} else {
				r_strbuf_appendf (&op->esil, "%s,%d,+,[4],%s,=",
					MEMBASE(1), MEMDISP(1), REG(0));
			}
			op->refptr = 4;
		}
		break;
	case ARM_INS_LDRD:
	case ARM_INS_LDRB:
		r_strbuf_appendf (&op->esil, "%s,%d,+,[1],%s,=",
			MEMBASE(1), MEMDISP(1), REG(0));
		break;
	default:
		break;
	}
	return 0;
}
Example #2
0
void Fset_hash_table_rehash_threshold(CL_FORM *base)
{
	LOAD_FIXNUM(ARG(2), 3, ARG(2));
	LOAD_SYMBOL(SYMBOL(Slisp, 399), ARG(3));	/* HASH-TABLE */
	rt_set_struct_ref(ARG(0));
}
Example #3
0
File: Ffind.c Project: hoelzl/Clicc
void Ffind(CL_FORM *base, int nargs)
{
	CL_FORM *rest_0;
	CL_FORM *local;
	rest_0 = ARG(2);
	local = ARG(nargs);
	if(CL_TRUEP(ARG(1)))
	{
		if(CL_CONSP(ARG(1)))
		{
			LOAD_GLOBFUN(&Clist_find, LOCAL(0));
			COPY(ARG(0), LOCAL(1));
			COPY(ARG(1), LOCAL(2));
			REST_APPLY(LOCAL(0), 3, rest_0);
			COPY(LOCAL(0), ARG(0));
		}
		else
		{
			LOAD_BOOL(CL_SMVECP(ARG(1)), LOCAL(0));
			if(CL_TRUEP(LOCAL(0)))
			{
				goto THEN1;
			}
			else
			{
				COPY(ARG(1), LOCAL(1));
				LOAD_SYMBOL(SYMBOL(Slisp, 150), LOCAL(2));	/* COMPLEX-VECTOR */
				rt_struct_typep(LOCAL(1));
			}
			if(CL_TRUEP(LOCAL(1)))
			{
				THEN1:;
				LOAD_GLOBFUN(&Cvector_find, LOCAL(0));
				COPY(ARG(0), LOCAL(1));
				COPY(ARG(1), LOCAL(2));
				REST_APPLY(LOCAL(0), 3, rest_0);
				COPY(LOCAL(0), ARG(0));
			}
			else
			{
				COPY(SYMVAL(Slisp, 58), LOCAL(0));	/* WRONG_TYPE */
				COPY(ARG(1), LOCAL(1));
				LOAD_SYMBOL(SYMBOL(Slisp, 36), LOCAL(2));	/* SEQUENCE */
				Ferror(LOCAL(0), 3);
			}
		}
	}
	else
	{
		LOAD_NIL(ARG(0));
	}
}
Example #4
0
void stringG1(CL_FORM *base)
{
	COPY(ARG(0), ARG(6));
	Fstring(ARG(6));
	COPY(ARG(6), ARG(0));
	COPY(ARG(1), ARG(6));
	Fstring(ARG(6));
	COPY(ARG(6), ARG(1));
	COPY(ARG(2), ARG(6));
	COPY(ARG(3), ARG(7));
	COPY(ARG(0), ARG(8));
	Flength(ARG(8));
	check_seq_start_end(ARG(6));
	COPY(ARG(6), ARG(3));
	COPY(ARG(4), ARG(6));
	COPY(ARG(5), ARG(7));
	COPY(ARG(1), ARG(8));
	Flength(ARG(8));
	check_seq_start_end(ARG(6));
	COPY(ARG(6), ARG(5));
	COPY(ARG(2), ARG(6));
	COPY(ARG(4), ARG(7));
	LOAD_NIL(ARG(8));
	LOAD_NIL(ARG(9));
	M1_1:;
	COPY(ARG(6), ARG(10));
	COPY(ARG(3), ARG(11));
	Fnumeql(ARG(10), 2);
	if(CL_TRUEP(ARG(10)))
	{
		LOAD_NIL(ARG(0));
		goto RETURN2;
	}
	COPY(ARG(7), ARG(10));
	COPY(ARG(5), ARG(11));
	Fnumeql(ARG(10), 2);
	if(CL_TRUEP(ARG(10)))
	{
		COPY(ARG(6), ARG(0));
		goto RETURN2;
	}
	COPY(ARG(0), ARG(10));
	COPY(ARG(6), ARG(11));
	COPY(ARG(10), ARG(12));
	Fstringp(ARG(12));
	if(CL_TRUEP(ARG(12)))
	{
	}
	else
	{
		COPY(SYMVAL(Slisp, 58), ARG(12));	/* WRONG_TYPE */
		COPY(ARG(10), ARG(13));
		LOAD_SYMBOL(SYMBOL(Slisp, 44), ARG(14));	/* STRING */
		Ferror(ARG(12), 3);
	}
	COPY(ARG(10), ARG(12));
	COPY(ARG(11), ARG(13));
	Frow_major_aref(ARG(12));
	COPY(ARG(12), ARG(8));
	COPY(ARG(1), ARG(10));
	COPY(ARG(7), ARG(11));
	COPY(ARG(10), ARG(12));
	Fstringp(ARG(12));
	if(CL_TRUEP(ARG(12)))
	{
	}
	else
	{
		COPY(SYMVAL(Slisp, 58), ARG(12));	/* WRONG_TYPE */
		COPY(ARG(10), ARG(13));
		LOAD_SYMBOL(SYMBOL(Slisp, 44), ARG(14));	/* STRING */
		Ferror(ARG(12), 3);
	}
	COPY(ARG(10), ARG(9));
	COPY(ARG(11), ARG(10));
	Frow_major_aref(ARG(9));
	if(CL_CHARP(ARG(8)))
	{
	}
	else
	{
		COPY(SYMVAL(Slisp, 58), ARG(10));	/* WRONG_TYPE */
		COPY(ARG(8), ARG(11));
		LOAD_SYMBOL(SYMBOL(Slisp, 18), ARG(12));	/* CHARACTER */
		Ferror(ARG(10), 3);
	}
	COPY(ARG(8), ARG(10));
	rt_char_code(ARG(10));
	if(CL_CHARP(ARG(9)))
	{
	}
	else
	{
		COPY(SYMVAL(Slisp, 58), ARG(11));	/* WRONG_TYPE */
		COPY(ARG(9), ARG(12));
		LOAD_SYMBOL(SYMBOL(Slisp, 18), ARG(13));	/* CHARACTER */
		Ferror(ARG(11), 3);
	}
	COPY(ARG(9), ARG(11));
	rt_char_code(ARG(11));
	Fgt(ARG(10), 2);
	if(CL_TRUEP(ARG(10)))
	{
		COPY(ARG(6), ARG(0));
		goto RETURN1;
	}
	else
	{
		COPY(ARG(8), ARG(10));
		COPY(ARG(9), ARG(11));
		rt_charE(ARG(10));
		if(CL_TRUEP(ARG(10)))
		{
		}
		else
		{
			LOAD_NIL(ARG(0));
			goto RETURN1;
		}
	}
	COPY(ARG(6), ARG(10));
	F1plus(ARG(10));
	F1plus(ARG(7));
	COPY(ARG(10), ARG(6));
	goto M1_1;
	RETURN2:;
	RETURN1:;
}
Example #5
0
int s2650Run(int cycles)
{
	s2650_ICount = cycles;
	do
	{
		S.ppc = S.page + S.iar;

		S.ir = ROP();
		S.r = S.ir & 3; 		/* register / value */
		switch (S.ir) {
			case 0x00:		/* LODZ,0 */
			case 0x01:		/* LODZ,1 */
			case 0x02:		/* LODZ,2 */
			case 0x03:		/* LODZ,3 */
				s2650_ICount -= 6;
				M_LOD( R0, S.reg[S.r] );
				break;

			case 0x04:		/* LODI,0 v */
			case 0x05:		/* LODI,1 v */
			case 0x06:		/* LODI,2 v */
			case 0x07:		/* LODI,3 v */
				s2650_ICount -= 6;
				M_LOD( S.reg[S.r], ARG() );
				break;

			case 0x08:		/* LODR,0 (*)a */
			case 0x09:		/* LODR,1 (*)a */
			case 0x0a:		/* LODR,2 (*)a */
			case 0x0b:		/* LODR,3 (*)a */
				s2650_ICount -= 9;
				REL_EA( S.page );
				M_LOD( S.reg[S.r], RDMEM(S.ea) );
				break;

			case 0x0c:		/* LODA,0 (*)a(,X) */
			case 0x0d:		/* LODA,1 (*)a(,X) */
			case 0x0e:		/* LODA,2 (*)a(,X) */
			case 0x0f:		/* LODA,3 (*)a(,X) */
				s2650_ICount -= 12;
				ABS_EA();
				M_LOD( S.reg[S.r], RDMEM(S.ea) );
				break;

			case 0x10:		/* illegal */
			case 0x11:		/* illegal */
				s2650_ICount -= 7;
				break;
			case 0x12:		/* SPSU */
				s2650_ICount -= 6;
				M_SPSU();
				break;
			case 0x13:		/* SPSL */
				s2650_ICount -= 6;
				M_SPSL();
				break;

			case 0x14:		/* RETC,0   (zero)  */
			case 0x15:		/* RETC,1   (plus)  */
			case 0x16:		/* RETC,2   (minus) */
				s2650_ICount -= 9;	/* +2 cycles if condition is true */
				M_RET( (S.psl >> 6) == S.r );
				break;
			case 0x17:		/* RETC,3   (always) */
				s2650_ICount -= 9;	/* +2 cycles if condition is true */
				M_RET( 1 );
				break;

			case 0x18:		/* BCTR,0  (*)a */
			case 0x19:		/* BCTR,1  (*)a */
			case 0x1a:		/* BCTR,2  (*)a */
				s2650_ICount -= 9;
				M_BRR( (S.psl >> 6) == S.r );
				break;
			case 0x1b:		/* BCTR,3  (*)a */
				s2650_ICount -= 9;
				M_BRR( 1 );
				break;

			case 0x1c:		/* BCTA,0  (*)a */
			case 0x1d:		/* BCTA,1  (*)a */
			case 0x1e:		/* BCTA,2  (*)a */
				s2650_ICount -= 9;
				M_BRA( (S.psl >> 6) == S.r );
				break;
			case 0x1f:		/* BCTA,3  (*)a */
				s2650_ICount -= 9;
				M_BRA( 1 );
				break;

			case 0x20:		/* EORZ,0 */
			case 0x21:		/* EORZ,1 */
			case 0x22:		/* EORZ,2 */
			case 0x23:		/* EORZ,3 */
				s2650_ICount -= 6;
				M_EOR( R0, S.reg[S.r] );
				break;

			case 0x24:		/* EORI,0 v */
			case 0x25:		/* EORI,1 v */
			case 0x26:		/* EORI,2 v */
			case 0x27:		/* EORI,3 v */
				s2650_ICount -= 6;
				M_EOR( S.reg[S.r], ARG() );
				break;

			case 0x28:		/* EORR,0 (*)a */
			case 0x29:		/* EORR,1 (*)a */
			case 0x2a:		/* EORR,2 (*)a */
			case 0x2b:		/* EORR,3 (*)a */
				s2650_ICount -= 9;
				REL_EA( S.page );
				M_EOR( S.reg[S.r], RDMEM(S.ea) );
				break;

			case 0x2c:		/* EORA,0 (*)a(,X) */
			case 0x2d:		/* EORA,1 (*)a(,X) */
			case 0x2e:		/* EORA,2 (*)a(,X) */
			case 0x2f:		/* EORA,3 (*)a(,X) */
				s2650_ICount -= 12;
				ABS_EA();
				M_EOR( S.reg[S.r], RDMEM(S.ea) );
				break;

			case 0x30:		/* REDC,0 */
			case 0x31:		/* REDC,1 */
			case 0x32:		/* REDC,2 */
			case 0x33:		/* REDC,3 */
				s2650_ICount -= 6;
				S.reg[S.r] = s2650_read_port(S2650_CTRL_PORT);
				SET_CC( S.reg[S.r] );
				break;

			case 0x34:		/* RETE,0 */
			case 0x35:		/* RETE,1 */
			case 0x36:		/* RETE,2 */
				s2650_ICount -= 9;
				M_RETE( (S.psl >> 6) == S.r );
				break;
			case 0x37:		/* RETE,3 */
				s2650_ICount -= 9;
				M_RETE( 1 );
				break;

			case 0x38:		/* BSTR,0 (*)a */
			case 0x39:		/* BSTR,1 (*)a */
			case 0x3a:		/* BSTR,2 (*)a */
				s2650_ICount -= 9;
				M_BSR( (S.psl >> 6) == S.r );
				break;
			case 0x3b:		/* BSTR,R3 (*)a */
				s2650_ICount -= 9;
				M_BSR( 1 );
				break;

			case 0x3c:		/* BSTA,0 (*)a */
			case 0x3d:		/* BSTA,1 (*)a */
			case 0x3e:		/* BSTA,2 (*)a */
				s2650_ICount -= 9;
				M_BSA( (S.psl >> 6) == S.r );
				break;
			case 0x3f:		/* BSTA,3 (*)a */
				s2650_ICount -= 9;
				M_BSA( 1 );
				break;

			case 0x40:		/* HALT */
				s2650_ICount -= 6;
				S.iar = (S.iar - 1) & PMSK;
				S.halt = 1;
				if (s2650_ICount > 0)
					s2650_ICount = 0;
				break;
			case 0x41:		/* ANDZ,1 */
			case 0x42:		/* ANDZ,2 */
			case 0x43:		/* ANDZ,3 */
				s2650_ICount -= 6;
				M_AND( R0, S.reg[S.r] );
				break;

			case 0x44:		/* ANDI,0 v */
			case 0x45:		/* ANDI,1 v */
			case 0x46:		/* ANDI,2 v */
			case 0x47:		/* ANDI,3 v */
				s2650_ICount -= 6;
				M_AND( S.reg[S.r], ARG() );
				break;

			case 0x48:		/* ANDR,0 (*)a */
			case 0x49:		/* ANDR,1 (*)a */
			case 0x4a:		/* ANDR,2 (*)a */
			case 0x4b:		/* ANDR,3 (*)a */
				s2650_ICount -= 9;
				REL_EA( S.page );
				M_AND( S.reg[S.r], RDMEM(S.ea) );
				break;

			case 0x4c:		/* ANDA,0 (*)a(,X) */
			case 0x4d:		/* ANDA,1 (*)a(,X) */
			case 0x4e:		/* ANDA,2 (*)a(,X) */
			case 0x4f:		/* ANDA,3 (*)a(,X) */
				s2650_ICount -= 12;
				ABS_EA();
				M_AND( S.reg[S.r], RDMEM(S.ea) );
				break;

			case 0x50:		/* RRR,0 */
			case 0x51:		/* RRR,1 */
			case 0x52:		/* RRR,2 */
			case 0x53:		/* RRR,3 */
				s2650_ICount -= 6;
				M_RRR( S.reg[S.r] );
				break;

			case 0x54:		/* REDE,0 v */
			case 0x55:		/* REDE,1 v */
			case 0x56:		/* REDE,2 v */
			case 0x57:		/* REDE,3 v */
				s2650_ICount -= 9;
				S.reg[S.r] = s2650_read_port( ARG() );
				SET_CC(S.reg[S.r]);
				break;

			case 0x58:		/* BRNR,0 (*)a */
			case 0x59:		/* BRNR,1 (*)a */
			case 0x5a:		/* BRNR,2 (*)a */
			case 0x5b:		/* BRNR,3 (*)a */
				s2650_ICount -= 9;
				M_BRR( S.reg[S.r] );
				break;

			case 0x5c:		/* BRNA,0 (*)a */
			case 0x5d:		/* BRNA,1 (*)a */
			case 0x5e:		/* BRNA,2 (*)a */
			case 0x5f:		/* BRNA,3 (*)a */
				s2650_ICount -= 9;
				M_BRA( S.reg[S.r] );
				break;

			case 0x60:		/* IORZ,0 */
			case 0x61:		/* IORZ,1 */
			case 0x62:		/* IORZ,2 */
			case 0x63:		/* IORZ,3 */
				s2650_ICount -= 6;
				M_IOR( R0, S.reg[S.r] );
				break;

			case 0x64:		/* IORI,0 v */
			case 0x65:		/* IORI,1 v */
			case 0x66:		/* IORI,2 v */
			case 0x67:		/* IORI,3 v */
				s2650_ICount -= 6;
				M_IOR( S.reg[S.r], ARG() );
				break;

			case 0x68:		/* IORR,0 (*)a */
			case 0x69:		/* IORR,1 (*)a */
			case 0x6a:		/* IORR,2 (*)a */
			case 0x6b:		/* IORR,3 (*)a */
				s2650_ICount -= 9;
				REL_EA( S.page );
				M_IOR( S.reg[S. r],RDMEM(S.ea) );
				break;

			case 0x6c:		/* IORA,0 (*)a(,X) */
			case 0x6d:		/* IORA,1 (*)a(,X) */
			case 0x6e:		/* IORA,2 (*)a(,X) */
			case 0x6f:		/* IORA,3 (*)a(,X) */
				s2650_ICount -= 12;
				ABS_EA();
				M_IOR( S.reg[S.r], RDMEM(S.ea) );
				break;

			case 0x70:		/* REDD,0 */
			case 0x71:		/* REDD,1 */
			case 0x72:		/* REDD,2 */
			case 0x73:		/* REDD,3 */
				s2650_ICount -= 6;
				S.reg[S.r] = s2650_read_port(S2650_DATA_PORT);
				SET_CC(S.reg[S.r]);
				break;

			case 0x74:		/* CPSU */
				s2650_ICount -= 9;
				M_CPSU();
				break;
			case 0x75:		/* CPSL */
				s2650_ICount -= 9;
				M_CPSL();
				break;
			case 0x76:		/* PPSU */
				s2650_ICount -= 9;
				M_PPSU();
				break;
			case 0x77:		/* PPSL */
				s2650_ICount -= 9;
				M_PPSL();
				break;

			case 0x78:		/* BSNR,0 (*)a */
			case 0x79:		/* BSNR,1 (*)a */
			case 0x7a:		/* BSNR,2 (*)a */
			case 0x7b:		/* BSNR,3 (*)a */
				s2650_ICount -= 9;
				M_BSR( S.reg[S.r] );
				break;

			case 0x7c:		/* BSNA,0 (*)a */
			case 0x7d:		/* BSNA,1 (*)a */
			case 0x7e:		/* BSNA,2 (*)a */
			case 0x7f:		/* BSNA,3 (*)a */
				s2650_ICount -= 9;
				M_BSA( S.reg[S.r] );
				break;

			case 0x80:		/* ADDZ,0 */
			case 0x81:		/* ADDZ,1 */
			case 0x82:		/* ADDZ,2 */
			case 0x83:		/* ADDZ,3 */
				s2650_ICount -= 6;
				M_ADD( R0,S.reg[S.r] );
				break;

			case 0x84:		/* ADDI,0 v */
			case 0x85:		/* ADDI,1 v */
			case 0x86:		/* ADDI,2 v */
			case 0x87:		/* ADDI,3 v */
				s2650_ICount -= 6;
				M_ADD( S.reg[S.r], ARG() );
				break;

			case 0x88:		/* ADDR,0 (*)a */
			case 0x89:		/* ADDR,1 (*)a */
			case 0x8a:		/* ADDR,2 (*)a */
			case 0x8b:		/* ADDR,3 (*)a */
				s2650_ICount -= 9;
				REL_EA(S.page);
				M_ADD( S.reg[S.r], RDMEM(S.ea) );
				break;

			case 0x8c:		/* ADDA,0 (*)a(,X) */
			case 0x8d:		/* ADDA,1 (*)a(,X) */
			case 0x8e:		/* ADDA,2 (*)a(,X) */
			case 0x8f:		/* ADDA,3 (*)a(,X) */
				s2650_ICount -= 12;
				ABS_EA();
				M_ADD( S.reg[S.r], RDMEM(S.ea) );
				break;

			case 0x90:		/* illegal */
			case 0x91:		/* illegal */
				s2650_ICount -= 7;
				break;
			case 0x92:		/* LPSU */
				s2650_ICount -= 6;
				S.psu = (R0 & ~PSU34) & ~SI;
				break;
			case 0x93:		/* LPSL */
				s2650_ICount -= 6;
				/* change register set ? */
				if ((S.psl ^ R0) & RS)
					SWAP_REGS;
				S.psl = R0;
				break;

			case 0x94:		/* DAR,0 */
			case 0x95:		/* DAR,1 */
			case 0x96:		/* DAR,2 */
			case 0x97:		/* DAR,3 */
				s2650_ICount -= 9;
				M_DAR( S.reg[S.r] );
				break;

			case 0x98:		/* BCFR,0 (*)a */
			case 0x99:		/* BCFR,1 (*)a */
			case 0x9a:		/* BCFR,2 (*)a */
				s2650_ICount -= 9;
				M_BRR( (S.psl >> 6) != S.r );
				break;
			case 0x9b:		/* ZBRR    (*)a */
				s2650_ICount -= 9;
				M_ZBRR();
				break;

			case 0x9c:		/* BCFA,0 (*)a */
			case 0x9d:		/* BCFA,1 (*)a */
			case 0x9e:		/* BCFA,2 (*)a */
				s2650_ICount -= 9;
				M_BRA( (S.psl >> 6) != S.r );
				break;
			case 0x9f:		/* BXA     (*)a */
				s2650_ICount -= 9;
				M_BXA();
				break;

			case 0xa0:		/* SUBZ,0 */
			case 0xa1:		/* SUBZ,1 */
			case 0xa2:		/* SUBZ,2 */
			case 0xa3:		/* SUBZ,3 */
				s2650_ICount -= 6;
				M_SUB( R0, S.reg[S.r] );
				break;

			case 0xa4:		/* SUBI,0 v */
			case 0xa5:		/* SUBI,1 v */
			case 0xa6:		/* SUBI,2 v */
			case 0xa7:		/* SUBI,3 v */
				s2650_ICount -= 6;
				M_SUB( S.reg[S.r], ARG() );
				break;

			case 0xa8:		/* SUBR,0 (*)a */
			case 0xa9:		/* SUBR,1 (*)a */
			case 0xaa:		/* SUBR,2 (*)a */
			case 0xab:		/* SUBR,3 (*)a */
				s2650_ICount -= 9;
				REL_EA(S.page);
				M_SUB( S.reg[S.r], RDMEM(S.ea) );
				break;

			case 0xac:		/* SUBA,0 (*)a(,X) */
			case 0xad:		/* SUBA,1 (*)a(,X) */
			case 0xae:		/* SUBA,2 (*)a(,X) */
			case 0xaf:		/* SUBA,3 (*)a(,X) */
				s2650_ICount -= 12;
				ABS_EA();
				M_SUB( S.reg[S.r], RDMEM(S.ea) );
				break;

			case 0xb0:		/* WRTC,0 */
			case 0xb1:		/* WRTC,1 */
			case 0xb2:		/* WRTC,2 */
			case 0xb3:		/* WRTC,3 */
				s2650_ICount -= 6;
				s2650_write_port(S2650_CTRL_PORT,S.reg[S.r]);
				break;

			case 0xb4:		/* TPSU */
				s2650_ICount -= 9;
				M_TPSU();
				break;
			case 0xb5:		/* TPSL */
				s2650_ICount -= 9;
				M_TPSL();
				break;
			case 0xb6:		/* illegal */
			case 0xb7:		/* illegal */
				s2650_ICount -= 7;
				break;

			case 0xb8:		/* BSFR,0 (*)a */
			case 0xb9:		/* BSFR,1 (*)a */
			case 0xba:		/* BSFR,2 (*)a */
				s2650_ICount -= 9;
				M_BSR( (S.psl >> 6) != S.r );
				break;
			case 0xbb:		/* ZBSR    (*)a */
				s2650_ICount -= 9;
				M_ZBSR();
				break;

			case 0xbc:		/* BSFA,0 (*)a */
			case 0xbd:		/* BSFA,1 (*)a */
			case 0xbe:		/* BSFA,2 (*)a */
				s2650_ICount -= 9;
				M_BSA( (S.psl >> 6) != S.r );
				break;
			case 0xbf:		/* BSXA    (*)a */
				s2650_ICount -= 9;
				M_BSXA();
				break;

			case 0xc0:		/* NOP */
				s2650_ICount -= 6;
				break;
			case 0xc1:		/* STRZ,1 */
			case 0xc2:		/* STRZ,2 */
			case 0xc3:		/* STRZ,3 */
				s2650_ICount -= 6;
				M_LOD( S.reg[S.r], R0 );
				break;

			case 0xc4:		/* illegal */
			case 0xc5:		/* illegal */
			case 0xc6:		/* illegal */
			case 0xc7:		/* illegal */
				s2650_ICount -= 7;
				break;

			case 0xc8:		/* STRR,0 (*)a */
			case 0xc9:		/* STRR,1 (*)a */
			case 0xca:		/* STRR,2 (*)a */
			case 0xcb:		/* STRR,3 (*)a */
				s2650_ICount -= 9;
				REL_EA(S.page);
				M_STR( S.ea, S.reg[S.r] );
				break;

			case 0xcc:		/* STRA,0 (*)a(,X) */
			case 0xcd:		/* STRA,1 (*)a(,X) */
			case 0xce:		/* STRA,2 (*)a(,X) */
			case 0xcf:		/* STRA,3 (*)a(,X) */
				s2650_ICount -= 12;
				ABS_EA();
				M_STR( S.ea, S.reg[S.r] );
				break;

			case 0xd0:		/* RRL,0 */
			case 0xd1:		/* RRL,1 */
			case 0xd2:		/* RRL,2 */
			case 0xd3:		/* RRL,3 */
				s2650_ICount -= 6;
				M_RRL( S.reg[S.r] );
				break;

			case 0xd4:		/* WRTE,0 v */
			case 0xd5:		/* WRTE,1 v */
			case 0xd6:		/* WRTE,2 v */
			case 0xd7:		/* WRTE,3 v */
				s2650_ICount -= 9;
				s2650_write_port( ARG(), S.reg[S.r] );
				break;

			case 0xd8:		/* BIRR,0 (*)a */
			case 0xd9:		/* BIRR,1 (*)a */
			case 0xda:		/* BIRR,2 (*)a */
			case 0xdb:		/* BIRR,3 (*)a */
				s2650_ICount -= 9;
				M_BRR( ++S.reg[S.r] );
				break;

			case 0xdc:		/* BIRA,0 (*)a */
			case 0xdd:		/* BIRA,1 (*)a */
			case 0xde:		/* BIRA,2 (*)a */
			case 0xdf:		/* BIRA,3 (*)a */
				s2650_ICount -= 9;
				M_BRA( ++S.reg[S.r] );
				break;

			case 0xe0:		/* COMZ,0 */
			case 0xe1:		/* COMZ,1 */
			case 0xe2:		/* COMZ,2 */
			case 0xe3:		/* COMZ,3 */
				s2650_ICount -= 6;
				M_COM( R0, S.reg[S.r] );
				break;

			case 0xe4:		/* COMI,0 v */
			case 0xe5:		/* COMI,1 v */
			case 0xe6:		/* COMI,2 v */
			case 0xe7:		/* COMI,3 v */
				s2650_ICount -= 6;
				M_COM( S.reg[S.r], ARG() );
				break;

			case 0xe8:		/* COMR,0 (*)a */
			case 0xe9:		/* COMR,1 (*)a */
			case 0xea:		/* COMR,2 (*)a */
			case 0xeb:		/* COMR,3 (*)a */
				s2650_ICount -= 9;
				REL_EA(S.page);
				M_COM( S.reg[S.r], RDMEM(S.ea) );
				break;

			case 0xec:		/* COMA,0 (*)a(,X) */
			case 0xed:		/* COMA,1 (*)a(,X) */
			case 0xee:		/* COMA,2 (*)a(,X) */
			case 0xef:		/* COMA,3 (*)a(,X) */
				s2650_ICount -= 12;
				ABS_EA();
				M_COM( S.reg[S.r], RDMEM(S.ea) );
				break;

			case 0xf0:		/* WRTD,0 */
			case 0xf1:		/* WRTD,1 */
			case 0xf2:		/* WRTD,2 */
			case 0xf3:		/* WRTD,3 */
				s2650_ICount -= 6;
				s2650_write_port(S2650_DATA_PORT, S.reg[S.r]);
				break;

			case 0xf4:		/* TMI,0  v */
			case 0xf5:		/* TMI,1  v */
			case 0xf6:		/* TMI,2  v */
			case 0xf7:		/* TMI,3  v */
				s2650_ICount -= 9;
				M_TMI( S.reg[S.r] );
				break;

			case 0xf8:		/* BDRR,0 (*)a */
			case 0xf9:		/* BDRR,1 (*)a */
			case 0xfa:		/* BDRR,2 (*)a */
			case 0xfb:		/* BDRR,3 (*)a */
				s2650_ICount -= 9;
				M_BRR( --S.reg[S.r] );
				break;

			case 0xfc:		/* BDRA,0 (*)a */
			case 0xfd:		/* BDRA,1 (*)a */
			case 0xfe:		/* BDRA,2 (*)a */
			case 0xff:		/* BDRA,3 (*)a */
				s2650_ICount -= 9;
				M_BRA( --S.reg[S.r] );
				break;
		}
	} while( s2650_ICount > 0 );

	return cycles - s2650_ICount;
}
Example #6
0
void radix_reader(CL_FORM *base)
{
	if(CL_TRUEP(SYMVAL(Slisp, 418)))	/* *READ-SUPPRESS* */
	{
		COPY(ARG(0), ARG(3));
		LOAD_SYMBOL(SYMBOL(Slisp, 48), ARG(4));	/* T */
		LOAD_NIL(ARG(5));
		LOAD_SYMBOL(SYMBOL(Slisp, 48), ARG(6));	/* T */
		read_char1(ARG(3));
		COPY(ARG(0), ARG(4));
		COPY(ARG(3), ARG(5));
		read_token(ARG(4));
		LOAD_NIL(ARG(0));
	}
	else
	{
		if(CL_TRUEP(ARG(2)))
		{
			LOAD_FIXNUM(ARG(3), 2, ARG(3));
			COPY(ARG(2), ARG(4));
			LOAD_FIXNUM(ARG(5), 36, ARG(5));
			Fle(ARG(3), 3);
			if(CL_TRUEP(ARG(3)))
			{
				COPY(ARG(2), ARG(3));
				BIND_SPECIAL(SYMBOL(Slisp, 417), ARG(3));	/* *READ-BASE* */
				COPY(ARG(0), ARG(3));
				LOAD_SYMBOL(SYMBOL(Slisp, 48), ARG(4));	/* T */
				LOAD_NIL(ARG(5));
				LOAD_SYMBOL(SYMBOL(Slisp, 48), ARG(6));	/* T */
				read1(ARG(3));
				RESTORE_SPECIAL;
				if(CL_FIXNUMP(ARG(3)))
				{
				}
				else
				{
					LOAD_SMSTR((CL_FORM *)&Kradix_reader[0], ARG(4));	/* #~A (base ~D) value is not a rational: ~S. */
					COPY(ARG(1), ARG(5));
					COPY(ARG(2), ARG(6));
					COPY(ARG(3), ARG(7));
					Ferror(ARG(4), 4);
				}
				COPY(ARG(3), ARG(0));
			}
			else
			{
				LOAD_SMSTR((CL_FORM *)&Kradix_reader[2], ARG(0));	/* Illegal radix for #R: ~D. */
				COPY(ARG(2), ARG(1));
				Ferror(ARG(0), 2);
			}
		}
		else
		{
			LOAD_SMSTR((CL_FORM *)&Kradix_reader[4], ARG(0));	/* Radix missing in #R. */
			Ferror(ARG(0), 1);
		}
	}
}
Example #7
0
void IrcChannel::setEncrypted(bool encrypted)
{
    _encrypted = encrypted;
    SYNC(ARG(encrypted))
    emit encryptedSet(encrypted);
}
Example #8
0
void unparse_unix_enough(CL_FORM *base)
{
	LOAD_NIL(ARG(2));
	LOAD_NIL(ARG(3));
	ALLOC_CONS(ARG(4), ARG(2), ARG(3), ARG(2));
	COPY(ARG(0), ARG(3));
	Ppathname_directory(ARG(3));
	COPY(ARG(1), ARG(4));
	Ppathname_directory(ARG(4));
	COPY(ARG(4), ARG(5));
	Flength(ARG(5));
	COPY(ARG(5), ARG(6));
	LOAD_FIXNUM(ARG(7), 1, ARG(7));
	Fgt(ARG(6), 2);
	if(CL_TRUEP(ARG(6)))
	{
		COPY(ARG(3), ARG(6));
		Flength(ARG(6));
		COPY(ARG(5), ARG(7));
		Fge(ARG(6), 2);
		if(CL_TRUEP(ARG(6)))
		{
			COPY(ARG(3), ARG(6));
			LOAD_FIXNUM(ARG(7), 0, ARG(7));
			COPY(ARG(5), ARG(8));
			subseq1(ARG(6));
			COPY(ARG(4), ARG(7));
			compare_component(ARG(6));
		}
		else
		{
			goto ELSE1;
		}
	}
	else
	{
		goto ELSE1;
	}
	if(CL_TRUEP(ARG(6)))
	{
		LOAD_SYMBOL(SYMBOL(Slisp, 270), ARG(6));	/* RELATIVE */
		COPY(ARG(5), ARG(7));
		COPY(ARG(3), ARG(8));
		Fnthcdr(ARG(7));
		ALLOC_CONS(ARG(8), ARG(6), ARG(7), ARG(6));
	}
	else
	{
		ELSE1:;
		if(CL_CONSP(ARG(3)))
		{
			COPY(GET_CAR(ARG(3)), ARG(6));
		}
		else
		{
			if(CL_TRUEP(ARG(3)))
			{
				LOAD_SMSTR((CL_FORM *)&KClisp[264], ARG(6));	/* ~a is not a list */
				COPY(ARG(3), ARG(7));
				Ferror(ARG(6), 2);
			}
			else
			{
				COPY(ARG(3), ARG(6));
			}
		}
		if(CL_SYMBOLP(ARG(6)) && GET_SYMBOL(ARG(6)) == SYMBOL(Slisp, 267))	/* ABSOLUTE */
		{
			COPY(ARG(3), ARG(6));
		}
		else
		{
			LOAD_SMSTR((CL_FORM *)&KClisp[232], ARG(6));	/* ~S cannot be represented relative to ~S */
			COPY(ARG(0), ARG(7));
			COPY(ARG(1), ARG(8));
			Ferror(ARG(6), 3);
		}
	}
	COPY(ARG(6), ARG(7));
	unparse_unix_directory_list(ARG(7));
	COPY(ARG(2), ARG(8));
	add_q(ARG(7));
	COPY(ARG(0), ARG(3));
	Ppathname_version(ARG(3));
	if(CL_TRUEP(ARG(3)))
	{
		if(CL_SYMBOLP(ARG(3)) && GET_SYMBOL(ARG(3)) == SYMBOL(Slisp, 269))	/* NEWEST */
		{
			LOAD_NIL(ARG(4));
		}
		else
		{
			LOAD_SYMBOL(SYMBOL(Slisp, 48), ARG(4));	/* T */
		}
	}
	else
	{
		LOAD_NIL(ARG(4));
	}
	COPY(ARG(0), ARG(5));
	Ppathname_type(ARG(5));
	if(CL_TRUEP(ARG(4)))
	{
		COPY(ARG(4), ARG(6));
	}
	else
	{
		if(CL_TRUEP(ARG(5)))
		{
			if(CL_SYMBOLP(ARG(5)) && GET_SYMBOL(ARG(5)) == SYMBOL(Slisp, 266))	/* UNSPECIFIC */
			{
				LOAD_NIL(ARG(6));
			}
			else
			{
				LOAD_SYMBOL(SYMBOL(Slisp, 48), ARG(6));	/* T */
			}
		}
		else
		{
			LOAD_NIL(ARG(6));
		}
	}
	COPY(ARG(0), ARG(7));
	Ppathname_name(ARG(7));
	if(CL_TRUEP(ARG(6)))
	{
		COPY(ARG(6), ARG(8));
	}
	else
	{
		if(CL_TRUEP(ARG(7)))
		{
			COPY(ARG(7), ARG(8));
			COPY(ARG(1), ARG(9));
			Ppathname_name(ARG(9));
			compare_component(ARG(8));
			if(CL_TRUEP(ARG(8)))
			{
				LOAD_NIL(ARG(8));
			}
			else
			{
				LOAD_SYMBOL(SYMBOL(Slisp, 48), ARG(8));	/* T */
			}
		}
		else
		{
			LOAD_NIL(ARG(8));
		}
	}
	if(CL_TRUEP(ARG(8)))
	{
		if(CL_TRUEP(ARG(7)))
		{
		}
		else
		{
			LOAD_SMSTR((CL_FORM *)&KClisp[232], ARG(9));	/* ~S cannot be represented relative to ~S */
			COPY(ARG(0), ARG(10));
			COPY(ARG(1), ARG(11));
			Ferror(ARG(9), 3);
		}
		COPY(ARG(7), ARG(9));
		unparse_unix_piece(ARG(9));
		COPY(ARG(2), ARG(10));
		add_q(ARG(9));
	}
	if(CL_TRUEP(ARG(6)))
	{
		if(CL_TRUEP(ARG(5)))
		{
			LOAD_NIL(ARG(9));
		}
		else
		{
			LOAD_SYMBOL(SYMBOL(Slisp, 48), ARG(9));	/* T */
		}
		if(CL_TRUEP(ARG(9)))
		{
			goto THEN2;
		}
		else
		{
		}	/* UNSPECIFIC */
		if(CL_SYMBOLP(ARG(5)) && GET_SYMBOL(ARG(5)) == SYMBOL(Slisp, 266))
		{
			THEN2:;
			LOAD_SMSTR((CL_FORM *)&KClisp[232], ARG(9));	/* ~S cannot be represented relative to ~S */
			COPY(ARG(0), ARG(10));
			COPY(ARG(1), ARG(11));
			Ferror(ARG(9), 3);
		}
		LOAD_SMSTR((CL_FORM *)&Kunparse_unix_enough[0], ARG(9));	/* . */
		COPY(ARG(2), ARG(10));
		add_q(ARG(9));
		COPY(ARG(5), ARG(9));
		unparse_unix_piece(ARG(9));
		COPY(ARG(2), ARG(10));
		add_q(ARG(9));
	}
	if(CL_TRUEP(ARG(4)))
	{
		if(CL_SYMBOLP(ARG(3)) && GET_SYMBOL(ARG(3)) == SYMBOL(Slisp, 271))	/* WILD */
		{
			LOAD_SMSTR((CL_FORM *)&Kunparse_unix_enough[2], ARG(9));	/* .* */
			COPY(ARG(2), ARG(10));
			add_q(ARG(9));
		}
		else
		{
			if(CL_FIXNUMP(ARG(3)))
			{
				LOAD_NIL(ARG(9));
				LOAD_SMSTR((CL_FORM *)&Kunparse_unix_enough[4], ARG(10));	/* .~D */
				COPY(ARG(3), ARG(11));
				Fformat(ARG(9), 3);
				mv_count = 1;
				COPY(ARG(2), ARG(10));
				add_q(ARG(9));
			}
			else
			{
				LOAD_SMSTR((CL_FORM *)&KClisp[232], ARG(9));	/* ~S cannot be represented relative to ~S */
				COPY(ARG(0), ARG(10));
				COPY(ARG(1), ARG(11));
				Ferror(ARG(9), 3);
			}
		}
	}
	LOAD_GLOBFUN(&CFconcatenate, ARG(3));
	LOAD_SYMBOL(SYMBOL(Slisp, 40), ARG(4));	/* SIMPLE-STRING */
	COPY(GET_CAR(ARG(2)), ARG(5));
	Fapply(ARG(3), 3);
	COPY(ARG(3), ARG(0));
}
Example #9
0
void syscall_handler(struct intr_frame *f) {
    // Run system call
    ARG(uint32_t, syscall_id, f, 0);
    handlers[syscall_id](f);
}
Example #10
0
void FFI_lisp_character(CL_FORM *base)
{
	LOAD_BOOL(CL_C_CHAR_P(ARG(0)), ARG(1));
	if(CL_TRUEP(ARG(1)))
	{
		goto THEN1;
	}
	else
	{
	}
	if(CL_C_UNSIGNED_CHAR_P(ARG(0)))
	{
		THEN1:;
		rt_make_lisp_character(ARG(0));
	}
	else
	{
		LOAD_SMSTR((CL_FORM *)&KClisp[240], ARG(1));	/* ~&Error in ~A: ~?~% */
		LOAD_SMSTR((CL_FORM *)&KClisp[10], ARG(2));	/* LISP-CHARACTER */
		LOAD_SMSTR((CL_FORM *)&KClisp[8], ARG(3));	/* The evaluated value ~S is not of type c-<char>. */
		COPY(ARG(0), ARG(4));
		Flist(ARG(4), 1);
		Ferror(ARG(1), 4);
	}
}
Example #11
0
static int
Netlist (int argc, char **argv, Coord x, Coord y)
{
  NFunc func;
  int i, j;
  LibraryMenuType *net;
  LibraryEntryType *pin;
  int net_found = 0;
  int pin_found = 0;
#if defined(USE_RE)
  int use_re = 0;
#endif
#if defined(HAVE_REGCOMP)
  regex_t elt_pattern;
  regmatch_t match;
#endif
#if defined(HAVE_RE_COMP)
  char *elt_pattern;
#endif

  if (!PCB)
    return 1;
  if (argc == 0)
    {
      Message (netlist_syntax);
      return 1;
    }
  if (strcasecmp (argv[0], "find") == 0)
    func = netlist_find;
  else if (strcasecmp (argv[0], "select") == 0)
    func = netlist_select;
  else if (strcasecmp (argv[0], "rats") == 0)
    func = netlist_rats;
  else if (strcasecmp (argv[0], "norats") == 0)
    func = netlist_norats;
  else if (strcasecmp (argv[0], "clear") == 0)
    {
      func = netlist_clear;
      if (argc == 1)
	{
	  netlist_clear (NULL, NULL);
	  return 0;
	}
    }
  else if (strcasecmp (argv[0], "style") == 0)
    func = (NFunc)netlist_style;
  else if (strcasecmp (argv[0], "add") == 0)
    {
      /* Add is different, because the net/pin won't already exist.  */
      return netlist_add (ARG(1), ARG(2));
    }
  else if (strcasecmp (argv[0], "sort") == 0)
    {
      sort_netlist ();
      return 0;
    }
  else if (strcasecmp (argv[0], "freeze") == 0)
    {
      netlist_frozen ++;
      return 0;
    }
  else if (strcasecmp (argv[0], "thaw") == 0)
    {
      if (netlist_frozen > 0)
	{
	  netlist_frozen --;
	  if (netlist_needs_update)
	    NetlistChanged (0);
	}
      return 0;
    }
  else if (strcasecmp (argv[0], "forcethaw") == 0)
    {
      netlist_frozen = 0;
      if (netlist_needs_update)
	NetlistChanged (0);
      return 0;
    }
  else
    {
      Message (netlist_syntax);
      return 1;
    }

#if defined(USE_RE)
  if (argc > 1)
    {
      int result;
      use_re = 1;
      for (i = 0; i < PCB->NetlistLib.MenuN; i++)
	{
	  net = PCB->NetlistLib.Menu + i;
	  if (strcasecmp (argv[1], net->Name + 2) == 0)
	    use_re = 0;
	}
      if (use_re)
	{
#if defined(HAVE_REGCOMP)
	  result =
	    regcomp (&elt_pattern, argv[1],
		     REG_EXTENDED | REG_ICASE | REG_NOSUB);
	  if (result)
	    {
	      char errorstring[128];

	      regerror (result, &elt_pattern, errorstring, 128);
	      Message (_("regexp error: %s\n"), errorstring);
	      regfree (&elt_pattern);
	      return (1);
	    }
#endif
#if defined(HAVE_RE_COMP)
	  if ((elt_pattern = re_comp (argv[1])) != NULL)
	    {
	      Message (_("re_comp error: %s\n"), elt_pattern);
	      return (false);
	    }
#endif
	}
    }
#endif

  for (i = PCB->NetlistLib.MenuN-1; i >= 0; i--)
    {
      net = PCB->NetlistLib.Menu + i;

      if (argc > 1)
	{
#if defined(USE_RE)
	  if (use_re)
	    {
#if defined(HAVE_REGCOMP)
	      if (regexec (&elt_pattern, net->Name + 2, 1, &match, 0) != 0)
		continue;
#endif
#if defined(HAVE_RE_COMP)
	      if (re_exec (net->Name + 2) != 1)
		continue;
#endif
	    }
	  else
#endif
	  if (strcasecmp (net->Name + 2, argv[1]))
	    continue;
	}
      net_found = 1;

      pin = 0;
      if (func == (void *)netlist_style)
	{
	  netlist_style (net, ARG(2));
	}
      else if (argc > 2)
	{
	  int l = strlen (argv[2]);
	  for (j = net->EntryN-1; j >= 0 ; j--)
	    if (strcasecmp (net->Entry[j].ListEntry, argv[2]) == 0
		|| (strncasecmp (net->Entry[j].ListEntry, argv[2], l) == 0
		    && net->Entry[j].ListEntry[l] == '-'))
	      {
		pin = net->Entry + j;
		pin_found = 1;
		func (net, pin);
	      }
	}
      else
	func (net, 0);
    }

  if (argc > 2 && !pin_found)
    {
      gui->log ("Net %s has no pin %s\n", argv[1], argv[2]);
      return 1;
    }
  else if (!net_found)
    {
      gui->log ("No net named %s\n", argv[1]);
    }
#ifdef HAVE_REGCOMP
  if (use_re)
    regfree (&elt_pattern);
#endif

  return 0;
}
Example #12
0
void subsetp1(CL_FORM *base)
{
    GEN_HEAPVAR(ARG(3), ARG(5));
    if(CL_TRUEP(ARG(2)))
    {
    }
    else
    {
        if(CL_TRUEP(INDIRECT(ARG(3))))
        {
            GEN_CLOSURE(array, ARG(5), 4, Z3_lambda, -1);
            COPY(ARG(3), &array[3]);
            LOAD_CLOSURE(array, ARG(5));
            COPY(ARG(5), ARG(2));
        }
        else
        {
            GEN_STATIC_GLOBAL_FUNARG(extern_closure, Feql, 2);
            LOAD_GLOBFUN(&extern_closure, ARG(2));
        }
    }
    LOAD_NIL(ARG(5));
    COPY(ARG(0), ARG(6));
M1_1:
    ;
    if(CL_ATOMP(ARG(6)))
    {
        LOAD_NIL(ARG(5));
        LOAD_SYMBOL(SYMBOL(Slisp, 48), ARG(0));	/* T */
        goto RETURN1;
    }
    COPY(ARG(6), ARG(7));
    COPY(GET_CAR(ARG(7)), ARG(5));
    if(CL_TRUEP(ARG(4)))
    {
        COPY(ARG(4), ARG(7));
        COPY(ARG(5), ARG(8));
        Ffuncall(ARG(7), 2);
        mv_count = 1;
    }
    else
    {
        COPY(ARG(5), ARG(7));
    }
    COPY(ARG(1), ARG(8));
    COPY(ARG(2), ARG(9));
    COPY(ARG(4), ARG(10));
    COPY(ARG(7), ARG(11));
    COPY(ARG(8), ARG(12));
    COPY(ARG(9), ARG(13));
    LOAD_NIL(ARG(14));
    COPY(ARG(10), ARG(15));
    member1(ARG(11));
    if(CL_TRUEP(ARG(11)))
    {
    }
    else
    {
        LOAD_NIL(ARG(0));
        goto RETURN1;
    }
    COPY(ARG(6), ARG(7));
    COPY(GET_CDR(ARG(7)), ARG(6));
    goto M1_1;
RETURN1:
    ;
}
Example #13
0
FontGen::FontGen(int argc, char **argv)
    :	hf(NULL)
    ,	dc(NULL)
    ,	dib(NULL)
    ,	oldbitmap(NULL)
    ,	fontStyle(0)
    ,	fontSize(16)
    ,	firstChar(' ')
    ,	lastChar(126)
    ,	isBold(false)
    ,	isUnderline(false)
    ,	isItalic(false)
    ,	isStrike(false)
    ,	compressTga(false)
    ,	monochrome(false)
    ,	cppFormat(false)
{
    int arg;

    fontName[0] = 0;
    fontWinName[0] = 0;

    for (arg = 1; arg < argc; arg++) {
        if (!stricmp(ARG(arg), "-size")) {
            fontSize = atoi(ARG(++arg));
        }
        else if (!stricmp(ARG(arg), "-styles")) {
            const char *styles = ARG(++arg);

            fontStyle = 0;
            if (strstr(styles, "bold"))
                isBold = true;
            if (strstr(styles, "italic"))
                isItalic = true;
            if (strstr(styles, "underline"))
                isUnderline = true;
            if (strstr(styles, "strikeout"))
                isStrike = true;
        }
        else if (!stricmp(ARG(arg), "-first")) {
            firstChar = atoi(ARG(++arg));
        }
        else if (!stricmp(ARG(arg), "-last")) {
            lastChar = atoi(ARG(++arg));
        }
        else if (!stricmp(ARG(arg), "-winname")) {
            strcpy(fontWinName, ARG(++arg));
        }
        else if (!stricmp(ARG(arg), "-name")) {
            strcpy(fontName, ARG(++arg));
        }
        else if (!stricmp(ARG(arg), "-tga")) {
            const char *parms = ARG(++arg);
            if (strstr(parms, "packed"))
                compressTga = true;
            if (strstr(parms, "8bit")) {
                monochrome = true;
            }
        }
        else if (!stricmp(ARG(arg), "-cpp")) {
            cppFormat = true;
        }
    }

    // Check validity...
    if ( firstChar >= lastChar ) {
        Error( "ERROR: First char (%d) is >= last char (%d)\n", firstChar, lastChar );
    }
    if ( fontSize <= 0 ) {
        Error( "ERROR: Font size (%d) is <= 0\n", fontSize );
    }
    if ( !fontName[0] ) {
        Error( "ERROR: No font name specified (do it with -name)\n" );
    }
    if ( !fontWinName[0] ) {
        Error( "ERROR: No windows font name specified (do it with -winname)\n" );
    }
}
Example #14
0
mos_METHOD(bcMethod,decompile)
{
  static mos_value stk[_stk_SIZE];
  static mos_value *sp = stk + (_stk_SIZE-1);

#define TOP *sp
#define PUSH(X) *(-- sp) = (X)
#define DUP() (sp[-1] = *sp, sp --)
#define POP() *(sp ++)
#define PUSHN(N) (sp -= (N))
#define POPN(N) (sp += (N))
#define ARG() (pc += 4, ((unsigned long) pc[-4] | ((unsigned long) pc[-3] << 8) | ((unsigned long) pc[-2] << 16) | ((unsigned long) pc[-1] << 24)))

  const unsigned char *pc;
  mos_value *fp;
  mos_value meth = mos_RCVR;
  mos_value bytecodes = mos_send(meth, mos_s(bytecodes));

  /* Our constants vector */
  mos_value *constants = mos_vector_V(mos_send(meth, mos_s(constants)));

  /* Our arguments ident vector */
  mos_value *args = mos_vector_V(mos_send(meth, mos_s(arguments)));

  /* Out locals ident vector */
  mos_value *locals = mos_vector_V(mos_send(meth, mos_s(locals)));

  /* An array to hold the method body */
  mos_value body = mos_vector_make(0, 0);
  mos_value sel;

  /* Save a frame pointer */
  fp = sp;
  // restart:
  pc = (void*) mos_string_V(bytecodes);

 again:
  switch ( (mos_bc) *(pc ++) ) {
  case mos_bc_nop:
    goto again;
    
  case mos_bc_restart:
    PUSH(mos_exprSend(mos_undef, mos_s(_restart), 0));
    goto again;
    
  case mos_bc_object:
    PUSH(mos_exprObject(mos_vector_make(0,0), mos_vector_make(0,0)));
    goto again;
    
  case mos_bc_block:
    PUSH(mos_exprBlock(mos_vector_make(0,0), mos_vector_make(0,0), mos_vector_make(0,0)));
    goto again;
    
  case mos_bc_method:
    PUSH(mos_exprMethod(mos_vector_make(0,0), mos_vector_make(0,0), mos_vector_make(0,0)));
    goto again;
    
  case mos_bc_dup:
    DUP();
    goto again;
    
  case mos_bc_pop:
    /* pop only occurs at the end of stmt */
    mos_send(body, mos_s(append_), POP());
    goto again;
    
  case mos_bc_rtn:
  case mos_bc_rtnBlk:
    mos_send(body, mos_s(append_), mos_exprSend(mos_undef, mos_s(__RTN__), 1, POP()));
    break;
    
  case mos_bc_const:
    PUSH(mos_exprSend(mos_undef, mos_s(_constants), 0));
    goto again;
    
  case mos_bc_lobby:
    PUSH(mos_exprSend(mos_undef, mos_s(_), 0));
    goto again;
    
  case mos_bc_msg:
    PUSH(mos_exprSend(mos_undef, mos_s(_msg), 0));
    goto again;
    
  case mos_bc_rcvr: /* msg | msg->rcvr */
    (void) POP();
    PUSH(mos_exprSend(mos_undef, mos_s(self), 0));
    goto again;
  case mos_bc_rcvrSet: /* msg value | value */
    sel = POP();
    TOP = mos_exprSend(mos_undef, mos_s(self_), 1, sel);
    goto again;
    
  case mos_bc_arg_: /* | args[I] */
    sel = args[ARG()];
    PUSH(mos_exprSend(mos_undef, sel, 0));
    goto again;

  case mos_bc_argSet_: /* x | rcvr */
    sel = args[ARG()];
    sel = mos_setter_selector(sel);
    TOP = mos_exprSend(mos_undef, sel, 1, TOP);
    goto again;
    
  case mos_bc_locs_: /* | ... */
    goto again;

  case mos_bc_loc_: /* | local[I] */
    sel = locals[ARG() - 1];
    PUSH(mos_exprSend(mos_undef, sel, 0));
    goto again;
    
  case mos_bc_locSet_: /* locSet:<i> value | */
    sel = locals[ARG() - 1];
    sel = mos_setter_selector(sel);
    TOP = mos_exprSend(mos_undef, sel, 1, TOP);
    goto again;

  case mos_bc_lit_: /* | constant[I] */
    PUSH(mos_exprConstant(constants[ARG()]));
    goto again;
    
  case mos_bc_memo_:
  case mos_bc_memoval_:
    /* IMPLIMENT */
    goto again;

  case mos_bc_send_: /* sel rcvr args ... | result */ 
    {
      int nargs = ARG();
      mos_value sel = POP();
      mos_value rcvr = POP();
      mos_value args = mos_vector_make(nargs, sp);
      rcvr = mos_exprSendV(rcvr, sel, args);
      POPN(nargs);
      PUSH(rcvr);
    }
    goto again;

  case mos_bc_sendDir_: /* sel cntx rcvr args ... | result */
    {
      int nargs = ARG();
      mos_value sel = POP();
      mos_value cntx = POP();
      mos_value rcvr = POP();
      mos_value args = mos_vector_make(nargs, sp);
      rcvr = mos_exprSend_V(cntx, rcvr, sel, args);
      POPN(nargs);
      PUSH(rcvr);
    }
    goto again;

  default:
    fprintf(stderr, "\n:bcDecomp.c: unknown bytecode %d\n", pc[-1]);
    break;
  }
  
  sp = fp;

  /* Create a exprMethod object */
  {
    mos_value args = mos_send(meth, mos_s(arguments));
    mos_value locals = mos_send(meth, mos_s(locals));
   
    mos_return(mos_exprMethod(args, locals, body));
  }
}
Example #15
0
void Ppackage_used_by_list(CL_FORM *base)
{
	COPY(ARG(0), ARG(1));
	LOAD_SYMBOL(SYMBOL(Slisp, 354), ARG(2));	/* PACKAGE */
	rt_struct_typep(ARG(1));
	if(CL_TRUEP(ARG(1)))
	{
		COPY(OFFSET(AR_BASE(GET_FORM(ARG(0))), 6 + 1), ARG(0));
	}
	else
	{
		COPY(SYMVAL(Slisp, 352), ARG(1));	/* NO_STRUCT */
		COPY(ARG(0), ARG(2));
		LOAD_SYMBOL(SYMBOL(Slisp, 354), ARG(3));	/* PACKAGE */
		Ferror(ARG(1), 3);
	}
}
Example #16
0
void rassoc_if1(CL_FORM *base)
{
	LOAD_NIL(ARG(3));
	COPY(ARG(1), ARG(4));
	M1_1:;
	if(CL_ATOMP(ARG(4)))
	{
		LOAD_NIL(ARG(3));
		COPY(ARG(3), ARG(0));
		goto RETURN2;
	}
	COPY(ARG(4), ARG(5));
	COPY(GET_CAR(ARG(5)), ARG(3));
	COPY(ARG(0), ARG(5));
	if(CL_TRUEP(ARG(2)))
	{
		COPY(ARG(2), ARG(6));
		if(CL_CONSP(ARG(3)))
		{
			COPY(GET_CDR(ARG(3)), ARG(7));
		}
		else
		{
			if(CL_TRUEP(ARG(3)))
			{
				LOAD_SMSTR((CL_FORM *)&KClisp[262], ARG(7));	/* ~a is not a list */
				COPY(ARG(3), ARG(8));
				Ferror(ARG(7), 2);
			}
			else
			{
				COPY(ARG(3), ARG(7));
			}
		}
		Ffuncall(ARG(6), 2);
		mv_count = 1;
	}
	else
	{
		if(CL_CONSP(ARG(3)))
		{
			COPY(GET_CDR(ARG(3)), ARG(6));
		}
		else
		{
			if(CL_TRUEP(ARG(3)))
			{
				LOAD_SMSTR((CL_FORM *)&KClisp[262], ARG(6));	/* ~a is not a list */
				COPY(ARG(3), ARG(7));
				Ferror(ARG(6), 2);
			}
			else
			{
				COPY(ARG(3), ARG(6));
			}
		}
	}
	Ffuncall(ARG(5), 2);
	mv_count = 1;
	if(CL_TRUEP(ARG(5)))
	{
		COPY(ARG(3), ARG(0));
		goto RETURN1;
	}
	COPY(ARG(4), ARG(5));
	COPY(GET_CDR(ARG(5)), ARG(4));
	goto M1_1;
	RETURN2:;
	RETURN1:;
}
Example #17
0
void unintern1(CL_FORM *base)
{
	LOAD_NIL(ARG(2));
	LOAD_NIL(ARG(3));
	if(CL_SYMBOLP(ARG(0)))
	{
		LOAD_SMSTR(SYM_NAME(ARG(0)), ARG(4));
	}
	else
	{
		if(CL_TRUEP(ARG(0)))
		{
			COPY(SYMVAL(Slisp, 676), ARG(4));	/* SYM_EXPECTED */
			COPY(ARG(0), ARG(5));
			Ferror(ARG(4), 2);
		}
		else
		{
			LOAD_SMSTR((CL_FORM *)&KClisp[266], ARG(4));	/* NIL */
		}
	}
	LOAD_NIL(ARG(5));
	COPY(ARG(1), ARG(6));
	coerce_to_package(ARG(6));
	COPY(ARG(6), ARG(1));
	COPY(ARG(4), ARG(6));
	COPY(ARG(1), ARG(7));
	find_symbol1(ARG(6));
	COPY(&mv_buf[0], ARG(7));
	{
		int nargs;
		nargs = 2;
		mv_count = 1;
		{
			switch(nargs)
			{
				case 0:
				LOAD_NIL(ARG(6));
				case 1:
				LOAD_NIL(ARG(7));
				nargs = 2;
			}
			COPY(ARG(6), ARG(2));
			COPY(ARG(7), ARG(3));
		}
	}
	if(EQ(ARG(2), ARG(0)))
	{
		LOAD_BOOL(CL_SYMBOLP(ARG(3)) && GET_SYMBOL(ARG(3)) == SYMBOL(Slisp, 384), ARG(6));	/* INTERNAL */
		if(CL_TRUEP(ARG(6)))
		{
			goto THEN1;
		}
		else
		{
		}	/* EXTERNAL */
	}
	else
	{
		goto ELSE2;
	}
	if(CL_SYMBOLP(ARG(3)) && GET_SYMBOL(ARG(3)) == SYMBOL(Slisp, 385))
	{
		THEN1:;
		if(CL_SYMBOLP(ARG(3)) && GET_SYMBOL(ARG(3)) == SYMBOL(Slisp, 385))	/* EXTERNAL */
		{
			COPY(ARG(1), ARG(6));
			COPY(ARG(6), ARG(7));
			COPY(ARG(7), ARG(8));
			LOAD_SYMBOL(SYMBOL(Slisp, 354), ARG(9));	/* PACKAGE */
			rt_struct_typep(ARG(8));
			if(CL_TRUEP(ARG(8)))
			{
				COPY(OFFSET(AR_BASE(GET_FORM(ARG(7))), 3 + 1), ARG(5));
			}
			else
			{
				COPY(SYMVAL(Slisp, 352), ARG(5));	/* NO_STRUCT */
				COPY(ARG(7), ARG(6));
				LOAD_SYMBOL(SYMBOL(Slisp, 354), ARG(7));	/* PACKAGE */
				Ferror(ARG(5), 3);
			}
		}
		else
		{
			COPY(ARG(1), ARG(6));
			COPY(ARG(6), ARG(7));
			COPY(ARG(7), ARG(8));
			LOAD_SYMBOL(SYMBOL(Slisp, 354), ARG(9));	/* PACKAGE */
			rt_struct_typep(ARG(8));
			if(CL_TRUEP(ARG(8)))
			{
				COPY(OFFSET(AR_BASE(GET_FORM(ARG(7))), 2 + 1), ARG(5));
			}
			else
			{
				COPY(SYMVAL(Slisp, 352), ARG(5));	/* NO_STRUCT */
				COPY(ARG(7), ARG(6));
				LOAD_SYMBOL(SYMBOL(Slisp, 354), ARG(7));	/* PACKAGE */
				Ferror(ARG(5), 3);
			}
		}
		COPY(ARG(1), ARG(6));
		LOAD_SYMBOL(SYMBOL(Slisp, 354), ARG(7));	/* PACKAGE */
		rt_struct_typep(ARG(6));
		if(CL_TRUEP(ARG(6)))
		{
			COPY(OFFSET(AR_BASE(GET_FORM(ARG(1))), 4 + 1), ARG(6));
		}
		else
		{
			COPY(SYMVAL(Slisp, 352), ARG(6));	/* NO_STRUCT */
			COPY(ARG(1), ARG(7));
			LOAD_SYMBOL(SYMBOL(Slisp, 354), ARG(8));	/* PACKAGE */
			Ferror(ARG(6), 3);
		}
		COPY(ARG(0), ARG(7));
		COPY(ARG(6), ARG(8));
		LOAD_NIL(ARG(9));
		LOAD_NIL(ARG(10));
		LOAD_NIL(ARG(11));
		member1(ARG(7));
		if(CL_TRUEP(ARG(7)))
		{
			LOAD_FIXNUM(ARG(6), 0, ARG(6));
			LOAD_NIL(ARG(7));
			COPY(ARG(1), ARG(8));
			LOAD_SYMBOL(SYMBOL(Slisp, 354), ARG(9));	/* PACKAGE */
			rt_struct_typep(ARG(8));
			if(CL_TRUEP(ARG(8)))
			{
				COPY(OFFSET(AR_BASE(GET_FORM(ARG(1))), 5 + 1), ARG(8));
			}
			else
			{
				COPY(SYMVAL(Slisp, 352), ARG(8));	/* NO_STRUCT */
				COPY(ARG(1), ARG(9));
				LOAD_SYMBOL(SYMBOL(Slisp, 354), ARG(10));	/* PACKAGE */
				Ferror(ARG(8), 3);
			}
			M1_1:;
			if(CL_ATOMP(ARG(8)))
			{
				LOAD_NIL(ARG(7));
				goto RETURN1;
			}
			COPY(ARG(8), ARG(9));
			COPY(GET_CAR(ARG(9)), ARG(7));
			COPY(ARG(4), ARG(9));
			COPY(ARG(7), ARG(10));
			find_symbol1(ARG(9));
			COPY(&mv_buf[0], ARG(10));
			{
				int nargs;
				nargs = 2;
				mv_count = 1;
				{
					switch(nargs)
					{
						case 0:
						LOAD_NIL(ARG(9));
						case 1:
						LOAD_NIL(ARG(10));
						nargs = 2;
					}
					COPY(ARG(9), ARG(2));
					COPY(ARG(10), ARG(3));
				}
			}
			if(CL_SYMBOLP(ARG(3)) && GET_SYMBOL(ARG(3)) == SYMBOL(Slisp, 385))	/* EXTERNAL */
			{
				if(CL_FIXNUMP(ARG(6)) && GET_FIXNUM(ARG(6)) == 0)
				{
					COPY(ARG(2), ARG(6));
				}
				else
				{
					if(EQ(ARG(2), ARG(6)))
					{
					}
					else
					{
						LOAD_SMSTR((CL_FORM *)&Kunintern1[0], ARG(9));	/* ~S and ~S will cause a name conflict */
						COPY(ARG(6), ARG(10));
						COPY(ARG(2), ARG(11));
						Ferror(ARG(9), 3);
					}
				}
			}
			COPY(ARG(8), ARG(9));
			COPY(GET_CDR(ARG(9)), ARG(8));
			goto M1_1;
			RETURN1:;
			COPY(ARG(1), ARG(6));
			LOAD_SYMBOL(SYMBOL(Slisp, 354), ARG(7));	/* PACKAGE */
			rt_struct_typep(ARG(6));
			if(CL_TRUEP(ARG(6)))
			{
				COPY(OFFSET(AR_BASE(GET_FORM(ARG(1))), 4 + 1), ARG(6));
			}
			else
			{
				COPY(SYMVAL(Slisp, 352), ARG(6));	/* NO_STRUCT */
				COPY(ARG(1), ARG(7));
				LOAD_SYMBOL(SYMBOL(Slisp, 354), ARG(8));	/* PACKAGE */
				Ferror(ARG(6), 3);
			}
			LOAD_SYMBOL(SYMBOL(Slisp, 392), ARG(7));	/* COUNT */
			LOAD_FIXNUM(ARG(8), 1, ARG(8));
			Flist(ARG(7), 2);
			LOAD_GLOBFUN(&CFremove, ARG(8));
			COPY(ARG(0), ARG(9));
			COPY(ARG(6), ARG(10));
			COPY(ARG(7), ARG(11));
			Fapply(ARG(8), 4);
			mv_count = 1;
			COPY(ARG(8), ARG(6));
			LOAD_FIXNUM(ARG(7), 4, ARG(7));
			COPY(ARG(1), ARG(8));
			LOAD_SYMBOL(SYMBOL(Slisp, 354), ARG(9));	/* PACKAGE */
			rt_struct_typep(ARG(8));
			if(CL_TRUEP(ARG(8)))
			{
				COPY(ARG(6), OFFSET(AR_BASE(GET_FORM(ARG(1))), 4 + 1));
			}
			else
			{
				COPY(SYMVAL(Slisp, 352), ARG(8));	/* NO_STRUCT */
				COPY(ARG(1), ARG(9));
				LOAD_SYMBOL(SYMBOL(Slisp, 354), ARG(10));	/* PACKAGE */
				Ferror(ARG(8), 3);
			}
		}
		COPY(ARG(0), ARG(6));
		COPY(ARG(5), ARG(7));
		LOAD_FIXNUM(ARG(8), 101, ARG(8));
		COPY(ARG(4), ARG(9));
		string_to_simple_string(ARG(9));
		rt_sxhash_string(ARG(9));
		COPY(ARG(9), ARG(10));
		LOAD_FIXNUM(ARG(11), 101, ARG(11));
		rt_floor(ARG(10));
		COPY(&mv_buf[0], ARG(11));
		mv_count = 1;
		{
			COPY(ARG(11), ARG(8));
		}
		del_pack_sym(ARG(6));
		if(CL_SYMBOLP(ARG(0)))
		{
			COPY(SYM_PACKAGE(ARG(0)), ARG(6));
		}
		else
		{
			if(CL_TRUEP(ARG(0)))
			{
				COPY(SYMVAL(Slisp, 676), ARG(6));	/* SYM_EXPECTED */
				COPY(ARG(0), ARG(7));
				Ferror(ARG(6), 2);
			}
			else
			{
				COPY(SYMVAL(Slisp, 679), ARG(6));	/* *NIL-PACKAGE* */
			}
		}
		if(EQ(ARG(6), ARG(1)))
		{
			COPY(ARG(0), ARG(6));
			LOAD_NIL(ARG(7));
			set_symbol_package(ARG(6));
		}
		LOAD_SYMBOL(SYMBOL(Slisp, 48), ARG(0));	/* T */
	}
	else
	{
		ELSE2:;
		LOAD_NIL(ARG(0));
	}
}
Example #18
0
void Flength(CL_FORM *base)
{
	if(CL_TRUEP(ARG(0)))
	{
		if(CL_CONSP(ARG(0)))
		{
			LOAD_FIXNUM(ARG(1), 0, ARG(1));
			COPY(ARG(0), ARG(2));
			M1_1:;
			if(CL_ATOMP(ARG(2)))
			{
				goto RETURN1;
			}
			F1plus(ARG(1));
			COPY(ARG(2), ARG(3));
			COPY(GET_CDR(ARG(3)), ARG(2));
			goto M1_1;
			RETURN1:;
			COPY(ARG(1), ARG(0));
		}
		else
		{
			if(CL_SMVECP(ARG(0)))
			{
				LOAD_FIXNUM(ARG(2), AR_SIZE(GET_FORM(ARG(0))), ARG(0));
			}
			else
			{
				COPY(ARG(0), ARG(1));
				LOAD_SYMBOL(SYMBOL(Slisp, 150), ARG(2));	/* COMPLEX-VECTOR */
				rt_struct_typep(ARG(1));
				if(CL_TRUEP(ARG(1)))
				{
					COPY(ARG(0), ARG(1));
					complex_vector_fillptr(ARG(1));
					Fminusp(ARG(1));
					if(CL_TRUEP(ARG(1)))
					{
						complex_vector_length(ARG(0));
					}
					else
					{
						complex_vector_fillptr(ARG(0));
					}
				}
				else
				{
					COPY(SYMVAL(Slisp, 58), ARG(1));	/* WRONG_TYPE */
					COPY(ARG(0), ARG(2));
					LOAD_SYMBOL(SYMBOL(Slisp, 36), ARG(3));	/* SEQUENCE */
					Ferror(ARG(1), 3);
				}
			}
		}
	}
	else
	{
		LOAD_FIXNUM(ARG(1), 0, ARG(0));
	}
}
Example #19
0
// ====================
//  PUBLIC SLOTS:
// ====================
void IrcChannel::setTopic(const QString &topic)
{
    _topic = topic;
    SYNC(ARG(topic))
    emit topicSet(topic);
}
Example #20
0
void
wsemul_sun_control(struct wsemul_sun_emuldata *edp, u_char c)
{
    u_int n, src, dst;
    int flags, fgcol, bgcol;
    long attr, bkgdattr;

    switch (c) {
    case '@':		/* "Insert Character (ICH)" */
        n = min(NORMALIZE(ARG(0,1)), COLS_LEFT + 1);
        src = edp->ccol;
        dst = edp->ccol + n;
        if (dst < edp->ncols) {
            (*edp->emulops->copycols)(edp->emulcookie, edp->crow,
                                      src, dst, edp->ncols - dst);
        }
        (*edp->emulops->erasecols)(edp->emulcookie, edp->crow,
                                   src, n, edp->bkgdattr);
        break;

    case 'A':		/* "Cursor Up (CUU)" */
        edp->crow -= min(NORMALIZE(ARG(0,1)), edp->crow);
        break;

    case 'E':		/* "Cursor Next Line (CNL)" */
        edp->ccol = 0;
    /* FALLTHROUGH */
    case 'B':		/* "Cursor Down (CUD)" */
        edp->crow += min(NORMALIZE(ARG(0,1)), ROWS_LEFT);
        break;

    case 'C':		/* "Cursor Forward (CUF)" */
        edp->ccol += min(NORMALIZE(ARG(0,1)), COLS_LEFT);
        break;

    case 'D':		/* "Cursor Backward (CUB)" */
        edp->ccol -= min(NORMALIZE(ARG(0,1)), edp->ccol);
        break;

    case 'f':		/* "Horizontal And Vertical Position (HVP)" */
    case 'H':		/* "Cursor Position (CUP)" */
        edp->crow = min(NORMALIZE(ARG(0,2)), edp->nrows) - 1;
        edp->ccol = min(NORMALIZE(ARG(1,2)), edp->ncols) - 1;
        break;

    case 'J':		/* "Erase in Display (ED)" */
        if (ROWS_LEFT > 0) {
            (*edp->emulops->eraserows)(edp->emulcookie,
                                       edp->crow + 1, ROWS_LEFT, edp->bkgdattr);
        }
    /* FALLTHROUGH */
    case 'K':		/* "Erase in Line (EL)" */
        (*edp->emulops->erasecols)(edp->emulcookie, edp->crow,
                                   edp->ccol, COLS_LEFT + 1, edp->bkgdattr);
        break;

    case 'L':		/* "Insert Line (IL)" */
        n = min(NORMALIZE(ARG(0,1)), ROWS_LEFT + 1);
        src = edp->crow;
        dst = edp->crow + n;
        if (dst < edp->nrows) {
            (*edp->emulops->copyrows)(edp->emulcookie,
                                      src, dst, edp->nrows - dst);
        }
        (*edp->emulops->eraserows)(edp->emulcookie,
                                   src, n, edp->bkgdattr);
        break;

    case 'M':		/* "Delete Line (DL)" */
        n = min(NORMALIZE(ARG(0,1)), ROWS_LEFT + 1);
        src = edp->crow + n;
        dst = edp->crow;
        if (src < edp->nrows) {
            (*edp->emulops->copyrows)(edp->emulcookie,
                                      src, dst, edp->nrows - src);
        }
        (*edp->emulops->eraserows)(edp->emulcookie,
                                   dst + edp->nrows - src, n, edp->bkgdattr);
        break;

    case 'P':		/* "Delete Character (DCH)" */
        n = min(NORMALIZE(ARG(0,1)), COLS_LEFT + 1);
        src = edp->ccol + n;
        dst = edp->ccol;
        if (src < edp->ncols) {
            (*edp->emulops->copycols)(edp->emulcookie, edp->crow,
                                      src, dst, edp->ncols - src);
        }
        (*edp->emulops->erasecols)(edp->emulcookie, edp->crow,
                                   edp->ncols - n, n, edp->bkgdattr);
        break;

    case 'm':		/* "Select Graphic Rendition (SGR)" */
        flags = edp->attrflags;
        fgcol = edp->fgcol;
        bgcol = edp->bgcol;

        for (n = 0; n < edp->nargs; n++) {
            switch (ARG(n,edp->nargs)) {
            /* Clear all attributes || End underline */
            case 0:
                if (n == edp->nargs - 1) {
                    edp->bkgdattr =
                        edp->curattr = edp->defattr;
                    edp->attrflags = 0;
                    edp->fgcol = WSCOL_BLACK;
                    edp->bgcol = WSCOL_WHITE;
                    return;
                }
                flags = 0;
                fgcol = WSCOL_BLACK;
                bgcol = WSCOL_WHITE;
                break;
            /* Begin bold */
            case 1:
                flags |= WSATTR_HILIT;
                break;
            /* Begin underline */
            case 4:
                flags |= WSATTR_UNDERLINE;
                break;
            /* Begin reverse */
            case 7:
                flags |= WSATTR_REVERSE;
                break;
            /* ANSI foreground color */
            case 30:
            case 31:
            case 32:
            case 33:
            case 34:
            case 35:
            case 36:
            case 37:
                fgcol = ARG(n,edp->nargs) - 30;
                break;
            /* ANSI background color */
            case 40:
            case 41:
            case 42:
            case 43:
            case 44:
            case 45:
            case 46:
            case 47:
                bgcol = ARG(n,edp->nargs) - 40;
                break;
            }
        }
setattr:
        if (wsemul_sun_selectattribute(edp, flags, fgcol, bgcol, &attr,
                                       &bkgdattr)) {
#ifdef DEBUG
            printf("error allocating attr %d/%d/%x\n",
                   fgcol, bgcol, flags);
#endif
        } else {
            edp->curattr = attr;
            edp->bkgdattr = bkgdattr;
            edp->attrflags = flags;
            edp->fgcol = fgcol;
            edp->bgcol = bgcol;
        }
        break;

    case 'p':		/* "Black On White (SUNBOW)" */
        flags = 0;
        fgcol = WSCOL_BLACK;
        bgcol = WSCOL_WHITE;
        goto setattr;

    case 'q':		/* "White On Black (SUNWOB)" */
        flags = 0;
        fgcol = WSCOL_WHITE;
        bgcol = WSCOL_BLACK;
        goto setattr;

    case 'r':		/* "Set Scrolling (SUNSCRL)" */
        edp->scrolldist = min(ARG(0,1), edp->nrows);
        break;

    case 's':		/* "Reset Terminal Emulator (SUNRESET)" */
        wsemul_sun_reset(edp);
        break;
    }
}
Example #21
0
File: lisp63.c Project: plops/clicc
void position_if_not1(CL_FORM *base)
{
	GEN_HEAPVAR(ARG(0), ARG(6));
	LOAD_NIL(ARG(6));
	{
		GEN_CLOSURE(array, ARG(7), 4, Z29_lambda, 2);
		COPY(ARG(0), &array[3]);
		LOAD_CLOSURE(array, ARG(7));
	}
	COPY(ARG(7), ARG(7));
	LOAD_NIL(ARG(8));
	if(CL_LISTP(ARG(1)))
	{
		LOAD_NIL(ARG(9));
		COPY(ARG(1), ARG(10));
		COPY(ARG(2), ARG(11));
		COPY(ARG(7), ARG(12));
		LOAD_NIL(ARG(13));
		COPY(ARG(3), ARG(14));
		COPY(ARG(4), ARG(15));
		COPY(ARG(5), ARG(16));
		list_position(ARG(9));
		COPY(ARG(9), ARG(0));
	}
	else
	{
		LOAD_NIL(ARG(9));
		COPY(ARG(1), ARG(10));
		COPY(ARG(2), ARG(11));
		COPY(ARG(7), ARG(12));
		LOAD_NIL(ARG(13));
		COPY(ARG(3), ARG(14));
		COPY(ARG(4), ARG(15));
		COPY(ARG(5), ARG(16));
		vector_position(ARG(9));
		COPY(ARG(9), ARG(0));
	}
}
Example #22
0
unsigned Dasm8085(char *buff, unsigned pc)
{
	UINT8 op;
	unsigned PC = pc;
	switch (op = OP(pc++))
	{
#ifdef  Z80_MNEMONICS
		case 0x00: sprintf (buff,"nop");                             break;
		case 0x01: sprintf (buff,"ld   bc,$%04x", ARGW(pc)); pc+=2;  break;
		case 0x02: sprintf (buff,"ld   (bc),a");                     break;
		case 0x03: sprintf (buff,"inc  bc");                         break;
		case 0x04: sprintf (buff,"inc  b");                          break;
		case 0x05: sprintf (buff,"dec  b");                          break;
		case 0x06: sprintf (buff,"ld   b,$%02x", ARG(pc)); pc++;     break;
		case 0x07: sprintf (buff,"rlca");                            break;
		case 0x08: sprintf (buff,"sub  hl,bc (*)");                  break;
		case 0x09: sprintf (buff,"add  hl,bc");                      break;
		case 0x0a: sprintf (buff,"ld   a,(bc)");                     break;
		case 0x0b: sprintf (buff,"dec  bc");                         break;
		case 0x0c: sprintf (buff,"inc  c");                          break;
		case 0x0d: sprintf (buff,"dec  c");                          break;
		case 0x0e: sprintf (buff,"ld   c,$%02x", ARG(pc)); pc++;     break;
		case 0x0f: sprintf (buff,"rrca");                            break;
		case 0x10: sprintf (buff,"sra  hl (*)");                     break;
		case 0x11: sprintf (buff,"ld   de,$%04x", ARGW(pc)); pc+=2;  break;
		case 0x12: sprintf (buff,"ld   (de),a");                     break;
		case 0x13: sprintf (buff,"inc  de");                         break;
		case 0x14: sprintf (buff,"inc  d");                          break;
		case 0x15: sprintf (buff,"dec  d");                          break;
		case 0x16: sprintf (buff,"ld   d,$%02x", ARG(pc)); pc++;     break;
		case 0x17: sprintf (buff,"rla");                             break;
		case 0x18: sprintf (buff,"rl   de (*)");                     break;
		case 0x19: sprintf (buff,"add  hl,de");                      break;
		case 0x1a: sprintf (buff,"ld   a,(de)");                     break;
		case 0x1b: sprintf (buff,"dec  de");                         break;
		case 0x1c: sprintf (buff,"inc  e");                          break;
		case 0x1d: sprintf (buff,"dec  e");                          break;
		case 0x1e: sprintf (buff,"ld   e,$%02x", ARG(pc)); pc++;     break;
		case 0x1f: sprintf (buff,"rra");                             break;
		case 0x20: sprintf (buff,"rim");                             break;
		case 0x21: sprintf (buff,"ld   hl,$%04x", ARGW(pc)); pc+=2;  break;
		case 0x22: sprintf (buff,"ld   ($%04x),hl", ARGW(pc)); pc+=2;break;
		case 0x23: sprintf (buff,"inc  hl");                         break;
		case 0x24: sprintf (buff,"inc  h");                          break;
		case 0x25: sprintf (buff,"dec  h");                          break;
		case 0x26: sprintf (buff,"ld   h,$%02x", ARG(pc)); pc++;     break;
		case 0x27: sprintf (buff,"daa");                             break;
		case 0x28: sprintf (buff,"ld   de,hl+$%02x (*)",ARG(pc));pc++;break;
		case 0x29: sprintf (buff,"add  hl,hl");                      break;
		case 0x2a: sprintf (buff,"ld   hl,($%04x)", ARGW(pc)); pc+=2;break;
		case 0x2b: sprintf (buff,"dec  hl");                         break;
		case 0x2c: sprintf (buff,"inc  l");                          break;
		case 0x2d: sprintf (buff,"dec  l");                          break;
		case 0x2e: sprintf (buff,"ld   l,$%02x", ARG(pc)); pc++;     break;
		case 0x2f: sprintf (buff,"cpl");                             break;
		case 0x30: sprintf (buff,"sim");                             break;
		case 0x31: sprintf (buff,"ld   sp,$%04x", ARGW(pc)); pc+=2;  break;
		case 0x32: sprintf (buff,"ld   ($%04x),a", ARGW(pc)); pc+=2; break;
		case 0x33: sprintf (buff,"inc  sp");                         break;
		case 0x34: sprintf (buff,"inc  (hl)");                       break;
		case 0x35: sprintf (buff,"dec  (hl)");                       break;
		case 0x36: sprintf (buff,"ld   (hl),$%02x", ARG(pc)); pc++;  break;
		case 0x37: sprintf (buff,"scf");                             break;
		case 0x38: sprintf (buff,"ld   de,sp+$%02x (*)",ARG(pc));pc++;break;
		case 0x39: sprintf (buff,"add  hl,sp");                      break;
		case 0x3a: sprintf (buff,"ld   a,($%04x)", ARGW(pc)); pc+=2; break;
		case 0x3b: sprintf (buff,"dec  sp");                         break;
		case 0x3c: sprintf (buff,"inc  a");                          break;
		case 0x3d: sprintf (buff,"dec  a");                          break;
		case 0x3e: sprintf (buff,"ld   a,$%02x", ARG(pc)); pc++;     break;
		case 0x3f: sprintf (buff,"ccf");                             break;
		case 0x40: sprintf (buff,"ld   b,b");                        break;
		case 0x41: sprintf (buff,"ld   b,c");                        break;
		case 0x42: sprintf (buff,"ld   b,d");                        break;
		case 0x43: sprintf (buff,"ld   b,e");                        break;
		case 0x44: sprintf (buff,"ld   b,h");                        break;
		case 0x45: sprintf (buff,"ld   b,l");                        break;
		case 0x46: sprintf (buff,"ld   b,(hl)");                     break;
		case 0x47: sprintf (buff,"ld   b,a");                        break;
		case 0x48: sprintf (buff,"ld   c,b");                        break;
		case 0x49: sprintf (buff,"ld   c,c");                        break;
		case 0x4a: sprintf (buff,"ld   c,d");                        break;
		case 0x4b: sprintf (buff,"ld   c,e");                        break;
		case 0x4c: sprintf (buff,"ld   c,h");                        break;
		case 0x4d: sprintf (buff,"ld   c,l");                        break;
		case 0x4e: sprintf (buff,"ld   c,(hl)");                     break;
		case 0x4f: sprintf (buff,"ld   c,a");                        break;
		case 0x50: sprintf (buff,"ld   d,b");                        break;
		case 0x51: sprintf (buff,"ld   d,c");                        break;
		case 0x52: sprintf (buff,"ld   d,d");                        break;
		case 0x53: sprintf (buff,"ld   d,e");                        break;
		case 0x54: sprintf (buff,"ld   d,h");                        break;
		case 0x55: sprintf (buff,"ld   d,l");                        break;
		case 0x56: sprintf (buff,"ld   d,(hl)");                     break;
		case 0x57: sprintf (buff,"ld   d,a");                        break;
		case 0x58: sprintf (buff,"ld   e,b");                        break;
		case 0x59: sprintf (buff,"ld   e,c");                        break;
		case 0x5a: sprintf (buff,"ld   e,d");                        break;
		case 0x5b: sprintf (buff,"ld   e,e");                        break;
		case 0x5c: sprintf (buff,"ld   e,h");                        break;
		case 0x5d: sprintf (buff,"ld   e,l");                        break;
		case 0x5e: sprintf (buff,"ld   e,(hl)");                     break;
		case 0x5f: sprintf (buff,"ld   e,a");                        break;
		case 0x60: sprintf (buff,"ld   h,b");                        break;
		case 0x61: sprintf (buff,"ld   h,c");                        break;
		case 0x62: sprintf (buff,"ld   h,d");                        break;
		case 0x63: sprintf (buff,"ld   h,e");                        break;
		case 0x64: sprintf (buff,"ld   h,h");                        break;
		case 0x65: sprintf (buff,"ld   h,l");                        break;
		case 0x66: sprintf (buff,"ld   h,(hl)");                     break;
		case 0x67: sprintf (buff,"ld   h,a");                        break;
		case 0x68: sprintf (buff,"ld   l,b");                        break;
		case 0x69: sprintf (buff,"ld   l,c");                        break;
		case 0x6a: sprintf (buff,"ld   l,d");                        break;
		case 0x6b: sprintf (buff,"ld   l,e");                        break;
		case 0x6c: sprintf (buff,"ld   l,h");                        break;
		case 0x6d: sprintf (buff,"ld   l,l");                        break;
		case 0x6e: sprintf (buff,"ld   l,(hl)");                     break;
		case 0x6f: sprintf (buff,"ld   l,a");                        break;
		case 0x70: sprintf (buff,"ld   (hl),b");                     break;
		case 0x71: sprintf (buff,"ld   (hl),c");                     break;
		case 0x72: sprintf (buff,"ld   (hl),d");                     break;
		case 0x73: sprintf (buff,"ld   (hl),e");                     break;
		case 0x74: sprintf (buff,"ld   (hl),h");                     break;
		case 0x75: sprintf (buff,"ld   (hl),l");                     break;
		case 0x76: sprintf (buff,"halt");                            break;
		case 0x77: sprintf (buff,"ld   (hl),a");                     break;
		case 0x78: sprintf (buff,"ld   a,b");                        break;
		case 0x79: sprintf (buff,"ld   a,c");                        break;
		case 0x7a: sprintf (buff,"ld   a,d");                        break;
		case 0x7b: sprintf (buff,"ld   a,e");                        break;
		case 0x7c: sprintf (buff,"ld   a,h");                        break;
		case 0x7d: sprintf (buff,"ld   a,l");                        break;
		case 0x7e: sprintf (buff,"ld   a,(hl)");                     break;
		case 0x7f: sprintf (buff,"ld   a,a");                        break;
		case 0x80: sprintf (buff,"add  a,b");                        break;
		case 0x81: sprintf (buff,"add  a,c");                        break;
		case 0x82: sprintf (buff,"add  a,d");                        break;
		case 0x83: sprintf (buff,"add  a,e");                        break;
		case 0x84: sprintf (buff,"add  a,h");                        break;
		case 0x85: sprintf (buff,"add  a,l");                        break;
		case 0x86: sprintf (buff,"add  a,(hl)");                     break;
		case 0x87: sprintf (buff,"add  a,a");                        break;
		case 0x88: sprintf (buff,"adc  a,b");                        break;
		case 0x89: sprintf (buff,"adc  a,c");                        break;
		case 0x8a: sprintf (buff,"adc  a,d");                        break;
		case 0x8b: sprintf (buff,"adc  a,e");                        break;
		case 0x8c: sprintf (buff,"adc  a,h");                        break;
		case 0x8d: sprintf (buff,"adc  a,l");                        break;
		case 0x8e: sprintf (buff,"adc  a,(hl)");                     break;
		case 0x8f: sprintf (buff,"adc  a,a");                        break;
		case 0x90: sprintf (buff,"sub  b");                          break;
		case 0x91: sprintf (buff,"sub  c");                          break;
		case 0x92: sprintf (buff,"sub  d");                          break;
		case 0x93: sprintf (buff,"sub  e");                          break;
		case 0x94: sprintf (buff,"sub  h");                          break;
		case 0x95: sprintf (buff,"sub  l");                          break;
		case 0x96: sprintf (buff,"sub  (hl)");                       break;
		case 0x97: sprintf (buff,"sub  a");                          break;
		case 0x98: sprintf (buff,"sbc  a,b");                        break;
		case 0x99: sprintf (buff,"sbc  a,c");                        break;
		case 0x9a: sprintf (buff,"sbc  a,d");                        break;
		case 0x9b: sprintf (buff,"sbc  a,e");                        break;
		case 0x9c: sprintf (buff,"sbc  a,h");                        break;
		case 0x9d: sprintf (buff,"sbc  a,l");                        break;
		case 0x9e: sprintf (buff,"sbc  a,(hl)");                     break;
		case 0x9f: sprintf (buff,"sbc  a,a");                        break;
		case 0xa0: sprintf (buff,"and  b");                          break;
		case 0xa1: sprintf (buff,"and  c");                          break;
		case 0xa2: sprintf (buff,"and  d");                          break;
		case 0xa3: sprintf (buff,"and  e");                          break;
		case 0xa4: sprintf (buff,"and  h");                          break;
		case 0xa5: sprintf (buff,"and  l");                          break;
		case 0xa6: sprintf (buff,"and  (hl)");                       break;
		case 0xa7: sprintf (buff,"and  a");                          break;
		case 0xa8: sprintf (buff,"xor  b");                          break;
		case 0xa9: sprintf (buff,"xor  c");                          break;
		case 0xaa: sprintf (buff,"xor  d");                          break;
		case 0xab: sprintf (buff,"xor  e");                          break;
		case 0xac: sprintf (buff,"xor  h");                          break;
		case 0xad: sprintf (buff,"xor  l");                          break;
		case 0xae: sprintf (buff,"xor  (hl)");                       break;
		case 0xaf: sprintf (buff,"xor  a");                          break;
		case 0xb0: sprintf (buff,"or   b");                          break;
		case 0xb1: sprintf (buff,"or   c");                          break;
		case 0xb2: sprintf (buff,"or   d");                          break;
		case 0xb3: sprintf (buff,"or   e");                          break;
		case 0xb4: sprintf (buff,"or   h");                          break;
		case 0xb5: sprintf (buff,"or   l");                          break;
		case 0xb6: sprintf (buff,"or   (hl)");                       break;
		case 0xb7: sprintf (buff,"or   a");                          break;
		case 0xb8: sprintf (buff,"cp   b");                          break;
		case 0xb9: sprintf (buff,"cp   c");                          break;
		case 0xba: sprintf (buff,"cp   d");                          break;
		case 0xbb: sprintf (buff,"cp   e");                          break;
		case 0xbc: sprintf (buff,"cp   h");                          break;
		case 0xbd: sprintf (buff,"cp   l");                          break;
		case 0xbe: sprintf (buff,"cp   (hl)");                       break;
		case 0xbf: sprintf (buff,"cp   a");                          break;
		case 0xc0: sprintf (buff,"ret  nz");                         break;
		case 0xc1: sprintf (buff,"pop  bc");                         break;
		case 0xc2: sprintf (buff,"jp   nz,$%04x", ARGW(pc)); pc+=2;  break;
		case 0xc3: sprintf (buff,"jp   $%04x", ARGW(pc)); pc+=2;     break;
		case 0xc4: sprintf (buff,"call nz,$%04x", ARGW(pc)); pc+=2;  break;
		case 0xc5: sprintf (buff,"push bc");                         break;
		case 0xc6: sprintf (buff,"add  a,$%02x", ARG(pc)); pc++;     break;
		case 0xc7: sprintf (buff,"rst  $00");                        break;
		case 0xc8: sprintf (buff,"ret  z");                          break;
		case 0xc9: sprintf (buff,"ret");                             break;
		case 0xca: sprintf (buff,"jp   z,$%04x", ARGW(pc)); pc+=2;   break;
		case 0xcb: sprintf (buff,"rst  v,$40 (*)");                  break;
		case 0xcc: sprintf (buff,"call z,$%04x", ARGW(pc)); pc+=2;   break;
		case 0xcd: sprintf (buff,"call $%04x", ARGW(pc)); pc+=2;     break;
		case 0xce: sprintf (buff,"adc  a,$%02x", ARG(pc)); pc++;     break;
		case 0xcf: sprintf (buff,"rst  $08");                        break;
		case 0xd0: sprintf (buff,"ret  nc");                         break;
		case 0xd1: sprintf (buff,"pop  de");                         break;
		case 0xd2: sprintf (buff,"jp   nc,$%04x", ARGW(pc)); pc+=2;  break;
		case 0xd3: sprintf (buff,"out  ($%02x),a", ARG(pc)); pc++;   break;
		case 0xd4: sprintf (buff,"call nc,$%04x", ARGW(pc)); pc+=2;  break;
		case 0xd5: sprintf (buff,"push de");                         break;
		case 0xd6: sprintf (buff,"sub  $%02x", ARG(pc)); pc++;       break;
		case 0xd7: sprintf (buff,"rst  $10");                        break;
		case 0xd8: sprintf (buff,"ret  c");                          break;
		case 0xd9: sprintf (buff,"ld   (de),hl (*)");                break;
		case 0xda: sprintf (buff,"jp   c,$%04x", ARGW(pc)); pc+=2;   break;
		case 0xdb: sprintf (buff,"in   a,($%02x)", ARG(pc)); pc++;   break;
		case 0xdc: sprintf (buff,"call c,$%04x", ARGW(pc)); pc+=2;   break;
		case 0xdd: sprintf (buff,"jp   nx,$%04x (*)",ARGW(pc));pc+=2;break;
		case 0xde: sprintf (buff,"sub  $%02x", ARG(pc)); pc++;       break;
		case 0xdf: sprintf (buff,"rst  $18");                        break;
		case 0xe0: sprintf (buff,"ret  pe");                         break;
		case 0xe1: sprintf (buff,"pop  hl");                         break;
		case 0xe2: sprintf (buff,"jp   pe,$%04x", ARGW(pc)); pc+=2;  break;
		case 0xe3: sprintf (buff,"ex   (sp),hl");                    break;
		case 0xe4: sprintf (buff,"call pe,$%04x", ARGW(pc)); pc+=2;  break;
		case 0xe5: sprintf (buff,"push hl");                         break;
		case 0xe6: sprintf (buff,"and  $%02x", ARG(pc)); pc++;       break;
		case 0xe7: sprintf (buff,"rst  $20");                        break;
		case 0xe8: sprintf (buff,"ret  po");                         break;
		case 0xe9: sprintf (buff,"jp   (hl)");                       break;
		case 0xea: sprintf (buff,"jp   po,$%04x", ARGW(pc)); pc+=2;  break;
		case 0xeb: sprintf (buff,"ex   de,hl");                      break;
		case 0xec: sprintf (buff,"call po,$%04x", ARGW(pc)); pc+=2;  break;
		case 0xed: sprintf (buff,"ld   hl,(de) (*)");                break;
		case 0xee: sprintf (buff,"xor  $%02x", ARG(pc)); pc++;       break;
		case 0xef: sprintf (buff,"rst  $28");                        break;
		case 0xf0: sprintf (buff,"ret  p");                          break;
		case 0xf1: sprintf (buff,"pop  af");                         break;
		case 0xf2: sprintf (buff,"jp   p,$%04x", ARGW(pc)); pc+=2;   break;
		case 0xf3: sprintf (buff,"di");                              break;
		case 0xf4: sprintf (buff,"cp   $%04x", ARGW(pc)); pc+=2;     break;
		case 0xf5: sprintf (buff,"push af");                         break;
		case 0xf6: sprintf (buff,"or   $%02x", ARG(pc)); pc++;       break;
		case 0xf7: sprintf (buff,"rst  $30");                        break;
		case 0xf8: sprintf (buff,"ret  m");                          break;
		case 0xf9: sprintf (buff,"ld   sp,hl");                      break;
		case 0xfa: sprintf (buff,"jp   m,$%04x", ARGW(pc)); pc+=2;   break;
		case 0xfb: sprintf (buff,"ei");                              break;
		case 0xfc: sprintf (buff,"call m,$%04x", ARGW(pc)); pc+=2;   break;
		case 0xfd: sprintf (buff,"jp   x,$%04x (*)",ARGW(pc));pc+=2; break;
		case 0xfe: sprintf (buff,"cp   $%02x", ARG(pc)); pc++;       break;
		case 0xff: sprintf (buff,"rst  $38");                        break;
#else
		case 0x00: sprintf (buff,"nop");                             break;
		case 0x01: sprintf (buff,"lxi  b,$%04x", ARGW(pc)); pc+=2;   break;
		case 0x02: sprintf (buff,"stax b");                          break;
		case 0x03: sprintf (buff,"inx  b");                          break;
		case 0x04: sprintf (buff,"inr  b");                          break;
		case 0x05: sprintf (buff,"dcr  b");                          break;
		case 0x06: sprintf (buff,"mvi  b,$%02x", ARG(pc)); pc++;     break;
		case 0x07: sprintf (buff,"rlc");                             break;
		case 0x08: sprintf (buff,"dsub (*)");                        break;
		case 0x09: sprintf (buff,"dad  b");                          break;
		case 0x0a: sprintf (buff,"ldax b");                          break;
		case 0x0b: sprintf (buff,"dcx  b");                          break;
		case 0x0c: sprintf (buff,"inr  c");                          break;
		case 0x0d: sprintf (buff,"dcr  c");                          break;
		case 0x0e: sprintf (buff,"mvi  c,$%02x", ARG(pc)); pc++;     break;
		case 0x0f: sprintf (buff,"rrc");                             break;
		case 0x10: sprintf (buff,"asrh (*)");                        break;
		case 0x11: sprintf (buff,"lxi  d,$%04x", ARGW(pc)); pc+=2;   break;
		case 0x12: sprintf (buff,"stax d");                          break;
		case 0x13: sprintf (buff,"inx  d");                          break;
		case 0x14: sprintf (buff,"inr  d");                          break;
		case 0x15: sprintf (buff,"dcr  d");                          break;
		case 0x16: sprintf (buff,"mvi  d,$%02x", ARG(pc)); pc++;     break;
		case 0x17: sprintf (buff,"ral");                             break;
		case 0x18: sprintf (buff,"rlde (*)");                        break;
		case 0x19: sprintf (buff,"dad  d");                          break;
		case 0x1a: sprintf (buff,"ldax d");                          break;
		case 0x1b: sprintf (buff,"dcx  d");                          break;
		case 0x1c: sprintf (buff,"inr  e");                          break;
		case 0x1d: sprintf (buff,"dcr  e");                          break;
		case 0x1e: sprintf (buff,"mvi  e,$%02x", ARG(pc)); pc++;     break;
		case 0x1f: sprintf (buff,"rar");                             break;
		case 0x20: sprintf (buff,"rim");                             break;
		case 0x21: sprintf (buff,"lxi  h,$%04x", ARGW(pc)); pc+=2;   break;
		case 0x22: sprintf (buff,"shld $%04x", ARGW(pc)); pc+=2;     break;
		case 0x23: sprintf (buff,"inx  h");                          break;
		case 0x24: sprintf (buff,"inr  h");                          break;
		case 0x25: sprintf (buff,"dcr  h");                          break;
		case 0x26: sprintf (buff,"mvi  h,$%02x", ARG(pc)); pc++;     break;
		case 0x27: sprintf (buff,"daa");                             break;
		case 0x28: sprintf (buff,"ldeh $%02x (*)", ARG(pc)); pc++;   break;
		case 0x29: sprintf (buff,"dad  h");                          break;
		case 0x2a: sprintf (buff,"lhld $%04x", ARGW(pc)); pc+=2;     break;
		case 0x2b: sprintf (buff,"dcx  h");                          break;
		case 0x2c: sprintf (buff,"inr  l");                          break;
		case 0x2d: sprintf (buff,"dcr  l");                          break;
		case 0x2e: sprintf (buff,"mvi  l,$%02x", ARG(pc)); pc++;     break;
		case 0x2f: sprintf (buff,"cma");                             break;
		case 0x30: sprintf (buff,"sim");                             break;
		case 0x31: sprintf (buff,"lxi  sp,$%04x", ARGW(pc)); pc+=2;  break;
		case 0x32: sprintf (buff,"stax $%04x", ARGW(pc)); pc+=2;     break;
		case 0x33: sprintf (buff,"inx  sp");                         break;
		case 0x34: sprintf (buff,"inr  m");                          break;
		case 0x35: sprintf (buff,"dcr  m");                          break;
		case 0x36: sprintf (buff,"mvi  m,$%02x", ARG(pc)); pc++;     break;
		case 0x37: sprintf (buff,"stc");                             break;
		case 0x28: sprintf (buff,"ldes $%02x", ARG(pc)); pc++;       break;
		case 0x39: sprintf (buff,"dad sp");                          break;
		case 0x3a: sprintf (buff,"ldax $%04x", ARGW(pc)); pc+=2;     break;
		case 0x3b: sprintf (buff,"dcx  sp");                         break;
		case 0x3c: sprintf (buff,"inr  a");                          break;
		case 0x3d: sprintf (buff,"dcr  a");                          break;
		case 0x3e: sprintf (buff,"mvi  a,$%02x", ARG(pc)); pc++;     break;
		case 0x3f: sprintf (buff,"cmf");                             break;
		case 0x40: sprintf (buff,"mov  b,b");                        break;
		case 0x41: sprintf (buff,"mov  b,c");                        break;
		case 0x42: sprintf (buff,"mov  b,d");                        break;
		case 0x43: sprintf (buff,"mov  b,e");                        break;
		case 0x44: sprintf (buff,"mov  b,h");                        break;
		case 0x45: sprintf (buff,"mov  b,l");                        break;
		case 0x46: sprintf (buff,"mov  b,m");                        break;
		case 0x47: sprintf (buff,"mov  b,a");                        break;
		case 0x48: sprintf (buff,"mov  c,b");                        break;
		case 0x49: sprintf (buff,"mov  c,c");                        break;
		case 0x4a: sprintf (buff,"mov  c,d");                        break;
		case 0x4b: sprintf (buff,"mov  c,e");                        break;
		case 0x4c: sprintf (buff,"mov  c,h");                        break;
		case 0x4d: sprintf (buff,"mov  c,l");                        break;
		case 0x4e: sprintf (buff,"mov  c,m");                        break;
		case 0x4f: sprintf (buff,"mov  c,a");                        break;
		case 0x50: sprintf (buff,"mov  d,b");                        break;
		case 0x51: sprintf (buff,"mov  d,c");                        break;
		case 0x52: sprintf (buff,"mov  d,d");                        break;
		case 0x53: sprintf (buff,"mov  d,e");                        break;
		case 0x54: sprintf (buff,"mov  d,h");                        break;
		case 0x55: sprintf (buff,"mov  d,l");                        break;
		case 0x56: sprintf (buff,"mov  d,m");                        break;
		case 0x57: sprintf (buff,"mov  d,a");                        break;
		case 0x58: sprintf (buff,"mov  e,b");                        break;
		case 0x59: sprintf (buff,"mov  e,c");                        break;
		case 0x5a: sprintf (buff,"mov  e,d");                        break;
		case 0x5b: sprintf (buff,"mov  e,e");                        break;
		case 0x5c: sprintf (buff,"mov  e,h");                        break;
		case 0x5d: sprintf (buff,"mov  e,l");                        break;
		case 0x5e: sprintf (buff,"mov  e,m");                        break;
		case 0x5f: sprintf (buff,"mov  e,a");                        break;
		case 0x60: sprintf (buff,"mov  h,b");                        break;
		case 0x61: sprintf (buff,"mov  h,c");                        break;
		case 0x62: sprintf (buff,"mov  h,d");                        break;
		case 0x63: sprintf (buff,"mov  h,e");                        break;
		case 0x64: sprintf (buff,"mov  h,h");                        break;
		case 0x65: sprintf (buff,"mov  h,l");                        break;
		case 0x66: sprintf (buff,"mov  h,m");                        break;
		case 0x67: sprintf (buff,"mov  h,a");                        break;
		case 0x68: sprintf (buff,"mov  l,b");                        break;
		case 0x69: sprintf (buff,"mov  l,c");                        break;
		case 0x6a: sprintf (buff,"mov  l,d");                        break;
		case 0x6b: sprintf (buff,"mov  l,e");                        break;
		case 0x6c: sprintf (buff,"mov  l,h");                        break;
		case 0x6d: sprintf (buff,"mov  l,l");                        break;
		case 0x6e: sprintf (buff,"mov  l,m");                        break;
		case 0x6f: sprintf (buff,"mov  l,a");                        break;
		case 0x70: sprintf (buff,"mov  m,b");                        break;
		case 0x71: sprintf (buff,"mov  m,c");                        break;
		case 0x72: sprintf (buff,"mov  m,d");                        break;
		case 0x73: sprintf (buff,"mov  m,e");                        break;
		case 0x74: sprintf (buff,"mov  m,h");                        break;
		case 0x75: sprintf (buff,"mov  m,l");                        break;
		case 0x76: sprintf (buff,"mov  m,m");                        break;
		case 0x77: sprintf (buff,"mov  m,a");                        break;
		case 0x78: sprintf (buff,"mov  a,b");                        break;
		case 0x79: sprintf (buff,"mov  a,c");                        break;
		case 0x7a: sprintf (buff,"mov  a,d");                        break;
		case 0x7b: sprintf (buff,"mov  a,e");                        break;
		case 0x7c: sprintf (buff,"mov  a,h");                        break;
		case 0x7d: sprintf (buff,"mov  a,l");                        break;
		case 0x7e: sprintf (buff,"mov  a,m");                        break;
		case 0x7f: sprintf (buff,"mov  a,a");                        break;
		case 0x80: sprintf (buff,"add  b");                          break;
		case 0x81: sprintf (buff,"add  c");                          break;
		case 0x82: sprintf (buff,"add  d");                          break;
		case 0x83: sprintf (buff,"add  e");                          break;
		case 0x84: sprintf (buff,"add  h");                          break;
		case 0x85: sprintf (buff,"add  l");                          break;
		case 0x86: sprintf (buff,"add  m");                          break;
		case 0x87: sprintf (buff,"add  a");                          break;
		case 0x88: sprintf (buff,"adc  b");                          break;
		case 0x89: sprintf (buff,"adc  c");                          break;
		case 0x8a: sprintf (buff,"adc  d");                          break;
		case 0x8b: sprintf (buff,"adc  e");                          break;
		case 0x8c: sprintf (buff,"adc  h");                          break;
		case 0x8d: sprintf (buff,"adc  l");                          break;
		case 0x8e: sprintf (buff,"adc  m");                          break;
		case 0x8f: sprintf (buff,"adc  a");                          break;
		case 0x90: sprintf (buff,"sub  b");                          break;
		case 0x91: sprintf (buff,"sub  c");                          break;
		case 0x92: sprintf (buff,"sub  d");                          break;
		case 0x93: sprintf (buff,"sub  e");                          break;
		case 0x94: sprintf (buff,"sub  h");                          break;
		case 0x95: sprintf (buff,"sub  l");                          break;
		case 0x96: sprintf (buff,"sub  m");                          break;
		case 0x97: sprintf (buff,"sub  a");                          break;
		case 0x98: sprintf (buff,"sbb  b");                          break;
		case 0x99: sprintf (buff,"sbb  c");                          break;
		case 0x9a: sprintf (buff,"sbb  d");                          break;
		case 0x9b: sprintf (buff,"sbb  e");                          break;
		case 0x9c: sprintf (buff,"sbb  h");                          break;
		case 0x9d: sprintf (buff,"sbb  l");                          break;
		case 0x9e: sprintf (buff,"sbb  m");                          break;
		case 0x9f: sprintf (buff,"sbb  a");                          break;
		case 0xa0: sprintf (buff,"ana  b");                          break;
		case 0xa1: sprintf (buff,"ana  c");                          break;
		case 0xa2: sprintf (buff,"ana  d");                          break;
		case 0xa3: sprintf (buff,"ana  e");                          break;
		case 0xa4: sprintf (buff,"ana  h");                          break;
		case 0xa5: sprintf (buff,"ana  l");                          break;
		case 0xa6: sprintf (buff,"ana  m");                          break;
		case 0xa7: sprintf (buff,"ana  a");                          break;
		case 0xa8: sprintf (buff,"xra  b");                          break;
		case 0xa9: sprintf (buff,"xra  c");                          break;
		case 0xaa: sprintf (buff,"xra  d");                          break;
		case 0xab: sprintf (buff,"xra  e");                          break;
		case 0xac: sprintf (buff,"xra  h");                          break;
		case 0xad: sprintf (buff,"xra  l");                          break;
		case 0xae: sprintf (buff,"xra  m");                          break;
		case 0xaf: sprintf (buff,"xra  a");                          break;
		case 0xb0: sprintf (buff,"ora  b");                          break;
		case 0xb1: sprintf (buff,"ora  c");                          break;
		case 0xb2: sprintf (buff,"ora  d");                          break;
		case 0xb3: sprintf (buff,"ora  e");                          break;
		case 0xb4: sprintf (buff,"ora  h");                          break;
		case 0xb5: sprintf (buff,"ora  l");                          break;
		case 0xb6: sprintf (buff,"ora  m");                          break;
		case 0xb7: sprintf (buff,"ora  a");                          break;
		case 0xb8: sprintf (buff,"cmp  b");                          break;
		case 0xb9: sprintf (buff,"cmp  c");                          break;
		case 0xba: sprintf (buff,"cmp  d");                          break;
		case 0xbb: sprintf (buff,"cmp  e");                          break;
		case 0xbc: sprintf (buff,"cmp  h");                          break;
		case 0xbd: sprintf (buff,"cmp  l");                          break;
		case 0xbe: sprintf (buff,"cmp  m");                          break;
		case 0xbf: sprintf (buff,"cmp  a");                          break;
		case 0xc0: sprintf (buff,"rnz");                             break;
		case 0xc1: sprintf (buff,"pop  b");                          break;
		case 0xc2: sprintf (buff,"jnz  $%04x", ARGW(pc)); pc+=2;     break;
		case 0xc3: sprintf (buff,"jmp  $%04x", ARGW(pc)); pc+=2;     break;
		case 0xc4: sprintf (buff,"cnz  $%04x", ARGW(pc)); pc+=2;     break;
		case 0xc5: sprintf (buff,"push b");                          break;
		case 0xc6: sprintf (buff,"adi  $%02x", ARG(pc)); pc++;       break;
		case 0xc7: sprintf (buff,"rst  0");                          break;
		case 0xc8: sprintf (buff,"rz");                              break;
		case 0xc9: sprintf (buff,"ret");                             break;
		case 0xca: sprintf (buff,"jz   $%04x", ARGW(pc)); pc+=2;     break;
		case 0xcb: sprintf (buff,"rstv 8 (*)");                      break;
		case 0xcc: sprintf (buff,"cz   $%04x", ARGW(pc)); pc+=2;     break;
		case 0xcd: sprintf (buff,"call $%04x", ARGW(pc)); pc+=2;     break;
		case 0xce: sprintf (buff,"aci  $%02x", ARG(pc)); pc++;       break;
		case 0xcf: sprintf (buff,"rst  1");                          break;
		case 0xd0: sprintf (buff,"rnc");                             break;
		case 0xd1: sprintf (buff,"pop  d");                          break;
		case 0xd2: sprintf (buff,"jnc  $%04x", ARGW(pc)); pc+=2;     break;
		case 0xd3: sprintf (buff,"out  $%02x", ARG(pc)); pc++;       break;
		case 0xd4: sprintf (buff,"cnc  $%04x", ARGW(pc)); pc+=2;     break;
		case 0xd5: sprintf (buff,"push d");                          break;
		case 0xd6: sprintf (buff,"sui  $%02x", ARG(pc)); pc++;       break;
		case 0xd7: sprintf (buff,"rst  2");                          break;
		case 0xd8: sprintf (buff,"rc");                              break;
		case 0xd9: sprintf (buff,"shlx d (*)");                      break;
		case 0xda: sprintf (buff,"jc   $%04x", ARGW(pc)); pc+=2;     break;
		case 0xdb: sprintf (buff,"in   $%02x", ARG(pc)); pc++;       break;
		case 0xdc: sprintf (buff,"cc   $%04x", ARGW(pc)); pc+=2;     break;
		case 0xdd: sprintf (buff,"jnx  $%04x (*)", ARGW(pc)); pc+=2; break;
		case 0xde: sprintf (buff,"sbi  $%02x", ARG(pc)); pc++;       break;
		case 0xdf: sprintf (buff,"rst  3");                          break;
		case 0xe0: sprintf (buff,"rpo");                             break;
		case 0xe1: sprintf (buff,"pop  h");                          break;
		case 0xe2: sprintf (buff,"jpo  $%04x", ARGW(pc)); pc+=2;     break;
		case 0xe3: sprintf (buff,"xthl");                            break;
		case 0xe4: sprintf (buff,"cpo  $%04x", ARGW(pc)); pc+=2;     break;
		case 0xe5: sprintf (buff,"push h");                          break;
		case 0xe6: sprintf (buff,"ani  $%02x", ARG(pc)); pc++;       break;
		case 0xe7: sprintf (buff,"rst  4");                          break;
		case 0xe8: sprintf (buff,"rpe");                             break;
		case 0xe9: sprintf (buff,"pchl");                            break;
		case 0xea: sprintf (buff,"jpe  $%04x", ARGW(pc)); pc+=2;     break;
		case 0xeb: sprintf (buff,"xchg");                            break;
		case 0xec: sprintf (buff,"cpe  $%04x", ARGW(pc)); pc+=2;     break;
		case 0xed: sprintf (buff,"lhlx d (*)");                      break;
		case 0xee: sprintf (buff,"xri  $%02x", ARG(pc)); pc++;       break;
		case 0xef: sprintf (buff,"rst  5");                          break;
		case 0xf0: sprintf (buff,"rp");                              break;
		case 0xf1: sprintf (buff,"pop  a");                          break;
		case 0xf2: sprintf (buff,"jp   $%04x", ARGW(pc)); pc+=2;     break;
		case 0xf3: sprintf (buff,"di");                              break;
		case 0xf4: sprintf (buff,"cp   $%04x", ARGW(pc)); pc+=2;     break;
		case 0xf5: sprintf (buff,"push a");                          break;
		case 0xf6: sprintf (buff,"ori  $%02x", ARG(pc)); pc++;       break;
		case 0xf7: sprintf (buff,"rst  6");                          break;
		case 0xf8: sprintf (buff,"rm");                              break;
		case 0xf9: sprintf (buff,"sphl");                            break;
		case 0xfa: sprintf (buff,"jm   $%04x", ARGW(pc)); pc+=2;     break;
		case 0xfb: sprintf (buff,"ei");                              break;
		case 0xfc: sprintf (buff,"cm   $%04x", ARGW(pc)); pc+=2;     break;
		case 0xfd: sprintf (buff,"jx   $%04x (*)", ARGW(pc)); pc+=2; break;
		case 0xfe: sprintf (buff,"cpi  $%02x", ARG(pc)); pc++;       break;
		case 0xff: sprintf (buff,"rst  7");                          break;
#endif
	}
	return pc - PC;
}
Example #23
0
static int analop_esil(RAnal *a, RAnalOp *op, ut64 addr, const ut8 *buf, int len, csh *handle, cs_insn *insn) {
	char str[8][32];
	int i;
	r_strbuf_init (&op->esil);
	r_strbuf_set (&op->esil, "");

	if (insn) {
		// caching operands
		for (i=0; i<insn->detail->mips.op_count && i<8; i++) {
			*str[i]=0;
			ARG (i);
		}
	}

	if (insn)
	switch (insn->id) {
	case MIPS_INS_NOP:
		r_strbuf_setf (&op->esil, ",");
		break;
	case MIPS_INS_BREAK:
		r_strbuf_setf (&op->esil, "%s,%s,TRAP", ARG (0), ARG (0));
		break;
	case MIPS_INS_SW:
	case MIPS_INS_SWL:
	case MIPS_INS_SWR:
		r_strbuf_appendf (&op->esil, "%s,%s,=[4]",
			ARG (0), ARG (1));
		break;
	case MIPS_INS_SH:
		r_strbuf_appendf (&op->esil, "%s,%s,=[2]",
			ARG (0), ARG (1));
		break;
	case MIPS_INS_SWC1:
	case MIPS_INS_SWC2:
		r_strbuf_setf (&op->esil, "%s,$", ARG (1));
		break;
	case MIPS_INS_SB:
		r_strbuf_appendf (&op->esil, "%s,%s,=[1]",
			ARG (0), ARG (1));
		break;
	case MIPS_INS_CMP:
	case MIPS_INS_CMPU:
	case MIPS_INS_CMPGU:
	case MIPS_INS_CMPGDU:
	case MIPS_INS_CMPI:
		r_strbuf_appendf (&op->esil, "%s,%s,==", ARG (1), ARG (0));
		break;
	case MIPS_INS_SHRAV:
	case MIPS_INS_SHRAV_R:
	case MIPS_INS_SHRA:
	case MIPS_INS_SHRA_R:
	case MIPS_INS_SRA:
		r_strbuf_appendf (&op->esil, "%s,%s,>>,31,%s,>>,?{,32,%s,-,%s,1,<<,1,-,<<,}{,0,},|,%s,=,",
			ARG (2), ARG (1), ARG (1), ARG (2), ARG (2), ARG (0));
		break;
	case MIPS_INS_SHRL:
		// suffix 'S' forces conditional flag to be updated
	case MIPS_INS_SRLV:
	case MIPS_INS_SRL:
		r_strbuf_appendf (&op->esil, "%s,%s,>>,%s,=", ARG (2), ARG (1), ARG (0));
		break;
	case MIPS_INS_SLLV:
	case MIPS_INS_SLL:
		r_strbuf_appendf (&op->esil, "%s,%s,<<,%s,=", ARG (2), ARG (1), ARG (0));
		break;
	case MIPS_INS_BAL:
	case MIPS_INS_JAL:
		r_strbuf_appendf (&op->esil, ES_TRAP_DS () "," ES_CALL_D ("%s"), ARG (0));
		break;
	case MIPS_INS_JALR:
	case MIPS_INS_JALRS:
		if (OPCOUNT () < 2) {
			r_strbuf_appendf (&op->esil, ES_TRAP_DS () "," ES_CALL_D ("%s"), ARG (0));
		} else {
			PROTECT_ZERO () {
				r_strbuf_appendf (&op->esil, ES_TRAP_DS () "," ES_CALL_DR ("%s","%s"), ARG (0), ARG (1));
			}
		}
		break;
	case MIPS_INS_JALRC: // no delay
		if (OPCOUNT () < 2) {
			r_strbuf_appendf (&op->esil, ES_TRAP_DS () "," ES_CALL_ND ("%s"), ARG (0));
		} else {
			PROTECT_ZERO () {
				r_strbuf_appendf (&op->esil, ES_TRAP_DS () "," ES_CALL_NDR ("%s","%s"), ARG (0), ARG (1));
			}
		}
		break;
	case MIPS_INS_JRADDIUSP:
		// increment stackpointer in X and jump to %ra
		r_strbuf_appendf (&op->esil, ES_TRAP_DS () ",%d,sp,+=,"ES_J ("ra"), ARG (0));
		break;
	case MIPS_INS_JR:
	case MIPS_INS_JRC:
	case MIPS_INS_J:
	case MIPS_INS_B: // ???
		// jump to address with conditional
		r_strbuf_appendf (&op->esil, ES_TRAP_DS () "," ES_J ("%s"), ARG (0));
		break;
	case MIPS_INS_BNE:  // bne $s, $t, offset
		r_strbuf_appendf (&op->esil, ES_TRAP_DS () ",%s,%s,==,$z,!,?{,"ES_J ("%s")",}",
			ARG (0), ARG (1), ARG (2));
		break;
	case MIPS_INS_BEQ:
		r_strbuf_appendf (&op->esil, ES_TRAP_DS () ",%s,%s,==,$z,?{,"ES_J ("%s")",}",
			ARG (0), ARG (1), ARG (2));
		break;
	case MIPS_INS_BZ:
	case MIPS_INS_BEQZ:
	case MIPS_INS_BEQZC:
		r_strbuf_appendf (&op->esil, ES_TRAP_DS () ",%s,0,==,$z,?{,"ES_J ("%s")",}",
			ARG (0), ARG (1));
		break;
	case MIPS_INS_BNEZ:
		r_strbuf_appendf (&op->esil, ES_TRAP_DS () ",%s,0,==,$z,!,?{,"ES_J ("%s")",}",
			ARG (0), ARG (1));
		break;
	case MIPS_INS_BEQZALC:
		r_strbuf_appendf (&op->esil, ES_TRAP_DS () ",%s,0,==,$z,?{,"ES_CALL_ND ("%s")",}",
			ARG (0), ARG (1));
		break;
	case MIPS_INS_BLEZ:
	case MIPS_INS_BLEZC:
		r_strbuf_appendf (&op->esil, ES_TRAP_DS () ",0,%s,==,$z,?{,"ES_J ("%s")",BREAK,},",
			ARG (0), ARG (1));
		r_strbuf_appendf (&op->esil, ES_TRAP_DS () ",1,"ES_IS_NEGATIVE ("%s")",==,$z,?{,"ES_J ("%s")",}",
			ARG (0), ARG (1));
		break;
	case MIPS_INS_BGEZ:
	case MIPS_INS_BGEZC:
		r_strbuf_appendf (&op->esil, ES_TRAP_DS () ",0,"ES_IS_NEGATIVE ("%s")",==,$z,?{,"ES_J ("%s")",}",
			ARG (0), ARG (1));
		break;
	case MIPS_INS_BGEZAL:
		r_strbuf_appendf (&op->esil, ES_TRAP_DS () ",0,"ES_IS_NEGATIVE ("%s")",==,$z,?{,"ES_CALL_D ("%s")",}",
			ARG (0), ARG (1));
		break;
	case MIPS_INS_BGEZALC:
		r_strbuf_appendf (&op->esil, ES_TRAP_DS () ",0,"ES_IS_NEGATIVE ("%s")",==,$z,?{,"ES_CALL_ND ("%s")",}",
			ARG (0), ARG (1));
		break;
	case MIPS_INS_BGTZALC:
		r_strbuf_appendf (&op->esil, ES_TRAP_DS () ",0,%s,==,$z,?{,BREAK,},", ARG(0));
		r_strbuf_appendf (&op->esil, "0,"ES_IS_NEGATIVE ("%s")",==,$z,?{,"ES_CALL_ND ("%s")",}",
			ARG (0), ARG (1));
		break;
	case MIPS_INS_BLTZAL:
		r_strbuf_appendf (&op->esil, ES_TRAP_DS () ",1,"ES_IS_NEGATIVE ("%s")",==,$z,?{,"ES_CALL_D ("%s")",}", ARG(0), ARG(1));
		break;
	case MIPS_INS_BLTZ:
	case MIPS_INS_BLTZC:
		r_strbuf_appendf (&op->esil, ES_TRAP_DS () ",1,"ES_IS_NEGATIVE ("%s")",==,$z,?{,"ES_J ("%s")",}",
			ARG (0), ARG (1));
		break;
	case MIPS_INS_BGTZ:
	case MIPS_INS_BGTZC:
		r_strbuf_appendf (&op->esil, ES_TRAP_DS () ",0,%s,==,$z,?{,BREAK,},", ARG (0));
		r_strbuf_appendf (&op->esil, ES_TRAP_DS () ",0,"ES_IS_NEGATIVE ("%s")",==,$z,?{,"ES_J("%s")",}",
			ARG (0), ARG (1));
		break;
	case MIPS_INS_BTEQZ:
		r_strbuf_appendf (&op->esil, ES_TRAP_DS () ",0,t,==,$z,?{,"ES_J ("%s")",}", ARG (0));
		break;
	case MIPS_INS_BTNEZ:
		r_strbuf_appendf (&op->esil, ES_TRAP_DS () ",0,t,==,$z,!,?{,"ES_J ("%s")",}", ARG (0));
		break;
	case MIPS_INS_MOV:
	case MIPS_INS_MOVE:
		PROTECT_ZERO () {
			r_strbuf_appendf (&op->esil, "%s,%s,=", ARG (1), REG (0));
		}
		break;
	case MIPS_INS_MOVZ:
	case MIPS_INS_MOVF:
		PROTECT_ZERO () {
			r_strbuf_appendf (&op->esil, "0,%s,==,$z,?{,%s,%s,=,}",
				ARG (2), ARG (1), REG (0));
		}
		break;
	case MIPS_INS_MOVT:
		PROTECT_ZERO () {
			r_strbuf_appendf (&op->esil, "1,%s,==,$z,?{,%s,%s,=,}",
				ARG (2), ARG (1), REG (0));
		}
		break;
	case MIPS_INS_FSUB:
	case MIPS_INS_SUB:
	case MIPS_INS_SUBU:
	case MIPS_INS_DSUB:
	case MIPS_INS_DSUBU:
		PROTECT_ZERO () {
			r_strbuf_appendf(&op->esil, "%s,%s,-,%s,=",
				ARG (2), ARG (1), ARG (0));
		}
		break;
	case MIPS_INS_NEG:
	case MIPS_INS_NEGU:
		r_strbuf_appendf (&op->esil, "%s,0,-,%s,=,",
			ARG (1), ARG (0));
		break;

	/** signed -- sets overflow flag */
	case MIPS_INS_ADD:
		{
		PROTECT_ZERO () {
			r_strbuf_appendf(&op->esil, "%s,%s,+,%s,=",
				ARG (1), ARG (2), ARG (0));
#if 0
			r_strbuf_appendf (&op->esil,
				"0,32,%s,%s,+,>>,>,?{,1,TRAP,}{,%s,%s,+,%s,=,}",
				ARG(2), ARG(1), ARG(2), ARG(1), ARG(0));
#endif
		}
		}
		break;
	case MIPS_INS_ADDI:
		PROTECT_ZERO () {
			r_strbuf_appendf (&op->esil, "0,32,%s,0xffffffff,&,%s,+,>>,>,?{,1,TRAP,}{,%s,%s,+,%s,=,}",
				ARG(2), ARG(1), ARG(2), ARG(1), ARG(0));
		}
		break;
	case MIPS_INS_DADD:
	case MIPS_INS_DADDI:
	/** unsigned */
	case MIPS_INS_ADDU:
	case MIPS_INS_ADDIU:
	case MIPS_INS_DADDIU:
		{
		const char *arg0 = ARG(0);
		const char *arg1 = ARG(1);
		const char *arg2 = ARG(2);
		PROTECT_ZERO () {
			if (*arg2 == '-') {
				r_strbuf_appendf (&op->esil, "%s,%s,-,%s,=",
						arg2+1, arg1, arg0);
			} else {
				r_strbuf_appendf (&op->esil, "%s,%s,+,%s,=",
						arg2, arg1, arg0);
			}
		}
		}
		break;
	case MIPS_INS_LI:
		r_strbuf_appendf (&op->esil, "0x%"PFMT64x",%s,=", IMM(1), ARG(0));
		break;
	case MIPS_INS_LUI:
		r_strbuf_appendf (&op->esil, "0x%"PFMT64x"0000,%s,=", IMM(1), ARG(0));
		break;
	case MIPS_INS_LB:
	case MIPS_INS_LBU:
		//one of these is wrong
		ESIL_LOAD ("1");
		break;
	case MIPS_INS_LW:
	case MIPS_INS_LWC1:
	case MIPS_INS_LWC2:
	case MIPS_INS_LWL:
	case MIPS_INS_LWR:
	case MIPS_INS_LWU:
	case MIPS_INS_LL:
	case MIPS_INS_LLD:
	case MIPS_INS_LD:
	case MIPS_INS_LDI:
	case MIPS_INS_LDL:
	case MIPS_INS_LDC1:
	case MIPS_INS_LDC2:
		ESIL_LOAD ("4");
		break;

	case MIPS_INS_LWX:
	case MIPS_INS_LH:
	case MIPS_INS_LHU:
	case MIPS_INS_LHX:
		ESIL_LOAD ("2");
		break;

	case MIPS_INS_AND:
	case MIPS_INS_ANDI:
		{
		const char *arg0 = ARG(0);
		const char *arg1 = ARG(1);
		const char *arg2 = ARG(2);
		if (!strcmp (arg0, arg1)) {
			r_strbuf_appendf (&op->esil, "%s,%s,&=", arg2, arg1);
		} else {
			r_strbuf_appendf (&op->esil, "%s,%s,&,%s,=", arg2, arg1, arg0);
		}
		}
		break;
	case MIPS_INS_OR:
	case MIPS_INS_ORI:
		{
		const char *arg0 = ARG(0);
		const char *arg1 = ARG(1);
		const char *arg2 = ARG(2);
		PROTECT_ZERO () {
			r_strbuf_appendf (&op->esil, "%s,%s,|,%s,=",
				arg2, arg1, arg0);
		}
		}
		break;
	case MIPS_INS_XOR:
	case MIPS_INS_XORI:
		{
		const char *arg0 = ARG(0);
		const char *arg1 = ARG(1);
		const char *arg2 = ARG(2);
		PROTECT_ZERO () {
			r_strbuf_appendf (&op->esil, "%s,%s,^,%s,=",
				arg2, arg1, arg0);
		}
		}
		break;
	case MIPS_INS_NOR:
		{
		const char *arg0 = ARG(0);
		const char *arg1 = ARG(1);
		const char *arg2 = ARG(2);
		PROTECT_ZERO () {
			r_strbuf_appendf (&op->esil, "%s,%s,|,0xffffffff,^,%s,=",
				arg2, arg1, arg0);
		}
		}
		break;
	case MIPS_INS_SLT:
	case MIPS_INS_SLTI:
		if (OPCOUNT () < 3) {
			r_strbuf_appendf (&op->esil,
				ES_IS_NEGATIVE ("%s")","
				ES_IS_NEGATIVE ("%s")","
				"==,$z,?{,"
					"%s,%s,<,t,=,"
				"}{,"
					"%s,%s,>=,t,=,"
				"}",

				ARG (1),
				ARG (0),
				ARG (1), ARG (0),
				ARG (1), ARG (0));
		} else {
			r_strbuf_appendf (&op->esil,
				ES_IS_NEGATIVE ("%s")","
				ES_IS_NEGATIVE ("%s")","
				"==,$z,?{,"
					"%s,%s,<,%s,=,"
				"}{,"
					"%s,%s,>=,%s,=,"
				"}",

				ARG (2),
				ARG (1),
				ARG (2), ARG (1), ARG (0),
				ARG (2), ARG (1), ARG (0));
		}
		break;
	case MIPS_INS_SLTU:
	case MIPS_INS_SLTIU:
		if (OPCOUNT () < 3) {
			r_strbuf_appendf (&op->esil, "%s,0xffffffff,&,%s,0xffffffff,&,<,t,=",
				ARG (1), ARG (0));
		} else {
			r_strbuf_appendf (&op->esil, "%s,0xffffffff,&,%s,0xffffffff,&,<,%s,=",
				ARG (2), ARG (1), ARG (0));
		}
		break;
	case MIPS_INS_MULT:
	case MIPS_INS_MULTU:
		r_strbuf_appendf (&op->esil,
			"%s,%s,*,0xffffffff,&,lo,=,"
			ES_SIGN_EXT64 ("lo")
			",32,%s,%s,*,>>,0xffffffff,&,hi,=,"
			ES_SIGN_EXT64 ("hi"),

			ARG (0), ARG (1), ARG (0), ARG (1));
		break;
	case MIPS_INS_MFLO:
		PROTECT_ZERO () {
			r_strbuf_appendf (&op->esil, "lo,%s,=", REG (0));
		}
		break;
	case MIPS_INS_MFHI:
		PROTECT_ZERO () {
			r_strbuf_appendf (&op->esil, "hi,%s,=", REG (0));
		}
		break;
	case MIPS_INS_MTLO:
		r_strbuf_appendf (&op->esil, "%s,lo,=,"ES_SIGN_EXT64 ("lo"), REG (0));
		break;
	case MIPS_INS_MTHI:
		r_strbuf_appendf (&op->esil, "%s,hi,=,"ES_SIGN_EXT64 ("hi"), REG (0));
		break;
#if 0
	// could not test div
	case MIPS_INS_DIV:
	case MIPS_INS_DIVU:
	case MIPS_INS_DDIV:
	case MIPS_INS_DDIVU:
		PROTECT_ZERO () {
			// 32 bit needs sign extend
			r_strbuf_appendf (&op->esil, "%s,%s,/,lo,=,%s,%s,%%,hi,=", REG(1), REG(0), REG(1), REG(0));
		}
		break;
#endif
	default:
		return -1;
	}
	return 0;
}
Example #24
0
void Flogeqv(CL_FORM *base, int nargs)
{
	Flist(ARG(0), nargs - 0);
	LOAD_FIXNUM(ARG(1), -1, ARG(1));
	M1_1:;
	if(CL_TRUEP(ARG(0)))
	{
	}
	else
	{
		COPY(ARG(1), ARG(0));
		goto RETURN1;
	}
	COPY(ARG(0), ARG(3));
	COPY(ARG(3), ARG(4));
	if(CL_CONSP(ARG(4)))
	{
		COPY(GET_CAR(ARG(4)), ARG(3));
	}
	else
	{
		LOAD_SMSTR((CL_FORM *)&KClisp[264], ARG(3));	/* ~a is not a list */
		Ferror(ARG(3), 2);
	}
	COPY(ARG(0), ARG(4));
	COPY(ARG(4), ARG(5));
	if(CL_CONSP(ARG(5)))
	{
		COPY(GET_CDR(ARG(5)), ARG(0));
	}
	else
	{
		LOAD_SMSTR((CL_FORM *)&KClisp[262], ARG(6));	/* ~a is not a list */
		COPY(ARG(5), ARG(7));
		Ferror(ARG(6), 2);
	}
	if(CL_FIXNUMP(ARG(3)))
	{
	}
	else
	{
		COPY(ARG(3), ARG(4));
		LOAD_SMSTR((CL_FORM *)&KClisp[244], ARG(3));	/* type error: ~S is not of type ~S */
		LOAD_SYMBOL(SYMBOL(Slisp, 23), ARG(5));	/* FIXNUM */
		Ferror(ARG(3), 3);
	}
	LOAD_FIXNUM(ARG(4), GET_FIXNUM(ARG(1)) ^ GET_FIXNUM(ARG(3)), ARG(2));
	LOAD_FIXNUM(ARG(3),  ~ GET_FIXNUM(ARG(2)), ARG(1));
	goto M1_1;
	RETURN1:;
}
Example #25
0
void hash_table_array(CL_FORM *base)
{
	COPY(ARG(0), ARG(1));
	LOAD_SYMBOL(SYMBOL(Slisp, 389), ARG(2));	/* HASH-TABLE */
	rt_struct_typep(ARG(1));
	if(CL_TRUEP(ARG(1)))
	{
		COPY(OFFSET(AR_BASE(GET_FORM(ARG(0))), 5 + 1), ARG(0));
	}
	else
	{
		COPY(SYMVAL(Slisp, 342), ARG(1));	/* NO_STRUCT */
		COPY(ARG(0), ARG(2));
		LOAD_SYMBOL(SYMBOL(Slisp, 389), ARG(3));	/* HASH-TABLE */
		Ferror(ARG(1), 3);
	}
}
Example #26
0
void Flist_all_packages(CL_FORM *base)
{
	LOAD_SYMBOL(SYMBOL(Slisp, 28), ARG(0));	/* LIST */
	COPY(SYMVAL(Slisp, 379), ARG(1));	/* *PACKAGE-ARRAY* */
	Fconcatenate(ARG(0), 2);
}
Example #27
0
void Fset_hash_table_size(CL_FORM *base)
{
	LOAD_SMALLFIXNUM(0, ARG(2));
	LOAD_SYMBOL(SYMBOL(Slisp, 389), ARG(3));	/* HASH-TABLE */
	rt_set_struct_ref(ARG(0));
}
Example #28
0
static int analop_esil(RAnal *a, RAnalOp *op, ut64 addr, const ut8 *buf, int len, csh *handle, cs_insn *insn) {
	int i;
	char str[32][32];
	r_strbuf_init (&op->esil);
	r_strbuf_set (&op->esil, "");
	switch (insn->detail->arm.cc) {
	case ARM_CC_AL:
		// no condition
		break;
	case ARM_CC_EQ:
		r_strbuf_setf (&op->esil, "zf,0,?,");
		break;
	case ARM_CC_NE:
		r_strbuf_setf (&op->esil, "zf,!,0,?,");
		break;
	case ARM_CC_GT:
	case ARM_CC_LE:
		break;
	}
	// TODO: PREFIX CONDITIONAL
	switch (insn->id) {
	case ARM_INS_PUSH:
		// TODO: increment stack
	case ARM_INS_STM:
		for (i=1; i<insn->detail->arm.op_count; i++) {
			r_strbuf_appendf (&op->esil, "%s,%s,%d,+,=[4],",
				REG (i), ARG (0), i*4);
		}
		break;
	case ARM_INS_POP:
		// TODO: decrement stack
	case ARM_INS_LDM:
		for (i=1; i<insn->detail->arm.op_count; i++) {
			r_strbuf_appendf (&op->esil, "%s,%d,+,[4],%s,=",
				ARG (0), i*4, REG (i));
		}
		break;
	case ARM_INS_CMP:
		r_strbuf_appendf (&op->esil, "%s,%s,==", ARG(1), ARG(0));
		break;
	case ARM_INS_LSL:
		// suffix 'S' forces conditional flag to be updated
		r_strbuf_appendf (&op->esil, "%s,%s,<<=", ARG(1), ARG(0));
		break;
	case ARM_INS_LSR:
		// suffix 'S' forces conditional flag to be updated
		r_strbuf_appendf (&op->esil, "%s,%s,>>=", ARG(1), ARG(0));
		break;
	case ARM_INS_B:
	case ARM_INS_BL:
	case ARM_INS_BLX:
		r_strbuf_appendf (&op->esil, "%s,pc,=", ARG(0));
		break;
	case ARM_INS_MOV:
	case ARM_INS_MOVS:
		r_strbuf_appendf (&op->esil, "%s,%s,=", ARG(1), REG(0));
		break;
	case ARM_INS_SSUB16:
	case ARM_INS_SSUB8:
	case ARM_INS_SUB:
		r_strbuf_appendf (&op->esil, "%s,%s,-=", ARG(1), ARG(0));
		break;
	case ARM_INS_SADD16:
	case ARM_INS_SADD8:
	case ARM_INS_ADD:
		r_strbuf_appendf (&op->esil, "%s,%s,+=", ARG(1), ARG(0));
		break;
	case ARM_INS_LDR:
		r_strbuf_appendf (&op->esil, "%s,%d,+,[4],%s,=",
			MEMBASE(1), MEMDISP(1), REG(0));
		break;
	case ARM_INS_LDRB:
		r_strbuf_appendf (&op->esil, "%s,%d,+,[1],%s,=",
			MEMBASE(1), MEMDISP(1), REG(0));
		break;
	}
	return 0;
}
Example #29
0
int
_rsModAVUMetadata (rsComm_t *rsComm, modAVUMetadataInp_t *modAVUMetadataInp )
{
    int status;

    char *args[MAX_NUM_OF_ARGS_IN_ACTION];
    int i, argc;
    ruleExecInfo_t rei2;

    memset ((char*)&rei2, 0, sizeof (ruleExecInfo_t));
    rei2.rsComm = rsComm;
    if (rsComm != NULL) {
      rei2.uoic = &rsComm->clientUser;
      rei2.uoip = &rsComm->proxyUser;
    }

    /** RAJA ADDED June 1 2009 for pre-post processing rule hooks **/
    args[0] = modAVUMetadataInp->arg0; /* option add, adda, rm, rmw, rmi, cp,
					  or mod */
    args[1] = modAVUMetadataInp->arg1; /* item type -d,-d,-c,-C,-r,-R,-u,-U */
    args[2] = modAVUMetadataInp->arg2; /* item name */
    args[3] = modAVUMetadataInp->arg3; /* attr name */
    args[4] = modAVUMetadataInp->arg4; /* attr val */
    args[5] = modAVUMetadataInp->arg5;
    if(args[5] == NULL) args[5] = ""; /* attr unit */
    if(strcmp(args[0], "mod") == 0) {
    	argc = 9;
#define ARG(arg) if((arg) != NULL && (arg)[0] != '\0') avu[checkModArgType(arg)] = arg
    	if(checkModArgType(modAVUMetadataInp->arg5) != 0) {
    		char *avu[4] = {"", "", "", ""};
    		ARG(modAVUMetadataInp->arg5);
    		ARG(modAVUMetadataInp->arg6);
    		ARG(modAVUMetadataInp->arg7);
    		args[5] = "";
    		memcpy(args+6, avu+1, sizeof(char *[3]));
    	} else {
    		char *avu[4] = {"", "", "", ""};
    	    ARG(modAVUMetadataInp->arg6); /* new attr */
    	    ARG(modAVUMetadataInp->arg7); /* new val */
    	    ARG(modAVUMetadataInp->arg8); /* new unit */
    		memcpy(args+6, avu+1, sizeof(char *[3]));
    	}
    } else if(strcmp(args[0], "cp") == 0) {
    	argc = 5;
    } else {
    	argc = 6;
    }
    i =  applyRuleArg("acPreProcForModifyAVUMetadata",args,argc, &rei2, NO_SAVE_REI);
    if (i < 0) {
      if (rei2.status < 0) {
	i = rei2.status;
      }
      rodsLog (LOG_ERROR,
	       "rsModAVUMetadata:acPreProcForModifyAVUMetadata error for %s of type %s and option %s,stat=%d",
	       modAVUMetadataInp->arg2,modAVUMetadataInp->arg1,modAVUMetadataInp->arg0, i);
      return i;
    }
    /** RAJA ADDED June 1 2009 for pre-post processing rule hooks **/


    if (strcmp(modAVUMetadataInp->arg0,"add")==0) {
       status = chlAddAVUMetadata(rsComm, 0,
				  modAVUMetadataInp->arg1,
				  modAVUMetadataInp->arg2,
				  modAVUMetadataInp->arg3,
				  modAVUMetadataInp->arg4,
				  modAVUMetadataInp->arg5);
    }
    else if (strcmp(modAVUMetadataInp->arg0,"adda")==0) {
       status = chlAddAVUMetadata(rsComm, 1,
				  modAVUMetadataInp->arg1,
				  modAVUMetadataInp->arg2,
				  modAVUMetadataInp->arg3,
				  modAVUMetadataInp->arg4,
				  modAVUMetadataInp->arg5);
    }
    else if (strcmp(modAVUMetadataInp->arg0,"addw")==0) {
       status = chlAddAVUMetadataWild(rsComm, 0,
				  modAVUMetadataInp->arg1,
				  modAVUMetadataInp->arg2,
				  modAVUMetadataInp->arg3,
				  modAVUMetadataInp->arg4,
				  modAVUMetadataInp->arg5);
    }
    else if (strcmp(modAVUMetadataInp->arg0,"rmw")==0) {
       status = chlDeleteAVUMetadata(rsComm, 1,
				  modAVUMetadataInp->arg1,
				  modAVUMetadataInp->arg2,
				  modAVUMetadataInp->arg3,
				  modAVUMetadataInp->arg4,
				  modAVUMetadataInp->arg5,
				  0);
    }
    else if (strcmp(modAVUMetadataInp->arg0,"rmi")==0) {
       status = chlDeleteAVUMetadata(rsComm, 2,
				  modAVUMetadataInp->arg1,
				  modAVUMetadataInp->arg2,
				  modAVUMetadataInp->arg3,
				  modAVUMetadataInp->arg4,
				  modAVUMetadataInp->arg5,
				  0);
    }
    else if (strcmp(modAVUMetadataInp->arg0,"rm")==0) {
       status = chlDeleteAVUMetadata(rsComm, 0,
				  modAVUMetadataInp->arg1,
				  modAVUMetadataInp->arg2,
				  modAVUMetadataInp->arg3,
				  modAVUMetadataInp->arg4,
			          modAVUMetadataInp->arg5, 
				  0);
    }
    else if (strcmp(modAVUMetadataInp->arg0,"cp")==0) {
       status = chlCopyAVUMetadata(rsComm, 
				  modAVUMetadataInp->arg1,
				  modAVUMetadataInp->arg2,
				  modAVUMetadataInp->arg3,
				  modAVUMetadataInp->arg4);
    }
    else if (strcmp(modAVUMetadataInp->arg0,"mod")==0) {
       status = chlModAVUMetadata(rsComm, 
				  modAVUMetadataInp->arg1,
				  modAVUMetadataInp->arg2,
				  modAVUMetadataInp->arg3,
				  modAVUMetadataInp->arg4,
				  modAVUMetadataInp->arg5,
				  modAVUMetadataInp->arg6,
				  modAVUMetadataInp->arg7,
				  modAVUMetadataInp->arg8);
    }
    else if (strcmp(modAVUMetadataInp->arg0,"set")==0) {
       status = chlSetAVUMetadata(rsComm, 
				  modAVUMetadataInp->arg1,
				  modAVUMetadataInp->arg2,
				  modAVUMetadataInp->arg3,
				  modAVUMetadataInp->arg4,
				  modAVUMetadataInp->arg5);
    }
    else {
      return(CAT_INVALID_ARGUMENT);
    }      
    /* rei2.status = status; */
    /** RAJA ADDED June 1 2009 for pre-post processing rule hooks **/
    i =  applyRuleArg("acPostProcForModifyAVUMetadata",args,argc, &rei2, NO_SAVE_REI);
    if (i < 0) {
      if (rei2.status < 0) {
        i = rei2.status;
      }
      rodsLog (LOG_ERROR,
               "rsModAVUMetadata:acPostProcForModifyAVUMetadata error for %s of type %s and option %s,stat=%d",
               modAVUMetadataInp->arg2,modAVUMetadataInp->arg1,modAVUMetadataInp->arg0, i);
      return i;
    }
    /** RAJA ADDED June 1 2009 for pre-post processing rule hooks **/

    return(status);

} 
Example #30
0
void Flognand(CL_FORM *base)
{
	Flogand(ARG(0), 2);
	Flognot(ARG(0));
}