dagcheck.c

lcc source code enjoy your self

/* 82 */	"I: MODI(I,I)",
/* 83 */	"U: MODU(U,U)",
/* 84 */	"I: RSHI(I,I)",
/* 85 */	"U: RSHU(U,I)",
/* 86 */	"U: BANDU(U,U)",
/* 87 */	"I: BANDI(I,I)",
/* 88 */	"U: BCOMU(U)",
/* 89 */	"I: BCOMI(I)",
/* 90 */	"I: BORI(I,I)",
/* 91 */	"U: BORU(U,U)",
/* 92 */	"U: BXORU(U,U)",
/* 93 */	"I: BXORI(I,I)",
/* 94 */	"F: DIVF(F,F)",
/* 95 */	"I: DIVI(I,I)",
/* 96 */	"U: DIVU(U,U)",
/* 97 */	"F: MULF(F,F)",
/* 98 */	"I: MULI(I,I)",
/* 99 */	"U: MULU(U,U)",
/* 100 */	"V: EQF(F,F)",
/* 101 */	"V: EQI(I,I)",
/* 102 */	"V: EQU(U,U)",
/* 103 */	"V: GEF(F,F)",
/* 104 */	"V: GEI(I,I)",
/* 105 */	"V: GEU(U,U)",
/* 106 */	"V: GTF(F,F)",
/* 107 */	"V: GTI(I,I)",
/* 108 */	"V: GTU(U,U)",
/* 109 */	"V: LEF(F,F)",
/* 110 */	"V: LEI(I,I)",
/* 111 */	"V: LEU(U,U)",
/* 112 */	"V: LTF(F,F)",
/* 113 */	"V: LTI(I,I)",
/* 114 */	"V: LTU(U,U)",
/* 115 */	"V: NEF(F,F)",
/* 116 */	"V: NEI(I,I)",
/* 117 */	"V: NEU(U,U)",
/* 118 */	"V: JUMPV(P)",
/* 119 */	"V: LABELV",
};

static short _decode_stmt[] = {
	0,
	1,
	2,
	3,
	4,
	5,
	6,
	7,
	8,
	9,
	10,
};

static short _decode_P[] = {
	0,
	19,
	25,
	41,
	50,
	51,
	58,
	65,
	66,
	67,
	70,
	71,
	72,
	73,
	77,
	78,
};

static short _decode_V[] = {
	0,
	22,
	27,
	28,
	29,
	30,
	31,
	32,
	33,
	34,
	35,
	36,
	54,
	59,
	60,
	61,
	62,
	63,
	64,
	100,
	101,
	102,
	103,
	104,
	105,
	106,
	107,
	108,
	109,
	110,
	111,
	112,
	113,
	114,
	115,
	116,
	117,
	118,
	119,
};

static short _decode_bogus[] = {
	0,
	11,
	12,
	13,
	14,
	15,
	16,
};

static short _decode_I[] = {
	0,
	17,
	24,
	39,
	42,
	43,
	44,
	53,
	56,
	69,
	76,
	80,
	82,
	84,
	87,
	89,
	90,
	93,
	95,
	98,
};

static short _decode_U[] = {
	0,
	18,
	26,
	40,
	45,
	46,
	47,
	57,
	74,
	79,
	81,
	83,
	85,
	86,
	88,
	91,
	92,
	96,
	99,
};

static short _decode_F[] = {
	0,
	20,
	23,
	38,
	48,
	49,
	52,
	55,
	68,
	75,
	94,
	97,
};

static short _decode_B[] = {
	0,
	21,
	37,
};

static int _rule(void *state, int goalnt) {
	if (goalnt < 1 || goalnt > 8)
		fatal("_rule", "Bad goal nonterminal %d\n", goalnt);
	if (!state)
		return 0;
	switch (goalnt) {
	case _stmt_NT:	return _decode_stmt[((struct _state *)state)->rule._stmt];
	case _P_NT:	return _decode_P[((struct _state *)state)->rule._P];
	case _V_NT:	return _decode_V[((struct _state *)state)->rule._V];
	case _bogus_NT:	return _decode_bogus[((struct _state *)state)->rule._bogus];
	case _I_NT:	return _decode_I[((struct _state *)state)->rule._I];
	case _U_NT:	return _decode_U[((struct _state *)state)->rule._U];
	case _F_NT:	return _decode_F[((struct _state *)state)->rule._F];
	case _B_NT:	return _decode_B[((struct _state *)state)->rule._B];
	default:
		fatal("_rule", "Bad goal nonterminal %d\n", goalnt);
		return 0;
	}
}

static void _closure_P(NODEPTR_TYPE, int);
static void _closure_V(NODEPTR_TYPE, int);
static void _closure_bogus(NODEPTR_TYPE, int);
static void _closure_I(NODEPTR_TYPE, int);
static void _closure_U(NODEPTR_TYPE, int);
static void _closure_F(NODEPTR_TYPE, int);
static void _closure_B(NODEPTR_TYPE, int);

