Пример #1
0
/*
 - regprop - printable representation of opcode
 */
static char *
regprop( char *op )
{
    register char *p;
    static char buf[50];

    (void) strcpy(buf, ":");

    switch (OP(op)) {
    case BOL:
        p = "BOL";
        break;
    case EOL:
        p = "EOL";
        break;
    case ANY:
        p = "ANY";
        break;
    case ANYOF:
        p = "ANYOF";
        break;
    case ANYBUT:
        p = "ANYBUT";
        break;
    case BRANCH:
        p = "BRANCH";
        break;
    case EXACTLY:
        p = "EXACTLY";
        break;
    case NOTHING:
        p = "NOTHING";
        break;
    case BACK:
        p = "BACK";
        break;
    case END:
        p = "END";
        break;
    case OPEN+1:
    case OPEN+2:
    case OPEN+3:
    case OPEN+4:
    case OPEN+5:
    case OPEN+6:
    case OPEN+7:
    case OPEN+8:
    case OPEN+9:
        sprintf(buf+strlen(buf), "OPEN%d", OP(op)-OPEN);
        p = NULL;
        break;
    case CLOSE+1:
    case CLOSE+2:
    case CLOSE+3:
    case CLOSE+4:
    case CLOSE+5:
    case CLOSE+6:
    case CLOSE+7:
    case CLOSE+8:
    case CLOSE+9:
        sprintf(buf+strlen(buf), "CLOSE%d", OP(op)-CLOSE);
        p = NULL;
        break;
    case STAR:
        p = "STAR";
        break;
    case PLUS:
        p = "PLUS";
        break;
    case WORDA:
        p = "WORDA";
        break;
    case WORDZ:
        p = "WORDZ";
        break;
    default:
        regerror("corrupted opcode");
        break;
    }
    if (p != NULL)
        (void) strcat(buf, p);
    return(buf);
}
Пример #2
0
#define MW mmix_type_memaccess_wyde
#define MT mmix_type_memaccess_tetra
#define MO mmix_type_memaccess_octa
#define M mmix_type_memaccess_block
#define J mmix_type_jsr
#define P mmix_type_pseudo

#define OP(y) XCONCAT2 (mmix_operands_,y)

/* Groups of instructions specified here must, if all are matching the
   same instruction, be consecutive, in order more-specific to
   less-specific match.  */

const struct mmix_opcode mmix_opcodes[] =
 {
   {"trap",	O (0),		OP (xyz_opt),		J},
   {"fcmp",	O (1),		OP (regs),		N},
   {"flot",	Z (8),		OP (roundregs_z),	N},

   {"fun",	O (2),		OP (regs),		N},
   {"feql",	O (3),		OP (regs),		N},
   {"flotu",	Z (10),		OP (roundregs_z),	N},

   {"fadd",	O (4),		OP (regs),		N},
   {"fix",	O (5),		OP (roundregs),		N},
   {"sflot",	Z (12),		OP (roundregs_z),	N},

   {"fsub",	O (6),		OP (regs),		N},
   {"fixu",	O (7),		OP (roundregs),		N},
   {"sflotu",	Z (14),		OP (roundregs_z),	N},
Пример #3
0
/****************
 * transform n*64 bytes
 */
static void
/*transform( MD5_CONTEXT *ctx, const void *buffer, size_t len )*/
transform( MD5_CONTEXT *ctx, byte *data )
{
    u32 correct_words[16];
    register u32 A = ctx->A;
    register u32 B = ctx->B;
    register u32 C = ctx->C;
    register u32 D = ctx->D;
    u32 *cwp = correct_words;
    int i;
    byte *p1;

    for(i=0, p1=data; i < 16; i++, p1 += 4)
	correct_words[i] = p1[0] | (p1[1] << 8) | (p1[2] << 16) | (p1[3] << 24);

#define OP(a, b, c, d, s, T)					    \
  do								    \
    {								    \
      a += FF (b, c, d) + (*cwp++) + T; 	    \
      a = rol(a, s);						    \
      a += b;							    \
    }								    \
  while (0)

    /* Before we start, one word about the strange constants.
       They are defined in RFC 1321 as

       T[i] = (int) (4294967296.0 * fabs (sin (i))), i=1..64
     */

    /* Round 1.  */
    OP (A, B, C, D,  7, 0xd76aa478);
    OP (D, A, B, C, 12, 0xe8c7b756);
    OP (C, D, A, B, 17, 0x242070db);
    OP (B, C, D, A, 22, 0xc1bdceee);
    OP (A, B, C, D,  7, 0xf57c0faf);
    OP (D, A, B, C, 12, 0x4787c62a);
    OP (C, D, A, B, 17, 0xa8304613);
    OP (B, C, D, A, 22, 0xfd469501);
    OP (A, B, C, D,  7, 0x698098d8);
    OP (D, A, B, C, 12, 0x8b44f7af);
    OP (C, D, A, B, 17, 0xffff5bb1);
    OP (B, C, D, A, 22, 0x895cd7be);
    OP (A, B, C, D,  7, 0x6b901122);
    OP (D, A, B, C, 12, 0xfd987193);
    OP (C, D, A, B, 17, 0xa679438e);
    OP (B, C, D, A, 22, 0x49b40821);

#undef OP
#define OP(f, a, b, c, d, k, s, T)  \
    do								      \
      { 							      \
	a += f (b, c, d) + correct_words[k] + T;		      \
	a = rol(a, s);						      \
	a += b; 						      \
      } 							      \
    while (0)

    /* Round 2.  */
    OP (FG, A, B, C, D,  1,  5, 0xf61e2562);
    OP (FG, D, A, B, C,  6,  9, 0xc040b340);
    OP (FG, C, D, A, B, 11, 14, 0x265e5a51);
    OP (FG, B, C, D, A,  0, 20, 0xe9b6c7aa);
    OP (FG, A, B, C, D,  5,  5, 0xd62f105d);
    OP (FG, D, A, B, C, 10,  9, 0x02441453);
    OP (FG, C, D, A, B, 15, 14, 0xd8a1e681);
    OP (FG, B, C, D, A,  4, 20, 0xe7d3fbc8);
    OP (FG, A, B, C, D,  9,  5, 0x21e1cde6);
    OP (FG, D, A, B, C, 14,  9, 0xc33707d6);
    OP (FG, C, D, A, B,  3, 14, 0xf4d50d87);
    OP (FG, B, C, D, A,  8, 20, 0x455a14ed);
    OP (FG, A, B, C, D, 13,  5, 0xa9e3e905);
    OP (FG, D, A, B, C,  2,  9, 0xfcefa3f8);
    OP (FG, C, D, A, B,  7, 14, 0x676f02d9);
    OP (FG, B, C, D, A, 12, 20, 0x8d2a4c8a);

    /* Round 3.  */
    OP (FH, A, B, C, D,  5,  4, 0xfffa3942);
    OP (FH, D, A, B, C,  8, 11, 0x8771f681);
    OP (FH, C, D, A, B, 11, 16, 0x6d9d6122);
    OP (FH, B, C, D, A, 14, 23, 0xfde5380c);
    OP (FH, A, B, C, D,  1,  4, 0xa4beea44);
    OP (FH, D, A, B, C,  4, 11, 0x4bdecfa9);
    OP (FH, C, D, A, B,  7, 16, 0xf6bb4b60);
    OP (FH, B, C, D, A, 10, 23, 0xbebfbc70);
    OP (FH, A, B, C, D, 13,  4, 0x289b7ec6);
    OP (FH, D, A, B, C,  0, 11, 0xeaa127fa);
    OP (FH, C, D, A, B,  3, 16, 0xd4ef3085);
    OP (FH, B, C, D, A,  6, 23, 0x04881d05);
    OP (FH, A, B, C, D,  9,  4, 0xd9d4d039);
    OP (FH, D, A, B, C, 12, 11, 0xe6db99e5);
    OP (FH, C, D, A, B, 15, 16, 0x1fa27cf8);
    OP (FH, B, C, D, A,  2, 23, 0xc4ac5665);

    /* Round 4.  */
    OP (FI, A, B, C, D,  0,  6, 0xf4292244);
    OP (FI, D, A, B, C,  7, 10, 0x432aff97);
    OP (FI, C, D, A, B, 14, 15, 0xab9423a7);
    OP (FI, B, C, D, A,  5, 21, 0xfc93a039);
    OP (FI, A, B, C, D, 12,  6, 0x655b59c3);
    OP (FI, D, A, B, C,  3, 10, 0x8f0ccc92);
    OP (FI, C, D, A, B, 10, 15, 0xffeff47d);
    OP (FI, B, C, D, A,  1, 21, 0x85845dd1);
    OP (FI, A, B, C, D,  8,  6, 0x6fa87e4f);
    OP (FI, D, A, B, C, 15, 10, 0xfe2ce6e0);
    OP (FI, C, D, A, B,  6, 15, 0xa3014314);
    OP (FI, B, C, D, A, 13, 21, 0x4e0811a1);
    OP (FI, A, B, C, D,  4,  6, 0xf7537e82);
    OP (FI, D, A, B, C, 11, 10, 0xbd3af235);
    OP (FI, C, D, A, B,  2, 15, 0x2ad7d2bb);
    OP (FI, B, C, D, A,  9, 21, 0xeb86d391);

    /* Put checksum in context given as argument.  */
    ctx->A += A;
    ctx->B += B;
    ctx->C += C;
    ctx->D += D;
}
Пример #4
0
void
arp_print(netdissect_options *ndo,
	  const u_char *bp, u_int length, u_int caplen)
{
	const struct arp_pkthdr *ap;
	u_short pro, hrd, op, linkaddr;

	ap = (const struct arp_pkthdr *)bp;
	ND_TCHECK(*ap);

	hrd = HRD(ap);
	pro = PRO(ap);
	op = OP(ap);

        
        /* if its ATM then call the ATM ARP printer
           for Frame-relay ARP most of the fields
           are similar to Ethernet so overload the Ethernet Printer
           and set the linkaddr type for linkaddr_string() accordingly */

        switch(hrd) {
        case ARPHRD_ATM2225:
            atmarp_print(ndo, bp, length, caplen);
            return;
        case ARPHRD_FRELAY:
            linkaddr = LINKADDR_FRELAY;
            break;
        default:
            linkaddr = LINKADDR_ETHER;
            break;
	}

	if (!ND_TTEST2(*ar_tpa(ap), PROTO_LEN(ap))) {
		ND_PRINT((ndo, "[|ARP]"));
		ND_DEFAULTPRINT((const u_char *)ap, length);
		return;
	}

        if (!ndo->ndo_eflag) {
            ND_PRINT((ndo, "ARP, "));
        }

        /* print hardware type/len and proto type/len */
        if ((pro != ETHERTYPE_IP && pro != ETHERTYPE_TRAIL) ||
	    PROTO_LEN(ap) != 4 ||
            HRD_LEN(ap) == 0 ||
            ndo->ndo_vflag) {
            ND_PRINT((ndo, "%s (len %u), %s (len %u)",
                      tok2str(arphrd_values, "Unknown Hardware (%u)", hrd),
                      HRD_LEN(ap),
                      tok2str(ethertype_values, "Unknown Protocol (0x%04x)", pro),
                      PROTO_LEN(ap)));

            /* don't know know about the address formats */
            if (!ndo->ndo_vflag) {
                goto out;
            }
	}

        /* print operation */
        printf("%s%s ",
               ndo->ndo_vflag ? ", " : "", 
               tok2str(arpop_values, "Unknown (%u)", op));

	switch (op) {

	case ARPOP_REQUEST:
		ND_PRINT((ndo, "who-has %s", ipaddr_string(TPA(ap))));
		if (memcmp((const char *)ezero, (const char *)THA(ap), HRD_LEN(ap)) != 0)
			ND_PRINT((ndo, " (%s)",
				  linkaddr_string(THA(ap), linkaddr, HRD_LEN(ap))));
		ND_PRINT((ndo, " tell %s", ipaddr_string(SPA(ap))));
		break;

	case ARPOP_REPLY:
		ND_PRINT((ndo, "%s is-at %s",
                          ipaddr_string(SPA(ap)),
                          linkaddr_string(SHA(ap), linkaddr, HRD_LEN(ap))));
		break;

	case ARPOP_REVREQUEST:
		ND_PRINT((ndo, "who-is %s tell %s",
			  linkaddr_string(THA(ap), linkaddr, HRD_LEN(ap)),
			  linkaddr_string(SHA(ap), linkaddr, HRD_LEN(ap))));
		break;

	case ARPOP_REVREPLY:
		ND_PRINT((ndo, "%s at %s",
			  linkaddr_string(THA(ap), linkaddr, HRD_LEN(ap)),
			  ipaddr_string(TPA(ap))));
		break;

	case ARPOP_INVREQUEST:
		ND_PRINT((ndo, "who-is %s tell %s",
			  linkaddr_string(THA(ap), linkaddr, HRD_LEN(ap)),
			  linkaddr_string(SHA(ap), linkaddr, HRD_LEN(ap))));
		break;

	case ARPOP_INVREPLY:
		ND_PRINT((ndo,"%s at %s",
			  linkaddr_string(THA(ap), linkaddr, HRD_LEN(ap)),
			  ipaddr_string(TPA(ap))));
		break;

	default:
		ND_DEFAULTPRINT((const u_char *)ap, caplen);
		return;
	}

 out:
        ND_PRINT((ndo, ", length %u", length));

	return;
trunc:
	ND_PRINT((ndo, "[|ARP]"));
}
Пример #5
0
#include "ngspice/ifsim.h"
#include "ngspice/devdefs.h"
#include "vcvsdefs.h"
#include "ngspice/suffix.h"

IFparm VCVSpTable[] = { /* parameters */ 
 IOPU("gain", VCVS_GAIN, IF_REAL,"Voltage gain"),
 IP("sens_gain",VCVS_GAIN_SENS,IF_FLAG,"flag to request sensitivity WRT gain"),
 OPU("pos_node", VCVS_POS_NODE, IF_INTEGER, "Positive node of source"),
 OPU("neg_node", VCVS_NEG_NODE, IF_INTEGER, "Negative node of source"),
 OPU("cont_p_node",VCVS_CONT_P_NODE,IF_INTEGER,
					"Positive node of contr. source"),
 OPU("cont_n_node",VCVS_CONT_N_NODE,IF_INTEGER,
					"Negative node of contr. source"),
 IP("ic", VCVS_IC, IF_REAL, "Initial condition of controlling source"),
 OP("i",        VCVS_CURRENT,       IF_REAL,        "Output current"),
 OP("v",        VCVS_VOLTS,         IF_REAL,        "Output voltage"),
 OP("p",        VCVS_POWER,         IF_REAL,        "Power"),
 OPU("sens_dc",   VCVS_QUEST_SENS_DC,  IF_REAL, "dc sensitivity "),
 OPU("sens_real", VCVS_QUEST_SENS_REAL,IF_REAL, "real part of ac sensitivity"),
 OPU("sens_imag", VCVS_QUEST_SENS_IMAG,IF_REAL, "imag part of ac sensitivity"),
 OPU("sens_mag",  VCVS_QUEST_SENS_MAG, IF_REAL, "sensitivity of ac magnitude"),
 OPU("sens_ph",   VCVS_QUEST_SENS_PH,  IF_REAL, "sensitivity of ac phase"),
 OPU("sens_cplx", VCVS_QUEST_SENS_CPLX,     IF_COMPLEX,    "ac sensitivity")
};

char *VCVSnames[] = {
    "V+",
    "V-",
    "VC+",
    "VC-"
Пример #6
0
/*
 - dissect - figure out what matched what, no back references
 == static const char *dissect(struct match *m, const char *start, \
 ==	const char *stop, sopno startst, sopno stopst);
 */
static const char *		/* == stop (success) always */
dissect(struct match *m,
	const char *start,
	const char *stop,
	sopno startst,
	sopno stopst)
{
	int i;
	sopno ss;		/* start sop of current subRE */
	sopno es;		/* end sop of current subRE */
	const char *sp;		/* start of string matched by it */
	const char *stp;	/* string matched by it cannot pass here */
	const char *rest;	/* start of rest of string */
	const char *tail;	/* string unmatched by rest of RE */
	sopno ssub;		/* start sop of subsubRE */
	sopno esub;		/* end sop of subsubRE */
	const char *ssp;	/* start of string matched by subsubRE */
	const char *sep;	/* end of string matched by subsubRE */
	const char *oldssp;	/* previous ssp */
	const char *dp;

	AT("diss", start, stop, startst, stopst);
	sp = start;
	for (ss = startst; ss < stopst; ss = es) {
		/* identify end of subRE */
		es = ss;
		switch (OP(m->g->strip[es])) {
		case OPLUS_:
		case OQUEST_:
			es += OPND(m->g->strip[es]);
			break;
		case OCH_:
			while (OP(m->g->strip[es]) != O_CH)
				es += OPND(m->g->strip[es]);
			break;
		}
		es++;

		/* figure out what it matched */
		switch (OP(m->g->strip[ss])) {
		case OEND:
			assert(nope);
			break;
		case OCHAR:
			sp += XMBRTOWC(NULL, sp, stop - start, &m->mbs, 0);
			break;
		case OBOL:
		case OEOL:
		case OBOW:
		case OEOW:
			break;
		case OANY:
		case OANYOF:
			sp += XMBRTOWC(NULL, sp, stop - start, &m->mbs, 0);
			break;
		case OBACK_:
		case O_BACK:
			assert(nope);
			break;
		/* cases where length of match is hard to find */
		case OQUEST_:
			stp = stop;
			for (;;) {
				/* how long could this one be? */
				rest = walk(m, sp, stp, ss, es, false);
				assert(rest != NULL);	/* it did match */
				/* could the rest match the rest? */
				tail = walk(m, rest, stop, es, stopst, false);
				if (tail == stop)
					break;		/* yes! */
				/* no -- try a shorter match for this one */
				stp = rest - 1;
				assert(stp >= sp);	/* it did work */
			}
			ssub = ss + 1;
			esub = es - 1;
			/* did innards match? */
			if (walk(m, sp, rest, ssub, esub, false) != NULL) {
				dp = dissect(m, sp, rest, ssub, esub);
				assert(dp == rest);
			} else		/* no */
				assert(sp == rest);
			sp = rest;
			break;
		case OPLUS_:
			stp = stop;
			for (;;) {
				/* how long could this one be? */
				rest = walk(m, sp, stp, ss, es, false);
				assert(rest != NULL);	/* it did match */
				/* could the rest match the rest? */
				tail = walk(m, rest, stop, es, stopst, false);
				if (tail == stop)
					break;		/* yes! */
				/* no -- try a shorter match for this one */
				stp = rest - 1;
				assert(stp >= sp);	/* it did work */
			}
			ssub = ss + 1;
			esub = es - 1;
			ssp = sp;
			oldssp = ssp;
			for (;;) {	/* find last match of innards */
				sep = walk(m, ssp, rest, ssub, esub, false);
				if (sep == NULL || sep == ssp)
					break;	/* failed or matched null */
				oldssp = ssp;	/* on to next try */
				ssp = sep;
			}
			if (sep == NULL) {
				/* last successful match */
				sep = ssp;
				ssp = oldssp;
			}
			assert(sep == rest);	/* must exhaust substring */
			assert(walk(m, ssp, sep, ssub, esub, false) == rest);
			dp = dissect(m, ssp, sep, ssub, esub);
			assert(dp == sep);
			sp = rest;
			break;
		case OCH_:
			stp = stop;
			for (;;) {
				/* how long could this one be? */
				rest = walk(m, sp, stp, ss, es, false);
				assert(rest != NULL);	/* it did match */
				/* could the rest match the rest? */
				tail = walk(m, rest, stop, es, stopst, false);
				if (tail == stop)
					break;		/* yes! */
				/* no -- try a shorter match for this one */
				stp = rest - 1;
				assert(stp >= sp);	/* it did work */
			}
			ssub = ss + 1;
			esub = ss + OPND(m->g->strip[ss]) - 1;
			assert(OP(m->g->strip[esub]) == OOR1);
			for (;;) {	/* find first matching branch */
				if (walk(m, sp, rest, ssub, esub, false) == rest)
					break;	/* it matched all of it */
				/* that one missed, try next one */
				assert(OP(m->g->strip[esub]) == OOR1);
				esub++;
				assert(OP(m->g->strip[esub]) == OOR2);
				ssub = esub + 1;
				esub += OPND(m->g->strip[esub]);
				if (OP(m->g->strip[esub]) == OOR2)
					esub--;
				else
					assert(OP(m->g->strip[esub]) == O_CH);
			}
			dp = dissect(m, sp, rest, ssub, esub);
			assert(dp == rest);
			sp = rest;
			break;
		case O_PLUS:
		case O_QUEST:
		case OOR1:
		case OOR2:
		case O_CH:
			assert(nope);
			break;
		case OLPAREN:
			i = OPND(m->g->strip[ss]);
			assert(0 < i && i <= m->g->nsub);
			m->pmatch[i].rm_so = sp - m->offp;
			break;
		case ORPAREN:
			i = OPND(m->g->strip[ss]);
			assert(0 < i && i <= m->g->nsub);
			m->pmatch[i].rm_eo = sp - m->offp;
			break;
		default:		/* uh oh */
			assert(nope);
			break;
		}
	}

	assert(sp == stop);
	return(sp);
}
Пример #7
0
/*
 - step - map set of states reachable before char to set reachable after
 == static states step(struct re_guts *g, sopno start, sopno stop, \
 ==	states bef, int ch, states aft);
 == #define	BOL	(OUT-1)
 == #define	EOL	(BOL-1)
 == #define	BOLEOL	(BOL-2)
 == #define	NOTHING	(BOL-3)
 == #define	BOW	(BOL-4)
 == #define	EOW	(BOL-5)
 == #define	BADCHAR	(BOL-6)
 == #define	NONCHAR(c)	((c) <= OUT)
 */
static states
step(struct re_guts *g,
	sopno start,		/* start state within strip */
	sopno stop,		/* state after stop state within strip */
	states bef,		/* states reachable before */
	wint_t ch,		/* character or NONCHAR code */
	states aft)		/* states already known reachable after */
{
	cset *cs;
	sop s;
	sopno pc;
	onestate here;		/* note, macros know this name */
	sopno look;
	int i;

	for (pc = start, INIT(here, pc); pc != stop; pc++, INC(here)) {
		s = g->strip[pc];
		switch (OP(s)) {
		case OEND:
			assert(pc == stop-1);
			break;
		case OCHAR:
			/* only characters can match */
			assert(!NONCHAR(ch) || ch != OPND(s));
			if (ch == OPND(s))
				FWD(aft, bef, 1);
			break;
		case OBOL:
			if (ch == BOL || ch == BOLEOL)
				FWD(aft, bef, 1);
			break;
		case OEOL:
			if (ch == EOL || ch == BOLEOL)
				FWD(aft, bef, 1);
			break;
		case OBOW:
			if (ch == BOW)
				FWD(aft, bef, 1);
			break;
		case OEOW:
			if (ch == EOW)
				FWD(aft, bef, 1);
			break;
		case OANY:
			if (!NONCHAR(ch))
				FWD(aft, bef, 1);
			break;
		case OANYOF:
			cs = &g->sets[OPND(s)];
			if (!NONCHAR(ch) && CHIN(cs, ch))
				FWD(aft, bef, 1);
			break;
		case OBACK_:		/* ignored here */
		case O_BACK:
			FWD(aft, aft, 1);
			break;
		case OPLUS_:		/* forward, this is just an empty */
			FWD(aft, aft, 1);
			break;
		case O_PLUS:		/* both forward and back */
			FWD(aft, aft, 1);
			i = ISSETBACK(aft, OPND(s));
			BACK(aft, aft, OPND(s));
			if (!i && ISSETBACK(aft, OPND(s))) {
				/* oho, must reconsider loop body */
				pc -= OPND(s) + 1;
				INIT(here, pc);
			}
			break;
		case OQUEST_:		/* two branches, both forward */
			FWD(aft, aft, 1);
			FWD(aft, aft, OPND(s));
			break;
		case O_QUEST:		/* just an empty */
			FWD(aft, aft, 1);
			break;
		case OLPAREN:		/* not significant here */
		case ORPAREN:
			FWD(aft, aft, 1);
			break;
		case OCH_:		/* mark the first two branches */
			FWD(aft, aft, 1);
			assert(OP(g->strip[pc+OPND(s)]) == OOR2);
			FWD(aft, aft, OPND(s));
			break;
		case OOR1:		/* done a branch, find the O_CH */
			if (ISSTATEIN(aft, here)) {
				for (look = 1;
						OP(s = g->strip[pc+look]) != O_CH;
						look += OPND(s))
					assert(OP(s) == OOR2);
				FWD(aft, aft, look + 1);
			}
			break;
		case OOR2:		/* propagate OCH_'s marking */
			FWD(aft, aft, 1);
			if (OP(g->strip[pc+OPND(s)]) != O_CH) {
				assert(OP(g->strip[pc+OPND(s)]) == OOR2);
				FWD(aft, aft, OPND(s));
			}
			break;
		case O_CH:		/* just empty */
			FWD(aft, aft, 1);
			break;
		default:		/* ooooops... */
			assert(nope);
			break;
		}
	}

	return(aft);
}
Пример #8
0
/*
 - p_simp_re - parse a simple RE, an atom possibly followed by a repetition
 == static int p_simp_re(struct parse *p, int starordinary, size_t reclimit);
 */
static int			/* was the simple RE an unbackslashed $? */
p_simp_re(
    struct parse *p,
    int starordinary,		/* is a leading * an ordinary character? */
    size_t reclimit)
{
	int c;
	int count;
	int count2;
	sopno pos, i;
	sopno subno;
#	define	BACKSL	(1<<CHAR_BIT)

	_DIAGASSERT(p != NULL);

	pos = HERE();		/* repetion op, if any, covers from here */

	assert(MORE());		/* caller should have ensured this */
	c = GETNEXT();
	if (c == '\\') {
		REQUIRE(MORE(), REG_EESCAPE);
		c = BACKSL | (unsigned char)GETNEXT();
	}
	switch (c) {
	case '.':
		if (p->g->cflags&REG_NEWLINE)
			nonnewline(p);
		else
			EMIT(OANY, 0);
		break;
	case '[':
		p_bracket(p);
		break;
	case BACKSL|'{':
		SETERROR(REG_BADRPT);
		break;
	case BACKSL|'(':
		p->g->nsub++;
		subno = p->g->nsub;
		if (subno < NPAREN)
			p->pbegin[subno] = HERE();
		EMIT(OLPAREN, subno);
		/* the MORE here is an error heuristic */
		if (MORE() && !SEETWO('\\', ')'))
			p_bre(p, '\\', ')', reclimit);
		if (subno < NPAREN) {
			p->pend[subno] = HERE();
			assert(p->pend[subno] != 0);
		}
		EMIT(ORPAREN, subno);
		REQUIRE(EATTWO('\\', ')'), REG_EPAREN);
		break;
	case BACKSL|')':	/* should not get here -- must be user */
	case BACKSL|'}':
		SETERROR(REG_EPAREN);
		break;
	case BACKSL|'1':
	case BACKSL|'2':
	case BACKSL|'3':
	case BACKSL|'4':
	case BACKSL|'5':
	case BACKSL|'6':
	case BACKSL|'7':
	case BACKSL|'8':
	case BACKSL|'9':
		i = (c&~BACKSL) - '0';
		assert(i < NPAREN);
		if (p->pend[i] != 0) {
			assert(i <= p->g->nsub);
			EMIT(OBACK_, i);
			assert(p->pbegin[i] != 0);
			assert(OP(p->strip[p->pbegin[i]]) == OLPAREN);
			assert(OP(p->strip[p->pend[i]]) == ORPAREN);
			(void) dupl(p, p->pbegin[i]+1, p->pend[i]);
			EMIT(O_BACK, i);
		} else
			SETERROR(REG_ESUBREG);
		p->g->backrefs = 1;
		break;
	case '*':
		REQUIRE(starordinary, REG_BADRPT);
		/* FALLTHROUGH */
	default:
		ordinary(p, c &~ BACKSL);
		break;
	}

	if (EAT('*')) {		/* implemented as +? */
		/* this case does not require the (y|) trick, noKLUDGE */
		INSERT(OPLUS_, pos);
		ASTERN(O_PLUS, pos);
		INSERT(OQUEST_, pos);
		ASTERN(O_QUEST, pos);
	} else if (EATTWO('\\', '{')) {
		count = p_count(p);
		if (EAT(',')) {
			if (MORE() && isdigit((unsigned char)PEEK())) {
				count2 = p_count(p);
				REQUIRE(count <= count2, REG_BADBR);
			} else		/* single number with comma */
				count2 = INFINITY;
		} else		/* just a single number */
			count2 = count;
		repeat(p, pos, count, count2, 0);
		if (!EATTWO('\\', '}')) {	/* error heuristics */
			while (MORE() && !SEETWO('\\', '}'))
				NEXT();
			REQUIRE(MORE(), REG_EBRACE);
			SETERROR(REG_BADBR);
		}
	} else if (c == (unsigned char)'$')	/* $ (but not \$) ends it */
		return(1);

	return(0);
}
Пример #9
0
int     CRegExp::regmatch(TCHAR *prog)
{
        TCHAR *scan;    // Current node. 
        TCHAR *next;            // Next node. 

        for (scan = prog; scan != NULL; scan = next) {
                next = regnext(scan);

                switch (OP(scan)) {
                case BOL:
                        if (reginput != regbol)
                                return(0);
                        break;
                case EOL:
                        if (*reginput != _T('\0'))
                                return(0);
                        break;
                case ANY:
                        if (*reginput == _T('\0'))
                                return(0);
                        reginput++;
                        break;
                case EXACTLY: {
                        size_t len;
                        TCHAR *const opnd = OPERAND(scan);

                        // Inline the first character, for speed. 
                        if (*opnd != *reginput)
                                return(0);
                        len = _tcslen(opnd);
                        if (len > 1 && _tcsncmp(opnd, reginput, len) != 0)
                                return(0);
                        reginput += len;
                        break;
                        }
                case ANYOF:
                        if (*reginput == _T('\0') ||
                                        _tcschr(OPERAND(scan), *reginput) == NULL)
                                return(0);
                        reginput++;
                        break;
                case ANYBUT:
                        if (*reginput == _T('\0') ||
                                        _tcschr(OPERAND(scan), *reginput) != NULL)
                                return(0);
                        reginput++;
                        break;
                case NOTHING:
                        break;
                case BACK:
                        break;
                case OPEN+1: case OPEN+2: case OPEN+3:
                case OPEN+4: case OPEN+5: case OPEN+6:
                case OPEN+7: case OPEN+8: case OPEN+9: {
                        const int no = OP(scan) - OPEN;
                        TCHAR *const input = reginput;

                        if (regmatch(next)) {
                                // Don't set startp if some later
                                // invocation of the same parentheses
                                // already has.
                                 
                                if (startp[no] == NULL)
                                        startp[no] = input;
                                return(1);
                        } else
                                return(0);
                        break;
                        }
                case CLOSE+1: case CLOSE+2: case CLOSE+3:
                case CLOSE+4: case CLOSE+5: case CLOSE+6:
                case CLOSE+7: case CLOSE+8: case CLOSE+9: {
                        const int no = OP(scan) - CLOSE;
                        TCHAR *const input = reginput;

                        if (regmatch(next)) {
                                // Don't set endp if some later
                                // invocation of the same parentheses
                                // already has.
                                 
                                if (endp[no] == NULL)
                                        endp[no] = input;
                                return(1);
                        } else
                                return(0);
                        break;
                        }
                case BRANCH: {
                        TCHAR *const save = reginput;

                        if (OP(next) != BRANCH)         // No choice. 
                                next = OPERAND(scan);   // Avoid recursion. 
                        else {
                                while (OP(scan) == BRANCH) {
                                        if (regmatch(OPERAND(scan)))
                                                return(1);
                                        reginput = save;
                                        scan = regnext(scan);
                                }
                                return(0);
                                // NOTREACHED 
                        }
                        break;
                        }
                case STAR: 
                case PLUS: {
                        const TCHAR nextch =
                                (OP(next) == EXACTLY) ? *OPERAND(next) : _T('\0');
                        size_t no;
                        TCHAR *const save = reginput;
                        const size_t min = (OP(scan) == STAR) ? 0 : 1;

                        for (no = regrepeat(OPERAND(scan)) + 1; no > min; no--) {
                                reginput = save + no - 1;
                                // If it could work, try it. 
                                if (nextch == _T('\0') || *reginput == nextch)
                                        if (regmatch(next))
                                                return(1);
                        }
                        return(0);
                        break;
                        }
                case END:
                        return(1);      // Success! 
                        break;
                default:
                        //TRACE0("regexp corruption\n");
						LastError = "regexp corruption";
                        return(0);
                        break;
                }
        }

        // We get here only if there's trouble -- normally "case END" is
        // the terminating point.
         
        //TRACE0("corrupted pointers\n");
		LastError = "corrupted pointers";
        return(0);
}
Пример #10
0
/*
 * s_print - print the strip for debugging
 */
static void
s_print(struct re_guts *g, FILE *d)
{
	sop *s;
	cset *cs;
	int done = 0;
	sop opnd;
	int col = 0;
	ssize_t last;
	sopno offset = 2;
#	define	GAP()	{	if (offset % 5 == 0) { \
					if (col > 40) { \
						fprintf(d, "\n\t"); \
						col = 0; \
					} else { \
						fprintf(d, " "); \
						col++; \
					} \
				} else \
					col++; \
				offset++; \
			}

	if (OP(g->strip[0]) != OEND)
		fprintf(d, "missing initial OEND!\n");
	for (s = &g->strip[1]; !done; s++) {
		opnd = OPND(*s);
		switch (OP(*s)) {
		case OEND:
			fprintf(d, "\n");
			done = 1;
			break;
		case OCHAR:
			if (strchr("\\|()^$.[+*?{}!<> ", (char)opnd) != NULL)
				fprintf(d, "\\%c", (char)opnd);
			else
				fprintf(d, "%s", regchar((char)opnd));
			break;
		case OBOL:
			fprintf(d, "^");
			break;
		case OEOL:
			fprintf(d, "$");
			break;
		case OBOW:
			fprintf(d, "\\{");
			break;
		case OEOW:
			fprintf(d, "\\}");
			break;
		case OANY:
			fprintf(d, ".");
			break;
		case OANYOF:
			fprintf(d, "[(%ld)", (long)opnd);
#ifdef __NetBSD__
			cs = &g->sets[opnd];
			last = -1;
			for (size_t i = 0; i < g->csetsize+1; i++)	/* +1 flushes */
				if (CHIN(cs, i) && i < g->csetsize) {
					if (last < 0) {
						fprintf(d, "%s", regchar(i));
						last = i;
					}
				} else {
					if (last >= 0) {
						if (last != (ssize_t)i - 1)
							fprintf(d, "-%s",
							    regchar(i - 1));
						last = -1;
					}
				}
#endif
			fprintf(d, "]");
			break;
		case OBACK_:
			fprintf(d, "(\\<%ld>", (long)opnd);
			break;
		case O_BACK:
			fprintf(d, "<%ld>\\)", (long)opnd);
			break;
		case OPLUS_:
			fprintf(d, "(+");
			if (OP(*(s+opnd)) != O_PLUS)
				fprintf(d, "<%ld>", (long)opnd);
			break;
		case O_PLUS:
			if (OP(*(s-opnd)) != OPLUS_)
				fprintf(d, "<%ld>", (long)opnd);
			fprintf(d, "+)");
			break;
		case OQUEST_:
			fprintf(d, "(?");
			if (OP(*(s+opnd)) != O_QUEST)
				fprintf(d, "<%ld>", (long)opnd);
			break;
		case O_QUEST:
			if (OP(*(s-opnd)) != OQUEST_)
				fprintf(d, "<%ld>", (long)opnd);
			fprintf(d, "?)");
			break;
		case OLPAREN:
			fprintf(d, "((<%ld>", (long)opnd);
			break;
		case ORPAREN:
			fprintf(d, "<%ld>))", (long)opnd);
			break;
		case OCH_:
			fprintf(d, "<");
			if (OP(*(s+opnd)) != OOR2)
				fprintf(d, "<%ld>", (long)opnd);
			break;
		case OOR1:
			if (OP(*(s-opnd)) != OOR1 && OP(*(s-opnd)) != OCH_)
				fprintf(d, "<%ld>", (long)opnd);
			fprintf(d, "|");
			break;
		case OOR2:
			fprintf(d, "|");
			if (OP(*(s+opnd)) != OOR2 && OP(*(s+opnd)) != O_CH)
				fprintf(d, "<%ld>", (long)opnd);
			break;
		case O_CH:
			if (OP(*(s-opnd)) != OOR1)
				fprintf(d, "<%ld>", (long)opnd);
			fprintf(d, ">");
			break;
		default:
#ifdef __FreeBSD__
			fprintf(d, "!%ld(%ld)!", OP(*s), opnd);
#else
			fprintf(d, "!%d(%d)!", OP(*s), opnd);
#endif
			break;
		}
		if (!done)
			GAP();
	}
}
Пример #11
0
#endif
#define MNEM CGEN_SYNTAX_MNEMONIC /* syntax value for mnemonic */
#define OP(field) CGEN_SYNTAX_MAKE_FIELD (OPERAND (field))