static void _closure_P(NODEPTR_TYPE a, int c) {
	struct _state *p = STATE_LABEL(a);
	if (c + 1 < p->cost[_bogus_NT]) {
		p->cost[_bogus_NT] = c + 1;
		p->rule._bogus = 3;
		_closure_bogus(a, c + 1);
	}
}

static void _closure_V(NODEPTR_TYPE a, int c) {
	struct _state *p = STATE_LABEL(a);
	if (c + 1 < p->cost[_bogus_NT]) {
		p->cost[_bogus_NT] = c + 1;
		p->rule._bogus = 6;
		_closure_bogus(a, c + 1);
	}
	if (c + 0 < p->cost[_stmt_NT]) {
		p->cost[_stmt_NT] = c + 0;
		p->rule._stmt = 10;
	}
}

static void _closure_bogus(NODEPTR_TYPE a, int c) {
	struct _state *p = STATE_LABEL(a);
	if (c + 1 < p->cost[_V_NT]) {
		p->cost[_V_NT] = c + 1;
		p->rule._V = 1;
		_closure_V(a, c + 1);
	}
	if (c + 1 < p->cost[_B_NT]) {
		p->cost[_B_NT] = c + 1;
		p->rule._B = 1;
		_closure_B(a, c + 1);
	}
	if (c + 1 < p->cost[_F_NT]) {
		p->cost[_F_NT] = c + 1;
		p->rule._F = 1;
		_closure_F(a, c + 1);
	}
	if (c + 1 < p->cost[_P_NT]) {
		p->cost[_P_NT] = c + 1;
		p->rule._P = 1;
		_closure_P(a, c + 1);
	}
	if (c + 1 < p->cost[_U_NT]) {
		p->cost[_U_NT] = c + 1;
		p->rule._U = 1;
		_closure_U(a, c + 1);
	}
	if (c + 1 < p->cost[_I_NT]) {
		p->cost[_I_NT] = c + 1;
		p->rule._I = 1;
		_closure_I(a, c + 1);
	}
}

static void _closure_I(NODEPTR_TYPE a, int c) {
	struct _state *p = STATE_LABEL(a);
	if (c + 1 < p->cost[_bogus_NT]) {
		p->cost[_bogus_NT] = c + 1;
		p->rule._bogus = 1;
		_closure_bogus(a, c + 1);
	}
}

static void _closure_U(NODEPTR_TYPE a, int c) {
	struct _state *p = STATE_LABEL(a);
	if (c + 1 < p->cost[_bogus_NT]) {
		p->cost[_bogus_NT] = c + 1;
		p->rule._bogus = 2;
		_closure_bogus(a, c + 1);
	}
}

static void _closure_F(NODEPTR_TYPE a, int c) {
	struct _state *p = STATE_LABEL(a);
	if (c + 1 < p->cost[_bogus_NT]) {
		p->cost[_bogus_NT] = c + 1;
		p->rule._bogus = 4;
		_closure_bogus(a, c + 1);
	}
}

static void _closure_B(NODEPTR_TYPE a, int c) {
	struct _state *p = STATE_LABEL(a);
	if (c + 1 < p->cost[_bogus_NT]) {
		p->cost[_bogus_NT] = c + 1;
		p->rule._bogus = 5;
		_closure_bogus(a, c + 1);
	}
}