/* The instruction table.  */

static const CGEN_OPCODE openrisc_cgen_insn_opcode_table[MAX_INSNS] =
{
  /* Special null first entry.
     A `num' value of zero is thus invalid.
     Also, the special `invalid' insn resides here.  */
  { { 0, 0, 0, 0 }, {{0}}, 0, {0}},
/* l.j ${abs-26} */
  {
    { 0, 0, 0, 0 },
    { { MNEM, ' ', OP (ABS_26), 0 } },
    & ifmt_l_j, { 0x0 }
  },
/* l.jal ${abs-26} */
  {
    { 0, 0, 0, 0 },
    { { MNEM, ' ', OP (ABS_26), 0 } },
    & ifmt_l_j, { 0x4000000 }
  },
/* l.jr $rA */
  {
    { 0, 0, 0, 0 },
    { { MNEM, ' ', OP (RA), 0 } },
    & ifmt_l_jr, { 0x14000000 }
  },
/* l.jalr $rA */
Пример #12
0
OP OPCodes::getMOVConversion(string param1, string param2)
{
	int src = getRegisterNum(param1);
	int dest = getRegisterNum(param2);

	if (dest == -1) // store OPs
	{
		if (src == 0) { return OP("STA", 12, 3); }
		else if (src == 1) { return OP("STX", 16, 3); }
		else if (src == 2) { return OP("STL", 20, 3); }
		else if (src == 3) { return OP("STB", 120, 3); }
		else if (src == 4) { return OP("STS", 124, 3); }
		else if (src == 5) { return OP("STT", 132, 3); }
		else { return OP("ERROR",0,0); }
	}
	else // load OPs
	{
		if (dest == 0) { return OP("LDA", 0, 3); }
		else if (dest == 1) { return OP("LDX", 4, 3); }
		else if (dest == 2) { return OP("LDL", 8, 3); }
		else if (dest == 3) { return OP("LDB", 104, 3); }
		else if (dest == 4) { return OP("LDS", 108, 3); }
		else if (dest == 5) { return OP("LDT", 116, 3); }
		else { return OP("ERROR", 0, 0); }
	}
}
Пример #13
0
OP OPCodes::getOP(string oper)
{
	int sizeOffset = 0; // increases the size of certain operations
	if (oper[0] == '+')
	{
		oper = oper.substr(1, oper.length());
		sizeOffset = 1;
	}
	if (oper == "ADDR")			{ return OP(oper, 144, 2 + sizeOffset); }
	else if (oper == "COMPR")	{ return OP(oper, 160,2 + sizeOffset); }
	else if (oper == "SUBR")	{ return OP(oper, 148,2 + sizeOffset); }
	else if (oper == "ADD")		{ return OP(oper, 24,3 + sizeOffset); }
	else if (oper == "SUB")		{ return OP(oper, 28,3 + sizeOffset); }
	else if (oper == "MUL")		{ return OP(oper, 32,3 + sizeOffset); }
	else if (oper == "DIV")		{ return OP(oper, 36,3 + sizeOffset); }
	else if (oper == "COMP")	{ return OP(oper, 40,3 + sizeOffset); }
	else if (oper == "J")		{ return OP(oper, 60,3 + sizeOffset); }
	else if (oper == "JEQ")		{ return OP(oper, 48,3 + sizeOffset); }
	else if (oper == "JGT")		{ return OP(oper, 52,3 + sizeOffset); }
	else if (oper == "JLT")		{ return OP(oper, 56,3 + sizeOffset); }
	else if (oper == "JSUB")	{ return OP(oper, 72,3 + sizeOffset); }
	else if (oper == "LDCH")	{ return OP(oper, 80,3 + sizeOffset); }
	else if (oper == "RSUB")	{ return OP(oper, 76,3 + sizeOffset); }
	else if (oper == "TIX")		{ return OP(oper, 44,3 + sizeOffset); }
	else if (oper == "TIXR")	{ return OP(oper, 184,2 + sizeOffset); }
	else if (oper == "RD")		{ return OP(oper, 216,3 + sizeOffset); }
	else if (oper == "TD")		{ return OP(oper, 224,3 + sizeOffset); }
	else if (oper == "WD")		{ return OP(oper, 220,3 + sizeOffset); }
	else if (oper == "STCH")	{ return OP(oper, 84,3 + sizeOffset); }
	else if (oper == "CLEAR")	{ return OP(oper, 180,2 + sizeOffset); }
	else if (oper == "MOV")		{ return OP(oper, 0,3 + sizeOffset); }
	else return OP("ERROR",0,0);
}
Пример #14
0
static int          /* 0 failure, 1 success */
regmatch( char * prog )
{
    char * scan;  /* Current node. */
    char * next;  /* Next node. */

    scan = prog;
#ifdef DEBUG
    if (scan != NULL && regnarrate)
        err_printf("%s(\n", regprop(scan));
#endif
    while (scan != NULL) {
#ifdef DEBUG
        if (regnarrate)
            err_printf("%s...\n", regprop(scan));
#endif
        next = regnext(scan);

        switch (OP(scan)) {
        case BOL:
            if (reginput != regbol)
                return(0);
            break;
        case EOL:
            if (*reginput != '\0')
                return(0);
            break;
        case WORDA:
            /* Must be looking at a letter, digit, or _ */
            if ((!isalnum(*reginput)) && *reginput != '_')
                return(0);
            /* Prev must be BOL or nonword */
            if (reginput > regbol &&
                (isalnum(reginput[-1]) || reginput[-1] == '_'))
                return(0);
            break;
        case WORDZ:
            /* Must be looking at non letter, digit, or _ */
            if (isalnum(*reginput) || *reginput == '_')
                return(0);
            /* We don't care what the previous char was */
            break;
        case ANY:
            if (*reginput == '\0')
                return(0);
            reginput++;
            break;
        case EXACTLY: {
                register int len;
                register char *opnd;

                opnd = OPERAND(scan);
                /* Inline the first character, for speed. */
                if (*opnd != *reginput)
                    return(0);
                len = strlen(opnd);
                if (len > 1 && strncmp(opnd, reginput, len) != 0)
                    return(0);
                reginput += len;
            }
            break;
        case ANYOF:
            if (*reginput == '\0' || strchr(OPERAND(scan), *reginput) == NULL)
                return(0);
            reginput++;
            break;
        case ANYBUT:
            if (*reginput == '\0' || strchr(OPERAND(scan), *reginput) != NULL)
                return(0);
            reginput++;
            break;
        case NOTHING:
            break;
        case BACK:
            break;
        case OPEN+1:
        case OPEN+2:
        case OPEN+3:
        case OPEN+4:
        case OPEN+5:
        case OPEN+6:
        case OPEN+7:
        case OPEN+8:
        case OPEN+9: {
                register int no;
                register const char *save;

                no = OP(scan) - OPEN;
                save = reginput;

                if (regmatch(next)) {
                    /*
                     * Don't set startp if some later
                     * invocation of the same parentheses
                     * already has.
                     */
                    if (regstartp[no] == NULL)
                        regstartp[no] = save;
                    return(1);
                } else
                    return(0);
            }
            break;
        case CLOSE+1:
        case CLOSE+2:
        case CLOSE+3:
        case CLOSE+4:
        case CLOSE+5:
        case CLOSE+6:
        case CLOSE+7:
        case CLOSE+8:
        case CLOSE+9: {
                register int no;
                register const char *save;

                no = OP(scan) - CLOSE;
                save = reginput;

                if (regmatch(next)) {
                    /*
                     * Don't set endp if some later
                     * invocation of the same parentheses
                     * already has.
                     */
                    if (regendp[no] == NULL)
                        regendp[no] = save;
                    return(1);
                } else
                    return(0);
            }
            break;
        case BRANCH: {
                register const char *save;

                if (OP(next) != BRANCH)     /* No choice. */
                    next = OPERAND(scan);   /* Avoid recursion. */
                else {
                    do {
                        save = reginput;
                        if (regmatch(OPERAND(scan)))
                            return(1);
                        reginput = save;
                        scan = regnext(scan);
                    } while (scan != NULL && OP(scan) == BRANCH);
                    return(0);
                    /* NOTREACHED */
                }
            }
            break;
        case STAR:
        case PLUS: {
                register char nextch;
                register int no;
                register const char *save;
                register int min;

                /*
                 * Lookahead to avoid useless match attempts
                 * when we know what character comes next.
                 */
                nextch = '\0';
                if (OP(next) == EXACTLY)
                    nextch = *OPERAND(next);
                min = (OP(scan) == STAR) ? 0 : 1;
                save = reginput;
                no = regrepeat(OPERAND(scan));
                while (no >= min) {
                    /* If it could work, try it. */
                    if (nextch == '\0' || *reginput == nextch)
                        if (regmatch(next))
                            return(1);
                    /* Couldn't or didn't -- back up. */
                    no--;
                    reginput = save + no;
                }
                return(0);
            }
            break;
        case END:
            return(1);  /* Success! */
            break;
        default:
            regerror("memory corruption");
            return(0);
            break;
        }

        scan = next;
    }

    /*
     * We get here only if there's trouble -- normally "case END" is
     * the terminating point.
     */
    regerror("corrupted pointers");
    return(0);
}
Token scan(FILE* fp) {
  // The character we are reading in:
  static char c;

  // Indicates if this is the first call to scan:
  static int first_time = 1;

  // If this is the first call
  if (first_time) {
    c = getc(fp);
    first_time = 0;
  }

  // We begin in the start state:
  static state curr_state = START_STATE;

  // The token to return to the caller:
  Token token;

  // An index used to remember the value characters:
  int value_idx = -1;

  // Run the machine:
  while (1) {
    switch (curr_state) {
    case START_STATE:
      if (c == TAB || c == WS || c == NL) {
    	curr_state = START_STATE;
	c = getc(fp);
      }
      else if (OP(c)) {
    	curr_state = OP_STATE;
      }
      else if (c == SEMI) {
    	curr_state = SEMI_STATE;
      }
      else if (c == EOF) {
	curr_state = EOF_STATE;
      }
      else if (isdigit(c)){
    	curr_state = INT_STATE;
      }
      else {
        token.value[++value_idx] = c;
	token.value[++value_idx] = '\0';
        token.t = TOK_ERROR;
	return token;
      }
      break;

    case INT_STATE:
      if (c == SEMI) {
        token.value[++value_idx] = '\0';
	token.t = TOK_INT;
	curr_state = SEMI_STATE;
	return token;
      }
      else if (OP(c)) {
        token.value[++value_idx] = '\0';
	curr_state = OP_STATE;
	token.t = TOK_INT;
	return token;
      }
      else if (c == TAB || c == WS || c == NL) {
        token.value[++value_idx] = '\0';
	curr_state = START_STATE;
	token.t = TOK_INT;
	c = getc(fp);
	return token;
      }
      else if (c >= '0' && c <= '9'){
        token.value[++value_idx] = c;
	curr_state = INT_STATE;
	c = getc(fp);
      }
      else {
        token.value[++value_idx] = c;
	token.value[++value_idx] = '\0';
        token.t = TOK_ERROR;
	return token;
      }
      break;

    case SEMI_STATE:
      token.value[++value_idx] = ';';
	token.value[++value_idx] = '\0';
      token.t = TOK_SEMI;
      c = getc(fp);
      curr_state = START_STATE;
      return token;
      break;

    case OP_STATE:
      if (OP(c)) {
    	token.value[++value_idx] = c;
	token.value[++value_idx] = '\0';
    	curr_state = START_STATE;
	token.t = whatOP(token.value[value_idx - 1]);
	c = getc(fp);
	return token;
      }
      else if (c == SEMI) {
    	curr_state = SEMI_STATE;
      }
      else if (c == TAB || c == WS || c == NL) {
	curr_state = START_STATE;
      }
      else if (c == EOF) {
	curr_state = EOF_STATE;
      }
      else if (isdigit(c)){ // value character
	curr_state = INT_STATE;
      }
      else {
        token.value[++value_idx] = c;
	token.value[++value_idx] = '\0';
        token.t = TOK_ERROR;
	return token;
      }
      break;

    case EOF_STATE:
      sprintf(token.value, "end of file");
      token.t = TOK_ENDOFFILE;
      curr_state = EOF_STATE;
      return token;

    default:
      token.t = TOK_ERROR;
      sprintf(token.value, "unexpected input character: %c", c);
      return token;
    }
  }
}
Пример #16
0
CRegExp* CRegExp::RegComp(const TCHAR *exp)
{
        TCHAR *scan;
        int flags;

        if (exp == NULL)
                return NULL;
        
        bCompiled = TRUE;

        // First pass: determine size, legality. 
        bEmitCode = FALSE;
        regparse = (TCHAR *)exp;
        regnpar = 1;
        regsize = 0L;
        regdummy[0] = NOTHING;
        regdummy[1] = regdummy[2] = 0;
        regcode = regdummy;
        if (reg(0, &flags) == NULL)
                return(NULL);

        // Allocate space. 
        delete program;
        program = new TCHAR[regsize];
        memset( program, 0, regsize * sizeof(TCHAR) );

        if (program == NULL)
                return NULL;

        // Second pass: emit code. 
        bEmitCode = TRUE;
        regparse = (TCHAR *)exp;
        regnpar = 1;
        regcode = program;
        if (reg(0, &flags) == NULL)
                return NULL;

        // Dig out information for optimizations. 
        regstart = _T('\0');            // Worst-case defaults. 
        reganch = 0;
        regmust = NULL;
        regmlen = 0;
        scan = program;         // First BRANCH. 
        if (OP(regnext(scan)) == END) 
        {       
                // Only one top-level choice. 
                scan = OPERAND(scan);

                // Starting-point info. 
                if (OP(scan) == EXACTLY)
                        regstart = *OPERAND(scan);
                else if (OP(scan) == BOL)
                        reganch = 1;

                // If there's something expensive in the r.e., find the
                // longest literal string that must appear and make it the
                // regmust.  Resolve ties in favor of later strings, since
                // the regstart check works with the beginning of the r.e.
                // and avoiding duplication strengthens checking.  Not a
                // strong reason, but sufficient in the absence of others.
                 
                if (flags&SPSTART) 
                {
                        char *longest = NULL;
                        size_t len = 0;

                        for (; scan != NULL; scan = regnext(scan))
                                if (OP(scan) == EXACTLY && _tcslen(OPERAND(scan)) >= (unsigned int) len) 
                                {
                                        longest = OPERAND(scan);
                                        len = _tcslen(OPERAND(scan));
                                }
                        regmust = longest;
                        regmlen = (int)len;
                }
        }

        return this;
}
Пример #17
0
#define MNEM CGEN_SYNTAX_MNEMONIC /* syntax value for mnemonic */
#define OPERAND(op) NIOS_OPERAND_##op
#define OP(field) CGEN_SYNTAX_MAKE_FIELD (OPERAND (field))

/* The instruction table.  */

static const CGEN_OPCODE nios_cgen_insn_opcode_table[MAX_INSNS] =
{
  /* Special null first entry.
     A `num' value of zero is thus invalid.
     Also, the special `invalid' insn resides here.  */
  { { 0 } },
/* ext8s $m16_Ra,$i1 */
  {
    { 0, 0, 0, 0 },
    { { MNEM, ' ', OP (M16_RA), ',', OP (I1), 0 } },
    & ifmt_ext8s16, { 0x7400 }
  },
/* st8s [$m16_Ra],$m16_R0,$i1 */
  {
    { 0, 0, 0, 0 },
    { { MNEM, ' ', '[', OP (M16_RA), ']', ',', OP (M16_R0), ',', OP (I1), 0 } },
    & ifmt_ext8s16, { 0x7600 }
  },
/* sts8s [$m16_sp,$i10],$m16_R0 */
  {
    { 0, 0, 0, 0 },
    { { MNEM, ' ', '[', OP (M16_SP), ',', OP (I10), ']', ',', OP (M16_R0), 0 } },
    & ifmt_sts8s16, { 0x6000 }
  },
/* st8d [$m16_Ra],$m16_R0 */
Пример #18
0
/*
 - regcomp - compile a regular expression into internal code
 *
 * We can't allocate space until we know how big the compiled form will be,
 * but we can't compile it (and thus know how big it is) until we've got a
 * place to put the code.  So we cheat:  we compile it twice, once with code
 * generation turned off and size counting turned on, and once "for real".
 * This also means that we don't allocate space until we are sure that the
 * thing really will compile successfully, and we never have to move the
 * code and thus invalidate pointers into it.  (Note that it has to be in
 * one piece because free() must be able to free it all.)
 *
 * Beware that the optimization-preparation code in here knows about some
 * of the structure of the compiled regexp.
 */
regexp *
regcomp(char *exp,int *patternsize)
{
	register regexp *r;
	register char *scan;
	register char *longest;
	register int len;
	int flags;
	/* commented out by ethan
	   extern char *malloc();
	*/

	if (exp == NULL)
		FAIL("NULL argument");

	/* First pass: determine size, legality. */
	regparse = exp;
	regnpar = 1;
	regsize = 0L;
	regcode = &regdummy;
	regc(MAGIC);
	if (reg(0, &flags) == NULL)
		return(NULL);

	/* Small enough for pointer-storage convention? */
	if (regsize >= 32767L)		/* Probably could be 65535L. */
		FAIL("regexp too big");

	/* Allocate space. */
	*patternsize=sizeof(regexp) + (unsigned)regsize;
	r = (regexp *)malloc(sizeof(regexp) + (unsigned)regsize);
	if (r == NULL)
		FAIL("out of space");

	/* Second pass: emit code. */
	regparse = exp;
	regnpar = 1;
	regcode = r->program;
	regc(MAGIC);
	if (reg(0, &flags) == NULL)
		return(NULL);

	/* Dig out information for optimizations. */
	r->regstart = '\0';	/* Worst-case defaults. */
	r->reganch = 0;
	r->regmust = NULL;
	r->regmlen = 0;
	scan = r->program+1;			/* First BRANCH. */
	if (OP(regnext(scan)) == END) {		/* Only one top-level choice. */
		scan = OPERAND(scan);

		/* Starting-point info. */
		if (OP(scan) == EXACTLY)
			r->regstart = *OPERAND(scan);
		else if (OP(scan) == BOL)
			r->reganch++;

		/*
		 * If there's something expensive in the r.e., find the
		 * longest literal string that must appear and make it the
		 * regmust.  Resolve ties in favor of later strings, since
		 * the regstart check works with the beginning of the r.e.
		 * and avoiding duplication strengthens checking.  Not a
		 * strong reason, but sufficient in the absence of others.
		 */
		if (flags&SPSTART) {
			longest = NULL;
			len = 0;
			for (; scan != NULL; scan = regnext(scan))
				if (OP(scan) == EXACTLY && strlen(OPERAND(scan)) >= len) {
					longest = OPERAND(scan);
					len = strlen(OPERAND(scan));
				}
			r->regmust = longest;
			r->regmlen = len;
		}
	}

	return(r);
}
Пример #19
0
/*
 - backref - figure out what matched what, figuring in back references
 == static const char *backref(struct match *m, const char *start, \
 ==	const char *stop, sopno startst, sopno stopst, sopno lev);
 */
static const char *		/* == stop (success) or NULL (failure) */
backref(struct match *m,
	const char *start,
	const char *stop,
	sopno startst,
	sopno stopst,
	sopno lev,		/* PLUS nesting level */
	int rec)
{
	int i;
	sopno ss;		/* start sop of current subRE */
	const char *sp;		/* start of string matched by it */
	sopno ssub;		/* start sop of subsubRE */
	sopno esub;		/* end sop of subsubRE */
	const char *ssp;	/* start of string matched by subsubRE */
	const char *dp;
	size_t len;
	int hard;
	sop s;
	regoff_t offsave;
	cset *cs;
	wint_t wc;

	AT("back", start, stop, startst, stopst);
	sp = start;

	/* get as far as we can with easy stuff */
	hard = 0;
	for (ss = startst; !hard && ss < stopst; ss++)
		switch (OP(s = m->g->strip[ss])) {
		case OCHAR:
			if (sp == stop)
				return(NULL);
			sp += XMBRTOWC(&wc, sp, stop - sp, &m->mbs, BADCHAR);
			if (wc != OPND(s))
				return(NULL);
			break;
		case OANY:
			if (sp == stop)
				return(NULL);
			sp += XMBRTOWC(&wc, sp, stop - sp, &m->mbs, BADCHAR);
			if (wc == BADCHAR)
				return (NULL);
			break;
		case OANYOF:
			if (sp == stop)
				return (NULL);
			cs = &m->g->sets[OPND(s)];
			sp += XMBRTOWC(&wc, sp, stop - sp, &m->mbs, BADCHAR);
			if (wc == BADCHAR || !CHIN(cs, wc))
				return(NULL);
			break;
		case OBOL:
			if ((sp == m->beginp && !(m->eflags&REG_NOTBOL)) ||
			    (sp > m->offp && sp < m->endp &&
			    *(sp-1) == '\n' && (m->g->cflags&REG_NEWLINE)))
				{ /* yes */ }
			else
				return(NULL);
			break;
		case OEOL:
			if ( (sp == m->endp && !(m->eflags&REG_NOTEOL)) ||
					(sp < m->endp && *sp == '\n' &&
						(m->g->cflags&REG_NEWLINE)) )
				{ /* yes */ }
			else
				return(NULL);
			break;
		case OBOW:
			if (sp < m->endp && ISWORD(*sp) &&
			    ((sp == m->beginp && !(m->eflags&REG_NOTBOL)) ||
			    (sp > m->offp && !ISWORD(*(sp-1)))))
				{ /* yes */ }
			else
				return(NULL);
			break;
		case OEOW:
			if (( (sp == m->endp && !(m->eflags&REG_NOTEOL)) ||
					(sp < m->endp && *sp == '\n' &&
						(m->g->cflags&REG_NEWLINE)) ||
					(sp < m->endp && !ISWORD(*sp)) ) &&
					(sp > m->beginp && ISWORD(*(sp-1))) )
				{ /* yes */ }
			else
				return(NULL);
			break;
		case O_QUEST:
			break;
		case OOR1:	/* matches null but needs to skip */
			ss++;
			s = m->g->strip[ss];
			do {
				assert(OP(s) == OOR2);
				ss += OPND(s);
			} while (OP(s = m->g->strip[ss]) != O_CH);
			/* note that the ss++ gets us past the O_CH */
			break;
		default:	/* have to make a choice */
			hard = 1;
			break;
		}
	if (!hard) {		/* that was it! */
		if (sp != stop)
			return(NULL);
		return(sp);
	}
	ss--;			/* adjust for the for's final increment */

	/* the hard stuff */
	AT("hard", sp, stop, ss, stopst);
	s = m->g->strip[ss];
	switch (OP(s)) {
	case OBACK_:		/* the vilest depths */
		i = OPND(s);
		assert(0 < i && i <= m->g->nsub);
		if (m->pmatch[i].rm_eo == -1)
			return(NULL);
		assert(m->pmatch[i].rm_so != -1);
		len = m->pmatch[i].rm_eo - m->pmatch[i].rm_so;
		if (len == 0 && rec++ > MAX_RECURSION)
			return(NULL);
		assert(stop - m->beginp >= len);
		if (sp > stop - len)
			return(NULL);	/* not enough left to match */
		ssp = m->offp + m->pmatch[i].rm_so;
		if (memcmp(sp, ssp, len) != 0)
			return(NULL);
		while (m->g->strip[ss] != SOP(O_BACK, i))
			ss++;
		return(backref(m, sp+len, stop, ss+1, stopst, lev, rec));
	case OQUEST_:		/* to null or not */
		dp = backref(m, sp, stop, ss+1, stopst, lev, rec);
		if (dp != NULL)
			return(dp);	/* not */
		return(backref(m, sp, stop, ss+OPND(s)+1, stopst, lev, rec));
	case OPLUS_:
		assert(m->lastpos != NULL);
		assert(lev+1 <= m->g->nplus);
		m->lastpos[lev+1] = sp;
		return(backref(m, sp, stop, ss+1, stopst, lev+1, rec));
	case O_PLUS:
		if (sp == m->lastpos[lev])	/* last pass matched null */
			return(backref(m, sp, stop, ss+1, stopst, lev-1, rec));
		/* try another pass */
		m->lastpos[lev] = sp;
		dp = backref(m, sp, stop, ss-OPND(s)+1, stopst, lev, rec);
		if (dp == NULL)
			return(backref(m, sp, stop, ss+1, stopst, lev-1, rec));
		else
			return(dp);
	case OCH_:		/* find the right one, if any */
		ssub = ss + 1;
		esub = ss + OPND(s) - 1;
		assert(OP(m->g->strip[esub]) == OOR1);
		for (;;) {	/* find first matching branch */
			dp = backref(m, sp, stop, ssub, esub, lev, rec);
			if (dp != NULL)
				return(dp);
			/* that one missed, try next one */
			if (OP(m->g->strip[esub]) == O_CH)
				return(NULL);	/* there is none */
			esub++;
			assert(OP(m->g->strip[esub]) == OOR2);
			ssub = esub + 1;
			esub += OPND(m->g->strip[esub]);
			if (OP(m->g->strip[esub]) == OOR2)
				esub--;
			else
				assert(OP(m->g->strip[esub]) == O_CH);
		}
		/* NOTREACHED */
		break;
	case OLPAREN:		/* must undo assignment if rest fails */
		i = OPND(s);
		assert(0 < i && i <= m->g->nsub);
		offsave = m->pmatch[i].rm_so;
		m->pmatch[i].rm_so = sp - m->offp;
		dp = backref(m, sp, stop, ss+1, stopst, lev, rec);
		if (dp != NULL)
			return(dp);
		m->pmatch[i].rm_so = offsave;
		return(NULL);
	case ORPAREN:		/* must undo assignment if rest fails */
		i = OPND(s);
		assert(0 < i && i <= m->g->nsub);
		offsave = m->pmatch[i].rm_eo;
		m->pmatch[i].rm_eo = sp - m->offp;
		dp = backref(m, sp, stop, ss+1, stopst, lev, rec);
		if (dp != NULL)
			return(dp);
		m->pmatch[i].rm_eo = offsave;
		return(NULL);
	default:		/* uh oh */
		assert(nope);
		break;
	}

	/* "can't happen" */
	assert(nope);
	/* NOTREACHED */
	return "shut up gcc";
}
Пример #20
0
static int fx_init(struct emu10k1_card *card)
{
	struct patch_manager *mgr = &card->mgr;
	struct dsp_patch *patch;
	struct dsp_rpatch *rpatch;
	s32 left, right;
	int i;
	u32 pc = 0;
	u32 patch_n;

	for (i = 0; i < SOUND_MIXER_NRDEVICES; i++) {
		mgr->ctrl_gpr[i][0] = -1;
		mgr->ctrl_gpr[i][1] = -1;
	}

	for (i = 0; i < 512; i++)
		OP(6, 0x40, 0x40, 0x40, 0x40);

	for (i = 0; i < 256; i++)
		sblive_writeptr_tag(card, 0,
				    FXGPREGBASE + i, 0,
				    TANKMEMADDRREGBASE + i, 0,
				    TAGLIST_END);

	/* !! The number bellow must equal the number of patches, currently 11 !! */
	mgr->current_pages = (11 + PATCHES_PER_PAGE - 1) / PATCHES_PER_PAGE;
	for (i = 0; i < mgr->current_pages; i++) {
	        mgr->patch[i] = (void *)__get_free_page(GFP_KERNEL);
		if (mgr->patch[i] == NULL) {
			mgr->current_pages = i;
			fx_cleanup(mgr);
			return -ENOMEM;
		}
		memset(mgr->patch[i], 0, PAGE_SIZE);
	}

	pc = 0;
	patch_n = 0;
	//first free GPR = 0x11b

	/* FX volume correction and Volume control*/
	INPUT_PATCH_START(patch, "Pcm L vol", 0x0, 0);
	GET_OUTPUT_GPR(patch, 0x100, 0x0);
	GET_CONTROL_GPR(patch, 0x106, "Vol", 0, 0x7fffffff);
	GET_DYNAMIC_GPR(patch, 0x112);

	OP(4, 0x112, 0x40, PCM_IN_L, 0x44); //*4
	OP(0, 0x100, 0x040, 0x112, 0x106);  //*vol
	INPUT_PATCH_END(patch);


	INPUT_PATCH_START(patch, "Pcm R vol", 0x1, 0);
	GET_OUTPUT_GPR(patch, 0x101, 0x1);
	GET_CONTROL_GPR(patch, 0x107, "Vol", 0, 0x7fffffff);
	GET_DYNAMIC_GPR(patch, 0x112);

	OP(4, 0x112, 0x40, PCM_IN_R, 0x44); 
	OP(0, 0x101, 0x040, 0x112, 0x107);

	INPUT_PATCH_END(patch);


	// CD-Digital In Volume control
	INPUT_PATCH_START(patch, "CD-Digital Vol L", 0x12, 0);
	GET_OUTPUT_GPR(patch, 0x10c, 0x12);
	GET_CONTROL_GPR(patch, 0x10d, "Vol", 0, 0x7fffffff);

	OP(0, 0x10c, 0x040, SPDIF_CD_L, 0x10d);
	INPUT_PATCH_END(patch);

	INPUT_PATCH_START(patch, "CD-Digital Vol R", 0x13, 0);
	GET_OUTPUT_GPR(patch, 0x10e, 0x13);
	GET_CONTROL_GPR(patch, 0x10f, "Vol", 0, 0x7fffffff);

	OP(0, 0x10e, 0x040, SPDIF_CD_R, 0x10f);
	INPUT_PATCH_END(patch);

	//Volume Correction for Multi-channel Inputs
	INPUT_PATCH_START(patch, "Multi-Channel Gain", 0x08, 0);
	patch->input=patch->output=0x3F00;

	GET_OUTPUT_GPR(patch, 0x113, MULTI_FRONT_L);
	GET_OUTPUT_GPR(patch, 0x114, MULTI_FRONT_R);
	GET_OUTPUT_GPR(patch, 0x115, MULTI_REAR_L);
	GET_OUTPUT_GPR(patch, 0x116, MULTI_REAR_R);
	GET_OUTPUT_GPR(patch, 0x117, MULTI_CENTER);
	GET_OUTPUT_GPR(patch, 0x118, MULTI_LFE);

	OP(4, 0x113, 0x40, MULTI_FRONT_L, 0x44);
	OP(4, 0x114, 0x40, MULTI_FRONT_R, 0x44);
	OP(4, 0x115, 0x40, MULTI_REAR_L, 0x44);
	OP(4, 0x116, 0x40, MULTI_REAR_R, 0x44);
	OP(4, 0x117, 0x40, MULTI_CENTER, 0x44);
	OP(4, 0x118, 0x40, MULTI_LFE, 0x44);
	
	INPUT_PATCH_END(patch);


	//Routing patch start
	ROUTING_PATCH_START(rpatch, "Routing");
	GET_INPUT_GPR(rpatch, 0x100, 0x0);
	GET_INPUT_GPR(rpatch, 0x101, 0x1);
	GET_INPUT_GPR(rpatch, 0x10c, 0x12);
	GET_INPUT_GPR(rpatch, 0x10e, 0x13);
	GET_INPUT_GPR(rpatch, 0x113, MULTI_FRONT_L);
	GET_INPUT_GPR(rpatch, 0x114, MULTI_FRONT_R);
	GET_INPUT_GPR(rpatch, 0x115, MULTI_REAR_L);
	GET_INPUT_GPR(rpatch, 0x116, MULTI_REAR_R);
	GET_INPUT_GPR(rpatch, 0x117, MULTI_CENTER);
	GET_INPUT_GPR(rpatch, 0x118, MULTI_LFE);

	GET_DYNAMIC_GPR(rpatch, 0x102);
	GET_DYNAMIC_GPR(rpatch, 0x103);

	GET_OUTPUT_GPR(rpatch, 0x104, 0x8);
	GET_OUTPUT_GPR(rpatch, 0x105, 0x9);
	GET_OUTPUT_GPR(rpatch, 0x10a, 0x2);
	GET_OUTPUT_GPR(rpatch, 0x10b, 0x3);


	/* input buffer */
	OP(6, 0x102, AC97_IN_L, 0x40, 0x40);
	OP(6, 0x103, AC97_IN_R, 0x40, 0x40);


	/* Digital In + PCM + MULTI_FRONT-> AC97 out (front speakers)*/
	OP(6, AC97_FRONT_L, 0x100, 0x10c, 0x113);

	CONNECT(MULTI_FRONT_L, AC97_FRONT_L);
	CONNECT(PCM_IN_L, AC97_FRONT_L);
	CONNECT(SPDIF_CD_L, AC97_FRONT_L);

	OP(6, AC97_FRONT_R, 0x101, 0x10e, 0x114);

	CONNECT(MULTI_FRONT_R, AC97_FRONT_R);
	CONNECT(PCM_IN_R, AC97_FRONT_R);
	CONNECT(SPDIF_CD_R, AC97_FRONT_R);

	/* Digital In + PCM + AC97 In + PCM1 + MULTI_REAR --> Rear Channel */ 
	OP(6, 0x104, PCM1_IN_L, 0x100, 0x115);
	OP(6, 0x104, 0x104, 0x10c, 0x102);

	CONNECT(MULTI_REAR_L, ANALOG_REAR_L);
	CONNECT(AC97_IN_L, ANALOG_REAR_L);
	CONNECT(PCM_IN_L, ANALOG_REAR_L);
	CONNECT(SPDIF_CD_L, ANALOG_REAR_L);
	CONNECT(PCM1_IN_L, ANALOG_REAR_L);

	OP(6, 0x105, PCM1_IN_R, 0x101, 0x116);
	OP(6, 0x105, 0x105, 0x10e, 0x103);

	CONNECT(MULTI_REAR_R, ANALOG_REAR_R);
	CONNECT(AC97_IN_R, ANALOG_REAR_R);
	CONNECT(PCM_IN_R, ANALOG_REAR_R);
	CONNECT(SPDIF_CD_R, ANALOG_REAR_R);
	CONNECT(PCM1_IN_R, ANALOG_REAR_R);

	/* Digital In + PCM + AC97 In + MULTI_FRONT --> Digital out */
	OP(6, 0x10a, 0x100, 0x102, 0x10c);
	OP(6, 0x10a, 0x10a, 0x113, 0x40);

	CONNECT(MULTI_FRONT_L, DIGITAL_OUT_L);
	CONNECT(PCM_IN_L, DIGITAL_OUT_L);
	CONNECT(AC97_IN_L, DIGITAL_OUT_L);
	CONNECT(SPDIF_CD_L, DIGITAL_OUT_L);

	OP(6, 0x10b, 0x101, 0x103, 0x10e);
	OP(6, 0x10b, 0x10b, 0x114, 0x40);

	CONNECT(MULTI_FRONT_R, DIGITAL_OUT_R);
	CONNECT(PCM_IN_R, DIGITAL_OUT_R);
	CONNECT(AC97_IN_R, DIGITAL_OUT_R);
	CONNECT(SPDIF_CD_R, DIGITAL_OUT_R);

	/* AC97 In --> ADC Recording Buffer */
	OP(6, ADC_REC_L, 0x102, 0x40, 0x40);

	CONNECT(AC97_IN_L, ADC_REC_L);

	OP(6, ADC_REC_R, 0x103, 0x40, 0x40);

	CONNECT(AC97_IN_R, ADC_REC_R);


	/* fx12:Analog-Center */
	OP(6, ANALOG_CENTER, 0x117, 0x40, 0x40);
	CONNECT(MULTI_CENTER, ANALOG_CENTER);

	/* fx11:Analog-LFE */
	OP(6, ANALOG_LFE, 0x118, 0x40, 0x40);
	CONNECT(MULTI_LFE, ANALOG_LFE);

	/* fx12:Digital-Center */
	OP(6, DIGITAL_CENTER, 0x117, 0x40, 0x40);
	CONNECT(MULTI_CENTER, DIGITAL_CENTER);

	/* fx11:Analog-LFE */
	OP(6, DIGITAL_LFE, 0x118, 0x40, 0x40);
	CONNECT(MULTI_LFE, DIGITAL_LFE);
	
	ROUTING_PATCH_END(rpatch);


	// Rear volume control
	OUTPUT_PATCH_START(patch, "Vol Rear L", 0x8, 0);
	GET_INPUT_GPR(patch, 0x104, 0x8);
	GET_CONTROL_GPR(patch, 0x119, "Vol", 0, 0x7fffffff);

	OP(0, ANALOG_REAR_L, 0x040, 0x104, 0x119);
	OUTPUT_PATCH_END(patch);


	OUTPUT_PATCH_START(patch, "Vol Rear R", 0x9, 0);
	GET_INPUT_GPR(patch, 0x105, 0x9);
	GET_CONTROL_GPR(patch, 0x11a, "Vol", 0, 0x7fffffff);

	OP(0, ANALOG_REAR_R, 0x040, 0x105, 0x11a);
	OUTPUT_PATCH_END(patch);


	//Master volume control on front-digital
	OUTPUT_PATCH_START(patch, "Vol Master L", 0x2, 1);
	GET_INPUT_GPR(patch, 0x10a, 0x2);
	GET_CONTROL_GPR(patch, 0x108, "Vol", 0, 0x7fffffff);

	OP(0, DIGITAL_OUT_L, 0x040, 0x10a, 0x108);
	OUTPUT_PATCH_END(patch);


	OUTPUT_PATCH_START(patch, "Vol Master R", 0x3, 1);
	GET_INPUT_GPR(patch, 0x10b, 0x3);
	GET_CONTROL_GPR(patch, 0x109, "Vol", 0, 0x7fffffff);

	OP(0, DIGITAL_OUT_R, 0x040, 0x10b, 0x109);
	OUTPUT_PATCH_END(patch);


	/* delimiter patch */
	patch = PATCH(mgr, patch_n);
	patch->code_size = 0;

	sblive_writeptr(card, DBG, 0, 0);

//	mgr->lock = SPIN_LOCK_UNLOCKED;


	//Master volume
	mgr->ctrl_gpr[SOUND_MIXER_VOLUME][0] = 8;
	mgr->ctrl_gpr[SOUND_MIXER_VOLUME][1] = 9;

//	left = card->ac97.mixer_state[SOUND_MIXER_VOLUME] & 0xff;
//	right = (card->ac97.mixer_state[SOUND_MIXER_VOLUME] >> 8) & 0xff;

//	left = right = 0x43;
	left = right = 100;
	
	emu10k1_set_volume_gpr(card, 8, left, 1 << 5);
	emu10k1_set_volume_gpr(card, 9, right, 1 << 5);

	//Rear volume
	mgr->ctrl_gpr[ SOUND_MIXER_OGAIN ][0] = 0x19;
	mgr->ctrl_gpr[ SOUND_MIXER_OGAIN ][1] = 0x1a;

//	card->ac97.mixer_state[SOUND_MIXER_OGAIN] = (right << 8) | left;

//	card->ac97.supported_mixers |= SOUND_MASK_OGAIN;
//	card->ac97.stereo_mixers |= SOUND_MASK_OGAIN;

	emu10k1_set_volume_gpr(card, 0x19, left, VOL_5BIT);
	emu10k1_set_volume_gpr(card, 0x1a, right, VOL_5BIT);

	//PCM Volume
	mgr->ctrl_gpr[SOUND_MIXER_PCM][0] = 6;
	mgr->ctrl_gpr[SOUND_MIXER_PCM][1] = 7;

//	left = card->ac97.mixer_state[SOUND_MIXER_PCM] & 0xff;
//	right = (card->ac97.mixer_state[SOUND_MIXER_PCM] >> 8) & 0xff;

	emu10k1_set_volume_gpr(card, 6, left, VOL_5BIT);
	emu10k1_set_volume_gpr(card, 7, right, VOL_5BIT);

	//CD-Digital Volume
	mgr->ctrl_gpr[SOUND_MIXER_DIGITAL1][0] = 0xd;
	mgr->ctrl_gpr[SOUND_MIXER_DIGITAL1][1] = 0xf;

//	left = right = 67;
//	card->ac97.mixer_state[SOUND_MIXER_DIGITAL1] = (right << 8) | left; 

//	card->ac97.supported_mixers |= SOUND_MASK_DIGITAL1;
//	card->ac97.stereo_mixers |= SOUND_MASK_DIGITAL1;

	emu10k1_set_volume_gpr(card, 0xd, left, VOL_5BIT);
	emu10k1_set_volume_gpr(card, 0xf, right, VOL_5BIT);

	//hard wire the ac97's pcm, we'll do that in dsp code instead.
//	emu10k1_ac97_write(&card->ac97, 0x18, 0x0);
//	card->ac97_supported_mixers &= ~SOUND_MASK_PCM;
//	card->ac97_stereo_mixers &= ~SOUND_MASK_PCM;

	//set Igain to 0dB by default, maybe consider hardwiring it here.
//	emu10k1_ac97_write(&card->ac97, AC97_RECORD_GAIN, 0x0000);
//	card->ac97.mixer_state[SOUND_MIXER_IGAIN] = 0x101; 

	return 0;
}
Пример #21
0
static int decode_frame(AVCodecContext *avctx,
                        void *data, int *data_size,
                        AVPacket *avpkt)
{
    AnmContext *s = avctx->priv_data;
    const uint8_t *buf = avpkt->data;
    const int buf_size = avpkt->size;
    const uint8_t *buf_end = buf + buf_size;
    uint8_t *dst, *dst_end;
    int count;

    if(avctx->reget_buffer(avctx, &s->frame) < 0){
        av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
        return -1;
    }
    dst     = s->frame.data[0];
    dst_end = s->frame.data[0] + s->frame.linesize[0]*avctx->height;

    if (buf[0] != 0x42) {
        av_log_ask_for_sample(avctx, "unknown record type\n");
        return buf_size;
    }
    if (buf[1]) {
        av_log_ask_for_sample(avctx, "padding bytes not supported\n");
        return buf_size;
    }
    buf += 4;

    s->x = 0;
    do {
        /* if statements are ordered by probability */
#define OP(buf, pixel, count) \
    op(&dst, dst_end, (buf), buf_end, (pixel), (count), &s->x, avctx->width, s->frame.linesize[0])

        int type = bytestream_get_byte(&buf);
        count = type & 0x7F;
        type >>= 7;
        if (count) {
            if (OP(type ? NULL : &buf, -1, count)) break;
        } else if (!type) {
            int pixel;
            count = bytestream_get_byte(&buf);  /* count==0 gives nop */
            pixel = bytestream_get_byte(&buf);
            if (OP(NULL, pixel, count)) break;
        } else {
            int pixel;
            type = bytestream_get_le16(&buf);
            count = type & 0x3FFF;
            type >>= 14;
            if (!count) {
                if (type == 0)
                    break; // stop
                if (type == 2) {
                    av_log_ask_for_sample(avctx, "unknown opcode");
                    return AVERROR_INVALIDDATA;
                }
                continue;
            }
            pixel = type == 3 ? bytestream_get_byte(&buf) : -1;
            if (type == 1) count += 0x4000;
            if (OP(type == 2 ? &buf : NULL, pixel, count)) break;
        }
    } while (buf + 1 < buf_end);

    *data_size = sizeof(AVFrame);
    *(AVFrame*)data = s->frame;
    return buf_size;
}
Пример #22
0
BOOST_UBLAS_INLINE
typename vector_unary_traits<E, OP>::result_type
apply_to_all (const vector_expression<E> &e, const OP& op = OP() ) {
	typedef typename vector_unary_traits<E, OP>::expression_type expression_type;
	return expression_type (e ());
}
Пример #23
0
void
describe_ppc_trap(ExceptionInformation *xp)
{
  pc where = xpPC(xp);
  opcode the_trap = *where, instr;
  int err_arg2, ra, rs;
  Boolean identified = false;

  if ((the_trap & OP_MASK) == OP(major_opcode_TRI)) {
    /* TWI/TDI.  If the RA field is "nargs", that means that the
       instruction is either a number-of-args check or an
       event-poll.  Otherwise, the trap is some sort of
       typecheck. */

    if (RA_field(the_trap) == nargs) {
      switch (TO_field(the_trap)) {
      case TO_NE:
	if (xpGPR(xp, nargs) < D_field(the_trap)) {
	  fprintf(dbgout, "Too few arguments (no opt/rest)\n");
	} else {
	  fprintf(dbgout, "Too many arguments (no opt/rest)\n");
	}
	identified = true;
	break;
	
      case TO_GT:
	fprintf(dbgout, "Event poll !\n");
	identified = true;
	break;
	
      case TO_HI:
	fprintf(dbgout, "Too many arguments (with opt)\n");
	identified = true;
	break;
	
      case TO_LT:
	fprintf(dbgout, "Too few arguments (with opt/rest/key)\n");
	identified = true;
	break;
	
      default:                /* some weird trap, not ours. */
	identified = false;
	break;
      }
    } else {
      /* A type or boundp trap of some sort. */
      switch (TO_field(the_trap)) {
      case TO_EQ:
	/* Boundp traps are of the form:
	   treqi rX,unbound
	   where some preceding instruction is of the form:
	   lwz/ld rX,symbol.value(rY).
	   The error message should try to say that rY is unbound. */
	
	if (D_field(the_trap) == unbound) {
#ifdef PPC64
	  instr = scan_for_instr(LD_instruction(RA_field(the_trap),
                                                unmasked_register,
                                                offsetof(lispsymbol,vcell)-fulltag_misc),
				 D_RT_IMM_MASK,
				 where);
#else
	  instr = scan_for_instr(LWZ_instruction(RA_field(the_trap),
						 unmasked_register,
						 offsetof(lispsymbol,vcell)-fulltag_misc),
				 D_RT_IMM_MASK,
				 where);
#endif
	  if (instr) {
	    ra = RA_field(instr);
	    if (lisp_reg_p(ra)) {
	      fprintf(dbgout, "Unbound variable: %s\n",
		      print_lisp_object(xpGPR(xp,ra)));
	      identified = true;	
	    }
	  }
	}
	break;
	
      case TO_NE:
	/* A type check.  If the type (the immediate field of the trap
	   instruction) is a header type, an "lbz
	   rX,misc_header_offset(rY)" should precede it, in which case
	   we say that "rY is not of header type <type>."  If the type
	   is not a header type, then rX should have been set by a
	   preceding "clrlwi rX,rY,29/30".  In that case, scan
	   backwards for an RLWINM instruction that set rX and report
	   that rY isn't of the indicated type. */
	err_arg2 = D_field(the_trap);
	if (nodeheader_tag_p(err_arg2) ||
	    immheader_tag_p(err_arg2)) {
	  instr = scan_for_instr(LBZ_instruction(RA_field(the_trap),
						 unmasked_register,
						 misc_subtag_offset),
				 D_RT_IMM_MASK,
				 where);
	  if (instr) {
	    ra = RA_field(instr);
	    if (lisp_reg_p(ra)) {
	      fprintf(dbgout, "value 0x%lX is not of the expected header type 0x%02X\n", xpGPR(xp, ra), err_arg2);
	      identified = true;
	    }
	  }
	} else {		
	  /* Not a header type, look for rlwinm whose RA field matches the_trap's */
	  instr = scan_for_instr((OP(major_opcode_RLWINM) | (the_trap & RA_MASK)),
				 (OP_MASK | RA_MASK),
				 where);
	  if (instr) {
	    rs = RS_field(instr);
	    if (lisp_reg_p(rs)) {
	      fprintf(dbgout, "value 0x%lX is not of the expected type 0x%02X\n",
		      xpGPR(xp, rs), err_arg2);
	      identified = true;
	    }
	  }
	}
	break;
      }
    }
  } else {
    /* a "TW <to>,ra,rb" instruction."
       twltu sp,rN is stack-overflow on SP.
       twgeu rX,rY is subscript out-of-bounds, which was preceded
       by an "lwz rM,misc_header_offset(rN)" instruction.
       rM may or may not be the same as rY, but no other header
       would have been loaded before the trap. */
    switch (TO_field(the_trap)) {
    case TO_LO:
      if (RA_field(the_trap) == sp) {
	fprintf(dbgout, "Stack overflow! Run away! Run away!\n");
	identified = true;
      }
      break;
      
    case (TO_HI|TO_EQ):
      instr = scan_for_instr(OP(major_opcode_LWZ) | (D_MASK & misc_header_offset),
			     (OP_MASK | D_MASK),
			     where);
      if (instr) {
	ra = RA_field(instr);
	if (lisp_reg_p(ra)) {
	  fprintf(dbgout, "Bad index %d for vector %lX length %d\n",
		  unbox_fixnum(xpGPR(xp, RA_field(the_trap))),
		  xpGPR(xp, ra),
		  unbox_fixnum(xpGPR(xp, RB_field(the_trap))));
	  identified = true;
	}
      }
      break;
    }
  }

  if (!identified) {
    fprintf(dbgout, "Unknown trap: 0x%08x\n", the_trap);
  }


}
Пример #24
0
Файл: numd.c Проект: imr/ngspice
Copyright 1992 Regents of the University of California.  All rights reserved.
Author:	1987 Kartikeya Mayaram, U. C. Berkeley CAD Group
**********/

#include "ngspice/ngspice.h"
#include "ngspice/devdefs.h"
#include "numddefs.h"
#include "ngspice/suffix.h"

IFparm NUMDpTable[] = {		/* parameters */
  IP("off", NUMD_OFF, IF_FLAG, "Initially off"),
  IP("ic.file", NUMD_IC_FILE, IF_REAL, "Initial conditions file"),
  IOP("area", NUMD_AREA, IF_REAL, "Area factor"),
  IP("save", NUMD_PRINT, IF_INTEGER, "Save Solutions"),
  IPR("print", NUMD_PRINT, IF_INTEGER, "Print Solutions"),
  OP("vd", NUMD_VD, IF_REAL, "Voltage"),
  OPR("voltage", NUMD_VD, IF_REAL, "Voltage"),
  OP("id", NUMD_ID, IF_REAL, "Current"),
  OPR("current", NUMD_ID, IF_REAL, "Current"),
  OP("g11", NUMD_G11, IF_REAL, "Conductance"),
  OPR("conductance", NUMD_G11, IF_REAL, "Conductance"),
  OP("c11", NUMD_C11, IF_REAL, "Capacitance"),
  OPR("capacitance", NUMD_C11, IF_REAL, "Capacitance"),
  OP("y11", NUMD_Y11, IF_COMPLEX, "Admittance"),
  OPU("g12", NUMD_G12, IF_REAL, "Conductance"),
  OPU("c12", NUMD_C12, IF_REAL, "Capacitance"),
  OPU("y12", NUMD_Y12, IF_COMPLEX, "Admittance"),
  OPU("g21", NUMD_G21, IF_REAL, "Conductance"),
  OPU("c21", NUMD_C21, IF_REAL, "Capacitance"),
  OPU("y21", NUMD_Y21, IF_COMPLEX, "Admittance"),
  OPU("g22", NUMD_G22, IF_REAL, "Conductance"),
Пример #25
0
Copyright 1990 Regents of the University of California.  All rights reserved.
Authors: 1985 Thomas L. Quarles
         1993 Stephen R. Whiteley
****************************************************************************/

#include "spice.h"
#include <stdio.h>
#include "resdefs.h"
#include "uflags.h"

static IFparm RESpTable[] = { /* parameters */ 
 IOPP( "resistance", RES_RESIST, IF_REAL,"Resistance"),
 IOPZU("temp",       RES_TEMP,   IF_REAL,"Instance operating temperature"),
 IOPQU("w",          RES_WIDTH,  IF_REAL,"Width"),
 IOPZU("l",          RES_LENGTH, IF_REAL,"Length"),
 OP(   "c",          RES_CURRENT,IF_REAL,"Current"),
 OP(   "p",          RES_POWER,  IF_REAL,"Power"),
} ;

static IFparm RESmPTable[] = { /* model parameters */
 IOPQ( "rsh",    RES_MOD_RSH,      IF_REAL,"Sheet resistance"),
 IOPZ( "narrow", RES_MOD_NARROW,   IF_REAL,"Narrowing of resistor"),
 IOPQ( "tc1",    RES_MOD_TC1,      IF_REAL,"First order temp. coefficient"),
 IOPQO("tc2",    RES_MOD_TC2,      IF_REAL,"Second order temp. coefficient"),
 IOPX( "defw",   RES_MOD_DEFWIDTH, IF_REAL,"Default device width"),
 IOPXU("tnom",   RES_MOD_TNOM,     IF_REAL,"Parameter measurement temperature"),
 IP(   "r",      RES_MOD_R,        IF_FLAG,"Device is a resistor model"),
};

static char *RESnames[] = {
    "R+",
Пример #26
0
#define OPERAND(op) OR1K_OPERAND_##op
#define MNEM CGEN_SYNTAX_MNEMONIC /* syntax value for mnemonic */
#define OP(field) CGEN_SYNTAX_MAKE_FIELD (OPERAND (field))

/* The instruction table.  */

static const CGEN_OPCODE or1k_cgen_insn_opcode_table[MAX_INSNS] =
{
  /* Special null first entry.
     A `num' value of zero is thus invalid.
     Also, the special `invalid' insn resides here.  */
  { { 0, 0, 0, 0 }, {{0}}, 0, {0}},
/* l.j ${disp26} */
  {
    { 0, 0, 0, 0 },
    { { MNEM, ' ', OP (DISP26), 0 } },
    & ifmt_l_j, { 0x0 }
  },
/* l.adrp $rD,${disp21} */
  {
    { 0, 0, 0, 0 },
    { { MNEM, ' ', OP (RD), ',', OP (DISP21), 0 } },
    & ifmt_l_adrp, { 0x8000000 }
  },
/* l.jal ${disp26} */
  {
    { 0, 0, 0, 0 },
    { { MNEM, ' ', OP (DISP26), 0 } },
    & ifmt_l_j, { 0x4000000 }
  },
/* l.jr $rB */
Пример #27
0
#define OPERAND(op) MT_OPERAND_##op
#define MNEM CGEN_SYNTAX_MNEMONIC /* syntax value for mnemonic */
#define OP(field) CGEN_SYNTAX_MAKE_FIELD (OPERAND (field))

/* The instruction table.  */

static const CGEN_OPCODE mt_cgen_insn_opcode_table[MAX_INSNS] =
{
  /* Special null first entry.
     A `num' value of zero is thus invalid.
     Also, the special `invalid' insn resides here.  */
  { { 0, 0, 0, 0 }, {{0}}, 0, {0}},
/* add $frdrrr,$frsr1,$frsr2 */
  {
    { 0, 0, 0, 0 },
    { { MNEM, ' ', OP (FRDRRR), ',', OP (FRSR1), ',', OP (FRSR2), 0 } },
    & ifmt_add, { 0x0 }
  },
/* addu $frdrrr,$frsr1,$frsr2 */
  {
    { 0, 0, 0, 0 },
    { { MNEM, ' ', OP (FRDRRR), ',', OP (FRSR1), ',', OP (FRSR2), 0 } },
    & ifmt_add, { 0x2000000 }
  },
/* addi $frdr,$frsr1,#$imm16 */
  {
    { 0, 0, 0, 0 },
    { { MNEM, ' ', OP (FRDR), ',', OP (FRSR1), ',', '#', OP (IMM16), 0 } },
    & ifmt_addi, { 0x1000000 }
  },
/* addui $frdr,$frsr1,#$imm16z */
Пример #28
0
void setup_opcodes(void)
{
  for(int i = 0; i < 5; i++)
  {
    for(int j = 0; j < 256; j++)
    {
      op[i][j] = illegal_opcode;
    }
  }
#define OP(args, opcode, fn) do { op[args][opcode] = fn; opnames[args][opcode] = #fn; } while(0)
  OP(ZERO, 0x00, zrtrue);
  OP(ZERO, 0x01, zrfalse);
  OP(ZERO, 0x02, zprint);
  OP(ZERO, 0x03, zprint_ret);
  OP(ZERO, 0x04, znop);
  if(zversion <= 4) OP(ZERO, 0x05, zsave);
  if(zversion <= 4) OP(ZERO, 0x06, zrestore);
  OP(ZERO, 0x07, zrestart);
  OP(ZERO, 0x08, zret_popped);
  if(zversion <= 4) OP(ZERO, 0x09, zpop);
  else              OP(ZERO, 0x09, zcatch);
  OP(ZERO, 0x0a, zquit);
  OP(ZERO, 0x0b, znew_line);
  if     (zversion == 3) OP(ZERO, 0x0c, zshow_status);
  else if(zversion >= 4) OP(ZERO, 0x0c, znop); /* §15: Technically illegal in V4+, but a V5 Wishbringer accidentally uses this opcode. */
  if(zversion >= 3) OP(ZERO, 0x0d, zverify);
  if(zversion >= 5) OP(ZERO, 0x0e, zextended);
  if(zversion >= 5) OP(ZERO, 0x0f, zpiracy);

  OP(ONE, 0x00, zjz);
  OP(ONE, 0x01, zget_sibling);
  OP(ONE, 0x02, zget_child);
  OP(ONE, 0x03, zget_parent);
  OP(ONE, 0x04, zget_prop_len);
  OP(ONE, 0x05, zinc);
  OP(ONE, 0x06, zdec);
  OP(ONE, 0x07, zprint_addr);
  if(zversion >= 4) OP(ONE, 0x08, zcall_1s);
  OP(ONE, 0x09, zremove_obj);
  OP(ONE, 0x0a, zprint_obj);
  OP(ONE, 0x0b, zret);
  OP(ONE, 0x0c, zjump);
  OP(ONE, 0x0d, zprint_paddr);
  OP(ONE, 0x0e, zload);
  if(zversion <= 4) OP(ONE, 0x0f, znot);
  else              OP(ONE, 0x0f, zcall_1n);

  OP(TWO, 0x01, zje);
  OP(TWO, 0x02, zjl);
  OP(TWO, 0x03, zjg);
  OP(TWO, 0x04, zdec_chk);
  OP(TWO, 0x05, zinc_chk);
  OP(TWO, 0x06, zjin);
  OP(TWO, 0x07, ztest);
  OP(TWO, 0x08, zor);
  OP(TWO, 0x09, zand);
  OP(TWO, 0x0a, ztest_attr);
  OP(TWO, 0x0b, zset_attr);
  OP(TWO, 0x0c, zclear_attr);
  OP(TWO, 0x0d, zstore);
  OP(TWO, 0x0e, zinsert_obj);
  OP(TWO, 0x0f, zloadw);
  OP(TWO, 0x10, zloadb);
  OP(TWO, 0x11, zget_prop);
  OP(TWO, 0x12, zget_prop_addr);
  OP(TWO, 0x13, zget_next_prop);
  OP(TWO, 0x14, zadd);
  OP(TWO, 0x15, zsub);
  OP(TWO, 0x16, zmul);
  OP(TWO, 0x17, zdiv);
  OP(TWO, 0x18, zmod);
  if(zversion >= 4) OP(TWO, 0x19, zcall_2s);
  if(zversion >= 5) OP(TWO, 0x1a, zcall_2n);
  if(zversion >= 5) OP(TWO, 0x1b, zset_colour);
  if(zversion >= 5) OP(TWO, 0x1c, zthrow);

  OP(VAR, 0x00, zcall);
  OP(VAR, 0x01, zstorew);
  OP(VAR, 0x02, zstoreb);
  OP(VAR, 0x03, zput_prop);
  OP(VAR, 0x04, zread);
  OP(VAR, 0x05, zprint_char);
  OP(VAR, 0x06, zprint_num);
  OP(VAR, 0x07, zrandom);
  OP(VAR, 0x08, zpush);
  OP(VAR, 0x09, zpull);
  if(zversion >= 3) OP(VAR, 0x0a, zsplit_window);
  if(zversion >= 3) OP(VAR, 0x0b, zset_window);
  if(zversion >= 4) OP(VAR, 0x0c, zcall_vs2);
  if(zversion >= 4) OP(VAR, 0x0d, zerase_window);
  if(zversion >= 4) OP(VAR, 0x0e, zerase_line);
  if(zversion >= 4) OP(VAR, 0x0f, zset_cursor);
  if(zversion >= 4) OP(VAR, 0x10, zget_cursor);
  if(zversion >= 4) OP(VAR, 0x11, zset_text_style);
  if(zversion >= 4) OP(VAR, 0x12, znop); /* XXX buffer_mode */
  if(zversion >= 3) OP(VAR, 0x13, zoutput_stream);
  if(zversion >= 3) OP(VAR, 0x14, zinput_stream);
  if(zversion >= 3) OP(VAR, 0x15, zsound_effect);
  if(zversion >= 4) OP(VAR, 0x16, zread_char);
  if(zversion >= 4) OP(VAR, 0x17, zscan_table);
  if(zversion >= 5) OP(VAR, 0x18, znot);
  if(zversion >= 5) OP(VAR, 0x19, zcall_vn);
  if(zversion >= 5) OP(VAR, 0x1a, zcall_vn2);
  if(zversion >= 5) OP(VAR, 0x1b, ztokenise);
  if(zversion >= 5) OP(VAR, 0x1c, zencode_text);
  if(zversion >= 5) OP(VAR, 0x1d, zcopy_table);
  if(zversion >= 5) OP(VAR, 0x1e, zprint_table);
  if(zversion >= 5) OP(VAR, 0x1f, zcheck_arg_count);

  if(zversion >= 5) OP(EXT, 0x00, zsave5);
  if(zversion >= 5) OP(EXT, 0x01, zrestore5);
  if(zversion >= 5) OP(EXT, 0x02, zlog_shift);
  if(zversion >= 5) OP(EXT, 0x03, zart_shift);
  if(zversion >= 5) OP(EXT, 0x04, zset_font);
  if(zversion >= 6) OP(EXT, 0x05, znop); /* XXX draw_picture */
  if(zversion >= 6) OP(EXT, 0x06, zpicture_data);
  if(zversion >= 6) OP(EXT, 0x07, znop); /* XXX erase_picture */
  if(zversion >= 6) OP(EXT, 0x08, znop); /* XXX set_margins */
  if(zversion >= 5) OP(EXT, 0x09, zsave_undo);
  if(zversion >= 5) OP(EXT, 0x0a, zrestore_undo);
  if(zversion >= 5) OP(EXT, 0x0b, zprint_unicode);
  if(zversion >= 5) OP(EXT, 0x0c, zcheck_unicode);
  if(zversion >= 5) OP(EXT, 0x0d, zset_true_colour);
  if(zversion >= 6) OP(EXT, 0x10, znop); /* XXX move_window */
  if(zversion >= 6) OP(EXT, 0x11, znop); /* XXX window_size */
  if(zversion >= 6) OP(EXT, 0x12, znop); /* XXX window_style */
  if(zversion >= 6) OP(EXT, 0x13, zget_wind_prop);
  if(zversion >= 6) OP(EXT, 0x14, znop); /* XXX scroll_window */
  if(zversion >= 6) OP(EXT, 0x15, zpop_stack);
  if(zversion >= 6) OP(EXT, 0x16, znop); /* XXX read_mouse */
  if(zversion >= 6) OP(EXT, 0x17, znop); /* XXX mouse_window */
  if(zversion >= 6) OP(EXT, 0x18, zpush_stack);
  if(zversion >= 6) OP(EXT, 0x19, znop); /* XXX put_wind_prop */
  if(zversion >= 6) OP(EXT, 0x1a, zprint_form);
  if(zversion >= 6) OP(EXT, 0x1b, zmake_menu);
  if(zversion >= 6) OP(EXT, 0x1c, znop); /* XXX picture_table */
  if(zversion >= 6) OP(EXT, 0x1d, zbuffer_screen);

  /* Zoom extensions. */
  OP(EXT, 0x80, zstart_timer);
  OP(EXT, 0x81, zstop_timer);
  OP(EXT, 0x82, zread_timer);
  OP(EXT, 0x83, zprint_timer);
#undef OP
}
Пример #29
0
 IOPU("temp",    VBIC_TEMP,           IF_REAL,    "Instance temperature"),
 IOPU("dtemp",   VBIC_DTEMP,          IF_REAL,    "Instance delta temperature"),
 IOPU("m",       VBIC_M,              IF_REAL,    "Multiplier"),

 OPU("collnode", VBIC_QUEST_COLLNODE, IF_INTEGER, "Number of collector node"),
 OPU("basenode", VBIC_QUEST_BASENODE, IF_INTEGER, "Number of base node"),
 OPU("emitnode", VBIC_QUEST_EMITNODE, IF_INTEGER, "Number of emitter node"),
 OPU("subsnode", VBIC_QUEST_SUBSNODE, IF_INTEGER, "Number of substrate node"),
 OPU("collCXnode",VBIC_QUEST_COLLCXNODE,IF_INTEGER, "Internal collector node"),
 OPU("collCInode",VBIC_QUEST_COLLCINODE,IF_INTEGER, "Internal collector node"),
 OPU("baseBXnode",VBIC_QUEST_BASEBXNODE,IF_INTEGER, "Internal base node"),
 OPU("baseBInode",VBIC_QUEST_BASEBINODE,IF_INTEGER, "Internal base node"),
 OPU("baseBPnode",VBIC_QUEST_BASEBPNODE,IF_INTEGER, "Internal base node"),
 OPU("emitEInode",VBIC_QUEST_EMITEINODE,IF_INTEGER, "Internal emitter node"),
 OPU("subsSInode",VBIC_QUEST_SUBSSINODE,IF_INTEGER, "Internal substrate node"),
 OP("vbe",   VBIC_QUEST_VBE,  IF_REAL, "B-E voltage"),
 OP("vbc",   VBIC_QUEST_VBC,  IF_REAL, "B-C voltage"),
 OP("ic",    VBIC_QUEST_CC,   IF_REAL, "Collector current"),
 OP("ib",    VBIC_QUEST_CB,   IF_REAL, "Base current"),
 OP("ie",    VBIC_QUEST_CE,   IF_REAL, "Emitter current"),
 OP("is",    VBIC_QUEST_CS,   IF_REAL, "Substrate current"),
 OP("gm",    VBIC_QUEST_GM,   IF_REAL, "Small signal transconductance dIc/dVbe"),
 OP("go",    VBIC_QUEST_GO,   IF_REAL, "Small signal output conductance dIc/dVbc"),
 OP("gpi",   VBIC_QUEST_GPI,  IF_REAL, "Small signal input conductance dIb/dVbe"),
 OP("gmu",   VBIC_QUEST_GMU,  IF_REAL, "Small signal conductance dIb/dVbc"),
 OP("gx",    VBIC_QUEST_GX,   IF_REAL, "Conductance from base to internal base"),
 OP("cbe",   VBIC_QUEST_CBE,  IF_REAL, "Internal base to emitter capacitance"),
 OP("cbex",  VBIC_QUEST_CBEX, IF_REAL, "External base to emitter capacitance"),
 OP("cbc",   VBIC_QUEST_CBC,  IF_REAL, "Internal base to collector capacitance"),
 OP("cbcx",  VBIC_QUEST_CBCX, IF_REAL, "External Base to collector capacitance"),
 OP("cbep",  VBIC_QUEST_CBEP, IF_REAL, "Parasitic Base to emitter capacitance"),
Пример #30
0
void Hlsl11GeneratorInstance::PrintOperationNodeInit(OperationNode* node)
{
	OperationNode::Operation operation = node->GetOperation();
	switch(operation)
	{
	case OperationNode::operationNegate:
		text << '-';
		PrintNode(node->GetA());
		break;
	case OperationNode::operationAdd:
		PrintNode(node->GetA());
		text << " + ";
		PrintNode(node->GetB());
		break;
	case OperationNode::operationSubtract:
		PrintNode(node->GetA());
		text << " - ";
		PrintNode(node->GetB());
		break;
	case OperationNode::operationMultiply:
		PrintNode(node->GetA());
		text << " * ";
		PrintNode(node->GetB());
		break;
	case OperationNode::operationDivide:
		PrintNode(node->GetA());
		text << " / ";
		PrintNode(node->GetB());
		break;
	case OperationNode::operationLess:
		PrintNode(node->GetA());
		text << " < ";
		PrintNode(node->GetB());
		break;
	case OperationNode::operationLessEqual:
		PrintNode(node->GetA());
		text << " <= ";
		PrintNode(node->GetB());
		break;
	case OperationNode::operationEqual:
		PrintNode(node->GetA());
		text << " == ";
		PrintNode(node->GetB());
		break;
	case OperationNode::operationNotEqual:
		PrintNode(node->GetA());
		text << " != ";
		PrintNode(node->GetB());
		break;
	case OperationNode::operationGetInstanceID:
		text << "sI";
		break;
	case OperationNode::operationScreenToTexture:
		PrintNode(node->GetA());
		text << " * float2(0.5f, -0.5f) + float2(0.5f, 0.5f)";
		break;
	default:
		{
			// остались только функции, которые делаются простым преобразованием имени
			const char* name;
			switch(operation)
			{
#define OP(o, n) case OperationNode::operation##o: name = #n; break
				OP(Float11to2, float2);
				OP(Float111to3, float3);
				OP(Float1111to4, float4);
				OP(Float31to4, float4);
				OP(Float211to4, float4);
				OP(Dot, dot);
				OP(Cross, cross);
				OP(Mul, mul);
				OP(Length, length);
				OP(Normalize, normalize);
				OP(Lerp, lerp);
				OP(Pow, pow);
				OP(Min, min);
				OP(Max, max);
				OP(Abs, abs);
				OP(Sqrt, sqrt);
				OP(Sin, sin);
				OP(Cos, cos);
				OP(Atan2, atan2);
				OP(Exp, exp);
				OP(Exp2, exp2);
				OP(Log, log);
				OP(Saturate, saturate);
				OP(Ddx, ddx);
				OP(Ddy, ddy);
				OP(Floor, floor);
				OP(Ceil, ceil);
				OP(Mod, fmod);
#undef OP
			default:
				THROW("Invalid operation type");
			}

			// вывести
			text << name << '(';
			int argumentsCount = node->GetArgumentsCount();
			for(int i = 0; i < argumentsCount; ++i)
			{
				if(i)
					text << ", ";
				PrintNode(node->GetArgument(i));
			}
			text << ')';
		}
	}
}