static void _label(NODEPTR_TYPE a) {
	int c;
	struct _state *p;

	if (!a)
		fatal("_label", "Null tree\n", 0);
	STATE_LABEL(a) = p = allocate(sizeof *p, FUNC);
	p->rule._stmt = 0;
	p->cost[1] =
	p->cost[2] =
	p->cost[3] =
	p->cost[4] =
	p->cost[5] =
	p->cost[6] =
	p->cost[7] =
	p->cost[8] =
		0x7fff;
	switch (OP_LABEL(a)) {
	case 17: /* CNSTF */
		/* F: CNSTF */
		if (0 + 0 < p->cost[_F_NT]) {
			p->cost[_F_NT] = 0 + 0;
			p->rule._F = 2;
			_closure_F(a, 0 + 0);
		}
		break;
	case 21: /* CNSTI */
		/* I: CNSTI */
		if (0 + 0 < p->cost[_I_NT]) {
			p->cost[_I_NT] = 0 + 0;
			p->rule._I = 2;
			_closure_I(a, 0 + 0);
		}
		break;
	case 22: /* CNSTU */
		/* U: CNSTU */
		if (0 + 0 < p->cost[_U_NT]) {
			p->cost[_U_NT] = 0 + 0;
			p->rule._U = 2;
			_closure_U(a, 0 + 0);
		}
		break;
	case 23: /* CNSTP */
		/* P: CNSTP */
		if (0 + 0 < p->cost[_P_NT]) {
			p->cost[_P_NT] = 0 + 0;
			p->rule._P = 2;
			_closure_P(a, 0 + 0);
		}
		break;
	case 33: /* ARGF */
		_label(LEFT_CHILD(a));
		/* V: ARGF(F) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_F_NT] + 0;
		if (c + 0 < p->cost[_V_NT]) {
			p->cost[_V_NT] = c + 0;
			p->rule._V = 3;
			_closure_V(a, c + 0);
		}
		break;
	case 37: /* ARGI */
		_label(LEFT_CHILD(a));
		/* V: ARGI(I) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_I_NT] + 0;
		if (c + 0 < p->cost[_V_NT]) {
			p->cost[_V_NT] = c + 0;
			p->rule._V = 4;
			_closure_V(a, c + 0);
		}
		break;
	case 38: /* ARGU */
		_label(LEFT_CHILD(a));
		/* V: ARGU(U) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_U_NT] + 0;
		if (c + 0 < p->cost[_V_NT]) {
			p->cost[_V_NT] = c + 0;
			p->rule._V = 5;
			_closure_V(a, c + 0);
		}
		break;
	case 39: /* ARGP */
		_label(LEFT_CHILD(a));
		/* V: ARGP(P) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_P_NT] + 0;
		if (c + 0 < p->cost[_V_NT]) {
			p->cost[_V_NT] = c + 0;
			p->rule._V = 6;
			_closure_V(a, c + 0);
		}
		break;
	case 41: /* ARGB */
		_label(LEFT_CHILD(a));
		/* V: ARGB(B) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_B_NT] + 0;
		if (c + 0 < p->cost[_V_NT]) {
			p->cost[_V_NT] = c + 0;
			p->rule._V = 2;
			_closure_V(a, c + 0);
		}
		break;
	case 49: /* ASGNF */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* V: ASGNF(P,F) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_P_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_F_NT] + 0;
		if (c + 0 < p->cost[_V_NT]) {
			p->cost[_V_NT] = c + 0;
			p->rule._V = 8;
			_closure_V(a, c + 0);
		}
		break;
	case 53: /* ASGNI */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* V: ASGNI(P,I) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_P_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_I_NT] + 0;
		if (c + 0 < p->cost[_V_NT]) {
			p->cost[_V_NT] = c + 0;
			p->rule._V = 9;
			_closure_V(a, c + 0);
		}
		break;
	case 54: /* ASGNU */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* V: ASGNU(P,U) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_P_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_U_NT] + 0;
		if (c + 0 < p->cost[_V_NT]) {
			p->cost[_V_NT] = c + 0;
			p->rule._V = 10;
			_closure_V(a, c + 0);
		}
		break;
	case 55: /* ASGNP */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* V: ASGNP(P,P) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_P_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_P_NT] + 0;
		if (c + 0 < p->cost[_V_NT]) {
			p->cost[_V_NT] = c + 0;
			p->rule._V = 11;
			_closure_V(a, c + 0);
		}
		break;
	case 57: /* ASGNB */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* V: ASGNB(P,B) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_P_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_B_NT] + 0;
		if (c + 0 < p->cost[_V_NT]) {
			p->cost[_V_NT] = c + 0;
			p->rule._V = 7;
			_closure_V(a, c + 0);
		}
		break;
	case 65: /* INDIRF */
		_label(LEFT_CHILD(a));
		/* stmt: INDIRF(P) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_P_NT] + 0;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 2;
		}
		/* F: INDIRF(P) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_P_NT] + 0;
		if (c + 0 < p->cost[_F_NT]) {
			p->cost[_F_NT] = c + 0;
			p->rule._F = 3;
			_closure_F(a, c + 0);
		}
		break;
	case 69: /* INDIRI */
		_label(LEFT_CHILD(a));
		/* stmt: INDIRI(P) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_P_NT] + 0;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 3;
		}
		/* I: INDIRI(P) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_P_NT] + 0;
		if (c + 0 < p->cost[_I_NT]) {
			p->cost[_I_NT] = c + 0;
			p->rule._I = 3;
			_closure_I(a, c + 0);
		}
		break;
	case 70: /* INDIRU */
		_label(LEFT_CHILD(a));
		/* stmt: INDIRU(P) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_P_NT] + 0;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 4;
		}
		/* U: INDIRU(P) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_P_NT] + 0;
		if (c + 0 < p->cost[_U_NT]) {
			p->cost[_U_NT] = c + 0;
			p->rule._U = 3;
			_closure_U(a, c + 0);
		}
		break;
	case 71: /* INDIRP */
		_label(LEFT_CHILD(a));
		/* stmt: INDIRP(P) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_P_NT] + 0;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 5;
		}
		/* P: INDIRP(P) */