summaryrefslogtreecommitdiff
path: root/build/release-linux-x86_64/tools/rcc/dagcheck.c
diff options
context:
space:
mode:
Diffstat (limited to 'build/release-linux-x86_64/tools/rcc/dagcheck.c')
-rw-r--r--build/release-linux-x86_64/tools/rcc/dagcheck.c2086
1 files changed, 2086 insertions, 0 deletions
diff --git a/build/release-linux-x86_64/tools/rcc/dagcheck.c b/build/release-linux-x86_64/tools/rcc/dagcheck.c
new file mode 100644
index 0000000..30993b4
--- /dev/null
+++ b/build/release-linux-x86_64/tools/rcc/dagcheck.c
@@ -0,0 +1,2086 @@
+#include "c.h"
+typedef Node NODEPTR_TYPE;
+#define OP_LABEL(p) (specific((p)->op))
+#define LEFT_CHILD(p) ((p)->kids[0])
+#define RIGHT_CHILD(p) ((p)->kids[1])
+#define STATE_LABEL(p) ((p)->x.state)
+#define PANIC error
+/*
+generated at Sun Feb 16 17:43:19 2014
+by lburg.c - faked rcsid
+*/
+static void _kids(NODEPTR_TYPE, int, NODEPTR_TYPE[]);
+static void _label(NODEPTR_TYPE);
+static int _rule(void*, int);
+
+#define _stmt_NT 1
+#define _P_NT 2
+#define _V_NT 3
+#define _bogus_NT 4
+#define _I_NT 5
+#define _U_NT 6
+#define _F_NT 7
+#define _B_NT 8
+
+static char *_ntname[] = {
+ 0,
+ "stmt",
+ "P",
+ "V",
+ "bogus",
+ "I",
+ "U",
+ "F",
+ "B",
+ 0
+};
+
+struct _state {
+ short cost[9];
+ struct {
+ unsigned int _stmt:4;
+ unsigned int _P:4;
+ unsigned int _V:6;
+ unsigned int _bogus:3;
+ unsigned int _I:5;
+ unsigned int _U:5;
+ unsigned int _F:4;
+ unsigned int _B:2;
+ } rule;
+};
+
+static short _nts_0[] = { _P_NT, 0 };
+static short _nts_1[] = { _V_NT, 0 };
+static short _nts_2[] = { _I_NT, 0 };
+static short _nts_3[] = { _U_NT, 0 };
+static short _nts_4[] = { _F_NT, 0 };
+static short _nts_5[] = { _B_NT, 0 };
+static short _nts_6[] = { _bogus_NT, 0 };
+static short _nts_7[] = { 0 };
+static short _nts_8[] = { _P_NT, _B_NT, 0 };
+static short _nts_9[] = { _P_NT, _F_NT, 0 };
+static short _nts_10[] = { _P_NT, _I_NT, 0 };
+static short _nts_11[] = { _P_NT, _U_NT, 0 };
+static short _nts_12[] = { _P_NT, _P_NT, 0 };
+static short _nts_13[] = { _F_NT, _F_NT, 0 };
+static short _nts_14[] = { _I_NT, _I_NT, 0 };
+static short _nts_15[] = { _I_NT, _P_NT, 0 };
+static short _nts_16[] = { _U_NT, _P_NT, 0 };
+static short _nts_17[] = { _U_NT, _U_NT, 0 };
+static short _nts_18[] = { _U_NT, _I_NT, 0 };
+
+static short *_nts[] = {
+ 0, /* 0 */
+ _nts_0, /* 1 */
+ _nts_0, /* 2 */
+ _nts_0, /* 3 */
+ _nts_0, /* 4 */
+ _nts_0, /* 5 */
+ _nts_0, /* 6 */
+ _nts_0, /* 7 */
+ _nts_0, /* 8 */
+ _nts_0, /* 9 */
+ _nts_1, /* 10 */
+ _nts_2, /* 11 */
+ _nts_3, /* 12 */
+ _nts_0, /* 13 */
+ _nts_4, /* 14 */
+ _nts_5, /* 15 */
+ _nts_1, /* 16 */
+ _nts_6, /* 17 */
+ _nts_6, /* 18 */
+ _nts_6, /* 19 */
+ _nts_6, /* 20 */
+ _nts_6, /* 21 */
+ _nts_6, /* 22 */
+ _nts_7, /* 23 */
+ _nts_7, /* 24 */
+ _nts_7, /* 25 */
+ _nts_7, /* 26 */
+ _nts_5, /* 27 */
+ _nts_4, /* 28 */
+ _nts_2, /* 29 */
+ _nts_3, /* 30 */
+ _nts_0, /* 31 */
+ _nts_8, /* 32 */
+ _nts_9, /* 33 */
+ _nts_10, /* 34 */
+ _nts_11, /* 35 */
+ _nts_12, /* 36 */
+ _nts_0, /* 37 */
+ _nts_0, /* 38 */
+ _nts_0, /* 39 */
+ _nts_0, /* 40 */
+ _nts_0, /* 41 */
+ _nts_2, /* 42 */
+ _nts_3, /* 43 */
+ _nts_4, /* 44 */
+ _nts_2, /* 45 */
+ _nts_3, /* 46 */
+ _nts_0, /* 47 */
+ _nts_2, /* 48 */
+ _nts_4, /* 49 */
+ _nts_3, /* 50 */
+ _nts_0, /* 51 */
+ _nts_4, /* 52 */
+ _nts_2, /* 53 */
+ _nts_12, /* 54 */
+ _nts_0, /* 55 */
+ _nts_0, /* 56 */
+ _nts_0, /* 57 */
+ _nts_0, /* 58 */
+ _nts_0, /* 59 */
+ _nts_4, /* 60 */
+ _nts_2, /* 61 */
+ _nts_3, /* 62 */
+ _nts_0, /* 63 */
+ _nts_7, /* 64 */
+ _nts_7, /* 65 */
+ _nts_7, /* 66 */
+ _nts_7, /* 67 */
+ _nts_13, /* 68 */
+ _nts_14, /* 69 */
+ _nts_10, /* 70 */
+ _nts_15, /* 71 */
+ _nts_16, /* 72 */
+ _nts_11, /* 73 */
+ _nts_17, /* 74 */
+ _nts_13, /* 75 */
+ _nts_14, /* 76 */
+ _nts_10, /* 77 */
+ _nts_11, /* 78 */
+ _nts_17, /* 79 */
+ _nts_14, /* 80 */
+ _nts_18, /* 81 */
+ _nts_14, /* 82 */
+ _nts_17, /* 83 */
+ _nts_14, /* 84 */
+ _nts_18, /* 85 */
+ _nts_17, /* 86 */
+ _nts_14, /* 87 */
+ _nts_3, /* 88 */
+ _nts_2, /* 89 */
+ _nts_14, /* 90 */
+ _nts_17, /* 91 */
+ _nts_17, /* 92 */
+ _nts_14, /* 93 */
+ _nts_13, /* 94 */
+ _nts_14, /* 95 */
+ _nts_17, /* 96 */
+ _nts_13, /* 97 */
+ _nts_14, /* 98 */
+ _nts_17, /* 99 */
+ _nts_13, /* 100 */
+ _nts_14, /* 101 */
+ _nts_17, /* 102 */
+ _nts_13, /* 103 */
+ _nts_14, /* 104 */
+ _nts_17, /* 105 */
+ _nts_13, /* 106 */
+ _nts_14, /* 107 */
+ _nts_17, /* 108 */
+ _nts_13, /* 109 */
+ _nts_14, /* 110 */
+ _nts_17, /* 111 */
+ _nts_13, /* 112 */
+ _nts_14, /* 113 */
+ _nts_17, /* 114 */
+ _nts_13, /* 115 */
+ _nts_14, /* 116 */
+ _nts_17, /* 117 */
+ _nts_0, /* 118 */
+ _nts_7, /* 119 */
+};
+
+static char *_templates[] = {
+/* 0 */ 0,
+/* 1 */ "", /* stmt: INDIRB(P) */
+/* 2 */ "", /* stmt: INDIRF(P) */
+/* 3 */ "", /* stmt: INDIRI(P) */
+/* 4 */ "", /* stmt: INDIRU(P) */
+/* 5 */ "", /* stmt: INDIRP(P) */
+/* 6 */ "", /* stmt: CALLF(P) */
+/* 7 */ "", /* stmt: CALLI(P) */
+/* 8 */ "", /* stmt: CALLU(P) */
+/* 9 */ "", /* stmt: CALLP(P) */
+/* 10 */ "", /* stmt: V */
+/* 11 */ "", /* bogus: I */
+/* 12 */ "", /* bogus: U */
+/* 13 */ "", /* bogus: P */
+/* 14 */ "", /* bogus: F */
+/* 15 */ "", /* bogus: B */
+/* 16 */ "", /* bogus: V */
+/* 17 */ "", /* I: bogus */
+/* 18 */ "", /* U: bogus */
+/* 19 */ "", /* P: bogus */
+/* 20 */ "", /* F: bogus */
+/* 21 */ "", /* B: bogus */
+/* 22 */ "", /* V: bogus */
+/* 23 */ "", /* F: CNSTF */
+/* 24 */ "", /* I: CNSTI */
+/* 25 */ "", /* P: CNSTP */
+/* 26 */ "", /* U: CNSTU */
+/* 27 */ "", /* V: ARGB(B) */
+/* 28 */ "", /* V: ARGF(F) */
+/* 29 */ "", /* V: ARGI(I) */
+/* 30 */ "", /* V: ARGU(U) */
+/* 31 */ "", /* V: ARGP(P) */
+/* 32 */ "", /* V: ASGNB(P,B) */
+/* 33 */ "", /* V: ASGNF(P,F) */
+/* 34 */ "", /* V: ASGNI(P,I) */
+/* 35 */ "", /* V: ASGNU(P,U) */
+/* 36 */ "", /* V: ASGNP(P,P) */
+/* 37 */ "", /* B: INDIRB(P) */
+/* 38 */ "", /* F: INDIRF(P) */
+/* 39 */ "", /* I: INDIRI(P) */
+/* 40 */ "", /* U: INDIRU(P) */
+/* 41 */ "", /* P: INDIRP(P) */
+/* 42 */ "", /* I: CVII(I) */
+/* 43 */ "", /* I: CVUI(U) */
+/* 44 */ "", /* I: CVFI(F) */
+/* 45 */ "", /* U: CVIU(I) */
+/* 46 */ "", /* U: CVUU(U) */
+/* 47 */ "", /* U: CVPU(P) */
+/* 48 */ "", /* F: CVIF(I) */
+/* 49 */ "", /* F: CVFF(F) */
+/* 50 */ "", /* P: CVUP(U) */
+/* 51 */ "", /* P: CVPP(P) */
+/* 52 */ "", /* F: NEGF(F) */
+/* 53 */ "", /* I: NEGI(I) */
+/* 54 */ "", /* V: CALLB(P,P) */
+/* 55 */ "", /* F: CALLF(P) */
+/* 56 */ "", /* I: CALLI(P) */
+/* 57 */ "", /* U: CALLU(P) */
+/* 58 */ "", /* P: CALLP(P) */
+/* 59 */ "", /* V: CALLV(P) */
+/* 60 */ "", /* V: RETF(F) */
+/* 61 */ "", /* V: RETI(I) */
+/* 62 */ "", /* V: RETU(U) */
+/* 63 */ "", /* V: RETP(P) */
+/* 64 */ "", /* V: RETV */
+/* 65 */ "", /* P: ADDRGP */
+/* 66 */ "", /* P: ADDRFP */
+/* 67 */ "", /* P: ADDRLP */
+/* 68 */ "", /* F: ADDF(F,F) */
+/* 69 */ "", /* I: ADDI(I,I) */
+/* 70 */ "", /* P: ADDP(P,I) */
+/* 71 */ "", /* P: ADDP(I,P) */
+/* 72 */ "", /* P: ADDP(U,P) */
+/* 73 */ "", /* P: ADDP(P,U) */
+/* 74 */ "", /* U: ADDU(U,U) */
+/* 75 */ "", /* F: SUBF(F,F) */
+/* 76 */ "", /* I: SUBI(I,I) */
+/* 77 */ "", /* P: SUBP(P,I) */
+/* 78 */ "", /* P: SUBP(P,U) */
+/* 79 */ "", /* U: SUBU(U,U) */
+/* 80 */ "", /* I: LSHI(I,I) */
+/* 81 */ "", /* U: LSHU(U,I) */
+/* 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 char _isinstruction[] = {
+/* 0 */ 0,
+/* 1 */ 0, /* */
+/* 2 */ 0, /* */
+/* 3 */ 0, /* */
+/* 4 */ 0, /* */
+/* 5 */ 0, /* */
+/* 6 */ 0, /* */
+/* 7 */ 0, /* */
+/* 8 */ 0, /* */
+/* 9 */ 0, /* */
+/* 10 */ 0, /* */
+/* 11 */ 0, /* */
+/* 12 */ 0, /* */
+/* 13 */ 0, /* */
+/* 14 */ 0, /* */
+/* 15 */ 0, /* */
+/* 16 */ 0, /* */
+/* 17 */ 0, /* */
+/* 18 */ 0, /* */
+/* 19 */ 0, /* */
+/* 20 */ 0, /* */
+/* 21 */ 0, /* */
+/* 22 */ 0, /* */
+/* 23 */ 0, /* */
+/* 24 */ 0, /* */
+/* 25 */ 0, /* */
+/* 26 */ 0, /* */
+/* 27 */ 0, /* */
+/* 28 */ 0, /* */
+/* 29 */ 0, /* */
+/* 30 */ 0, /* */
+/* 31 */ 0, /* */
+/* 32 */ 0, /* */
+/* 33 */ 0, /* */
+/* 34 */ 0, /* */
+/* 35 */ 0, /* */
+/* 36 */ 0, /* */
+/* 37 */ 0, /* */
+/* 38 */ 0, /* */
+/* 39 */ 0, /* */
+/* 40 */ 0, /* */
+/* 41 */ 0, /* */
+/* 42 */ 0, /* */
+/* 43 */ 0, /* */
+/* 44 */ 0, /* */
+/* 45 */ 0, /* */
+/* 46 */ 0, /* */
+/* 47 */ 0, /* */
+/* 48 */ 0, /* */
+/* 49 */ 0, /* */
+/* 50 */ 0, /* */
+/* 51 */ 0, /* */
+/* 52 */ 0, /* */
+/* 53 */ 0, /* */
+/* 54 */ 0, /* */
+/* 55 */ 0, /* */
+/* 56 */ 0, /* */
+/* 57 */ 0, /* */
+/* 58 */ 0, /* */
+/* 59 */ 0, /* */
+/* 60 */ 0, /* */
+/* 61 */ 0, /* */
+/* 62 */ 0, /* */
+/* 63 */ 0, /* */
+/* 64 */ 0, /* */
+/* 65 */ 0, /* */
+/* 66 */ 0, /* */
+/* 67 */ 0, /* */
+/* 68 */ 0, /* */
+/* 69 */ 0, /* */
+/* 70 */ 0, /* */
+/* 71 */ 0, /* */
+/* 72 */ 0, /* */
+/* 73 */ 0, /* */
+/* 74 */ 0, /* */
+/* 75 */ 0, /* */
+/* 76 */ 0, /* */
+/* 77 */ 0, /* */
+/* 78 */ 0, /* */
+/* 79 */ 0, /* */
+/* 80 */ 0, /* */
+/* 81 */ 0, /* */
+/* 82 */ 0, /* */
+/* 83 */ 0, /* */
+/* 84 */ 0, /* */
+/* 85 */ 0, /* */
+/* 86 */ 0, /* */
+/* 87 */ 0, /* */
+/* 88 */ 0, /* */
+/* 89 */ 0, /* */
+/* 90 */ 0, /* */
+/* 91 */ 0, /* */
+/* 92 */ 0, /* */
+/* 93 */ 0, /* */
+/* 94 */ 0, /* */
+/* 95 */ 0, /* */
+/* 96 */ 0, /* */
+/* 97 */ 0, /* */
+/* 98 */ 0, /* */
+/* 99 */ 0, /* */
+/* 100 */ 0, /* */
+/* 101 */ 0, /* */
+/* 102 */ 0, /* */
+/* 103 */ 0, /* */
+/* 104 */ 0, /* */
+/* 105 */ 0, /* */
+/* 106 */ 0, /* */
+/* 107 */ 0, /* */
+/* 108 */ 0, /* */
+/* 109 */ 0, /* */
+/* 110 */ 0, /* */
+/* 111 */ 0, /* */
+/* 112 */ 0, /* */
+/* 113 */ 0, /* */
+/* 114 */ 0, /* */
+/* 115 */ 0, /* */
+/* 116 */ 0, /* */
+/* 117 */ 0, /* */
+/* 118 */ 0, /* */
+/* 119 */ 0, /* */
+};
+
+static char *_string[] = {
+/* 0 */ 0,
+/* 1 */ "stmt: INDIRB(P)",
+/* 2 */ "stmt: INDIRF(P)",
+/* 3 */ "stmt: INDIRI(P)",
+/* 4 */ "stmt: INDIRU(P)",
+/* 5 */ "stmt: INDIRP(P)",
+/* 6 */ "stmt: CALLF(P)",
+/* 7 */ "stmt: CALLI(P)",
+/* 8 */ "stmt: CALLU(P)",
+/* 9 */ "stmt: CALLP(P)",
+/* 10 */ "stmt: V",
+/* 11 */ "bogus: I",
+/* 12 */ "bogus: U",
+/* 13 */ "bogus: P",
+/* 14 */ "bogus: F",
+/* 15 */ "bogus: B",
+/* 16 */ "bogus: V",
+/* 17 */ "I: bogus",
+/* 18 */ "U: bogus",
+/* 19 */ "P: bogus",
+/* 20 */ "F: bogus",
+/* 21 */ "B: bogus",
+/* 22 */ "V: bogus",
+/* 23 */ "F: CNSTF",
+/* 24 */ "I: CNSTI",
+/* 25 */ "P: CNSTP",
+/* 26 */ "U: CNSTU",
+/* 27 */ "V: ARGB(B)",
+/* 28 */ "V: ARGF(F)",
+/* 29 */ "V: ARGI(I)",
+/* 30 */ "V: ARGU(U)",
+/* 31 */ "V: ARGP(P)",
+/* 32 */ "V: ASGNB(P,B)",
+/* 33 */ "V: ASGNF(P,F)",
+/* 34 */ "V: ASGNI(P,I)",
+/* 35 */ "V: ASGNU(P,U)",
+/* 36 */ "V: ASGNP(P,P)",
+/* 37 */ "B: INDIRB(P)",
+/* 38 */ "F: INDIRF(P)",
+/* 39 */ "I: INDIRI(P)",
+/* 40 */ "U: INDIRU(P)",
+/* 41 */ "P: INDIRP(P)",
+/* 42 */ "I: CVII(I)",
+/* 43 */ "I: CVUI(U)",
+/* 44 */ "I: CVFI(F)",
+/* 45 */ "U: CVIU(I)",
+/* 46 */ "U: CVUU(U)",
+/* 47 */ "U: CVPU(P)",
+/* 48 */ "F: CVIF(I)",
+/* 49 */ "F: CVFF(F)",
+/* 50 */ "P: CVUP(U)",
+/* 51 */ "P: CVPP(P)",
+/* 52 */ "F: NEGF(F)",
+/* 53 */ "I: NEGI(I)",
+/* 54 */ "V: CALLB(P,P)",
+/* 55 */ "F: CALLF(P)",
+/* 56 */ "I: CALLI(P)",
+/* 57 */ "U: CALLU(P)",
+/* 58 */ "P: CALLP(P)",
+/* 59 */ "V: CALLV(P)",
+/* 60 */ "V: RETF(F)",
+/* 61 */ "V: RETI(I)",
+/* 62 */ "V: RETU(U)",
+/* 63 */ "V: RETP(P)",
+/* 64 */ "V: RETV",
+/* 65 */ "P: ADDRGP",
+/* 66 */ "P: ADDRFP",
+/* 67 */ "P: ADDRLP",
+/* 68 */ "F: ADDF(F,F)",
+/* 69 */ "I: ADDI(I,I)",
+/* 70 */ "P: ADDP(P,I)",
+/* 71 */ "P: ADDP(I,P)",
+/* 72 */ "P: ADDP(U,P)",
+/* 73 */ "P: ADDP(P,U)",
+/* 74 */ "U: ADDU(U,U)",
+/* 75 */ "F: SUBF(F,F)",
+/* 76 */ "I: SUBI(I,I)",
+/* 77 */ "P: SUBP(P,I)",
+/* 78 */ "P: SUBP(P,U)",
+/* 79 */ "U: SUBU(U,U)",
+/* 80 */ "I: LSHI(I,I)",
+/* 81 */ "U: LSHU(U,I)",
+/* 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) */
+ c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_P_NT] + 0;
+ if (c + 0 < p->cost[_P_NT]) {
+ p->cost[_P_NT] = c + 0;
+ p->rule._P = 3;
+ _closure_P(a, c + 0);
+ }
+ break;
+ case 73: /* INDIRB */
+ _label(LEFT_CHILD(a));
+ /* stmt: INDIRB(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 = 1;
+ }
+ /* B: INDIRB(P) */
+ c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_P_NT] + 0;
+ if (c + 0 < p->cost[_B_NT]) {
+ p->cost[_B_NT] = c + 0;
+ p->rule._B = 2;
+ _closure_B(a, c + 0);
+ }
+ break;
+ case 113: /* CVFF */
+ _label(LEFT_CHILD(a));
+ /* F: CVFF(F) */
+ c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_F_NT] + 0;
+ if (c + 0 < p->cost[_F_NT]) {
+ p->cost[_F_NT] = c + 0;
+ p->rule._F = 5;
+ _closure_F(a, c + 0);
+ }
+ break;
+ case 117: /* CVFI */
+ _label(LEFT_CHILD(a));
+ /* I: CVFI(F) */
+ c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_F_NT] + 0;
+ if (c + 0 < p->cost[_I_NT]) {
+ p->cost[_I_NT] = c + 0;
+ p->rule._I = 6;
+ _closure_I(a, c + 0);
+ }
+ break;
+ case 129: /* CVIF */
+ _label(LEFT_CHILD(a));
+ /* F: CVIF(I) */
+ c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_I_NT] + 0;
+ if (c + 0 < p->cost[_F_NT]) {
+ p->cost[_F_NT] = c + 0;
+ p->rule._F = 4;
+ _closure_F(a, c + 0);
+ }
+ break;
+ case 133: /* CVII */
+ _label(LEFT_CHILD(a));
+ /* I: CVII(I) */
+ c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_I_NT] + 0;
+ if (c + 0 < p->cost[_I_NT]) {
+ p->cost[_I_NT] = c + 0;
+ p->rule._I = 4;
+ _closure_I(a, c + 0);
+ }
+ break;
+ case 134: /* CVIU */
+ _label(LEFT_CHILD(a));
+ /* U: CVIU(I) */
+ c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_I_NT] + 0;
+ if (c + 0 < p->cost[_U_NT]) {
+ p->cost[_U_NT] = c + 0;
+ p->rule._U = 4;
+ _closure_U(a, c + 0);
+ }
+ break;
+ case 150: /* CVPU */
+ _label(LEFT_CHILD(a));
+ /* U: CVPU(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 = 6;
+ _closure_U(a, c + 0);
+ }
+ break;
+ case 151: /* CVPP */
+ _label(LEFT_CHILD(a));
+ /* P: CVPP(P) */
+ c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_P_NT] + 0;
+ if (c + 0 < p->cost[_P_NT]) {
+ p->cost[_P_NT] = c + 0;
+ p->rule._P = 5;
+ _closure_P(a, c + 0);
+ }
+ break;
+ case 181: /* CVUI */
+ _label(LEFT_CHILD(a));
+ /* I: CVUI(U) */
+ c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_U_NT] + 0;
+ if (c + 0 < p->cost[_I_NT]) {
+ p->cost[_I_NT] = c + 0;
+ p->rule._I = 5;
+ _closure_I(a, c + 0);
+ }
+ break;
+ case 182: /* CVUU */
+ _label(LEFT_CHILD(a));
+ /* U: CVUU(U) */
+ c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_U_NT] + 0;
+ if (c + 0 < p->cost[_U_NT]) {
+ p->cost[_U_NT] = c + 0;
+ p->rule._U = 5;
+ _closure_U(a, c + 0);
+ }
+ break;
+ case 183: /* CVUP */
+ _label(LEFT_CHILD(a));
+ /* P: CVUP(U) */
+ c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_U_NT] + 0;
+ if (c + 0 < p->cost[_P_NT]) {
+ p->cost[_P_NT] = c + 0;
+ p->rule._P = 4;
+ _closure_P(a, c + 0);
+ }
+ break;
+ case 193: /* NEGF */
+ _label(LEFT_CHILD(a));
+ /* F: NEGF(F) */
+ c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_F_NT] + 0;
+ if (c + 0 < p->cost[_F_NT]) {
+ p->cost[_F_NT] = c + 0;
+ p->rule._F = 6;
+ _closure_F(a, c + 0);
+ }
+ break;
+ case 197: /* NEGI */
+ _label(LEFT_CHILD(a));
+ /* I: NEGI(I) */
+ c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_I_NT] + 0;
+ if (c + 0 < p->cost[_I_NT]) {
+ p->cost[_I_NT] = c + 0;
+ p->rule._I = 7;
+ _closure_I(a, c + 0);
+ }
+ break;
+ case 209: /* CALLF */
+ _label(LEFT_CHILD(a));
+ /* stmt: CALLF(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 = 6;
+ }
+ /* F: CALLF(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 = 7;
+ _closure_F(a, c + 0);
+ }
+ break;
+ case 213: /* CALLI */
+ _label(LEFT_CHILD(a));
+ /* stmt: CALLI(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 = 7;
+ }
+ /* I: CALLI(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 = 8;
+ _closure_I(a, c + 0);
+ }
+ break;
+ case 214: /* CALLU */
+ _label(LEFT_CHILD(a));
+ /* stmt: CALLU(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 = 8;
+ }
+ /* U: CALLU(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 = 7;
+ _closure_U(a, c + 0);
+ }
+ break;
+ case 215: /* CALLP */
+ _label(LEFT_CHILD(a));
+ /* stmt: CALLP(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 = 9;
+ }
+ /* P: CALLP(P) */
+ c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_P_NT] + 0;
+ if (c + 0 < p->cost[_P_NT]) {
+ p->cost[_P_NT] = c + 0;
+ p->rule._P = 6;
+ _closure_P(a, c + 0);
+ }
+ break;
+ case 216: /* CALLV */
+ _label(LEFT_CHILD(a));
+ /* V: CALLV(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 = 13;
+ _closure_V(a, c + 0);
+ }
+ break;
+ case 217: /* CALLB */
+ _label(LEFT_CHILD(a));
+ _label(RIGHT_CHILD(a));
+ /* V: CALLB(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 = 12;
+ _closure_V(a, c + 0);
+ }
+ break;
+ case 241: /* RETF */
+ _label(LEFT_CHILD(a));
+ /* V: RETF(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 = 14;
+ _closure_V(a, c + 0);
+ }
+ break;
+ case 245: /* RETI */
+ _label(LEFT_CHILD(a));
+ /* V: RETI(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 = 15;
+ _closure_V(a, c + 0);
+ }
+ break;
+ case 246: /* RETU */
+ _label(LEFT_CHILD(a));
+ /* V: RETU(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 = 16;
+ _closure_V(a, c + 0);
+ }
+ break;
+ case 247: /* RETP */
+ _label(LEFT_CHILD(a));
+ /* V: RETP(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 = 17;
+ _closure_V(a, c + 0);
+ }
+ break;
+ case 248: /* RETV */
+ /* V: RETV */
+ if (0 + 0 < p->cost[_V_NT]) {
+ p->cost[_V_NT] = 0 + 0;
+ p->rule._V = 18;
+ _closure_V(a, 0 + 0);
+ }
+ break;
+ case 263: /* ADDRGP */
+ /* P: ADDRGP */
+ if (0 + 0 < p->cost[_P_NT]) {
+ p->cost[_P_NT] = 0 + 0;
+ p->rule._P = 7;
+ _closure_P(a, 0 + 0);
+ }
+ break;
+ case 279: /* ADDRFP */
+ /* P: ADDRFP */
+ if (0 + 0 < p->cost[_P_NT]) {
+ p->cost[_P_NT] = 0 + 0;
+ p->rule._P = 8;
+ _closure_P(a, 0 + 0);
+ }
+ break;
+ case 295: /* ADDRLP */
+ /* P: ADDRLP */
+ if (0 + 0 < p->cost[_P_NT]) {
+ p->cost[_P_NT] = 0 + 0;
+ p->rule._P = 9;
+ _closure_P(a, 0 + 0);
+ }
+ break;
+ case 305: /* ADDF */
+ _label(LEFT_CHILD(a));
+ _label(RIGHT_CHILD(a));
+ /* F: ADDF(F,F) */
+ c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_F_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_F_NT] + 0;
+ if (c + 0 < p->cost[_F_NT]) {
+ p->cost[_F_NT] = c + 0;
+ p->rule._F = 8;
+ _closure_F(a, c + 0);
+ }
+ break;
+ case 309: /* ADDI */
+ _label(LEFT_CHILD(a));
+ _label(RIGHT_CHILD(a));
+ /* I: ADDI(I,I) */
+ c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_I_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_I_NT] + 0;
+ if (c + 0 < p->cost[_I_NT]) {
+ p->cost[_I_NT] = c + 0;
+ p->rule._I = 9;
+ _closure_I(a, c + 0);
+ }
+ break;
+ case 310: /* ADDU */
+ _label(LEFT_CHILD(a));
+ _label(RIGHT_CHILD(a));
+ /* U: ADDU(U,U) */
+ c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_U_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_U_NT] + 0;
+ if (c + 0 < p->cost[_U_NT]) {
+ p->cost[_U_NT] = c + 0;
+ p->rule._U = 8;
+ _closure_U(a, c + 0);
+ }
+ break;
+ case 311: /* ADDP */
+ _label(LEFT_CHILD(a));
+ _label(RIGHT_CHILD(a));
+ /* P: ADDP(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[_P_NT]) {
+ p->cost[_P_NT] = c + 0;
+ p->rule._P = 10;
+ _closure_P(a, c + 0);
+ }
+ /* P: ADDP(I,P) */
+ c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_I_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_P_NT] + 0;
+ if (c + 0 < p->cost[_P_NT]) {
+ p->cost[_P_NT] = c + 0;
+ p->rule._P = 11;
+ _closure_P(a, c + 0);
+ }
+ /* P: ADDP(U,P) */
+ c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_U_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_P_NT] + 0;
+ if (c + 0 < p->cost[_P_NT]) {
+ p->cost[_P_NT] = c + 0;
+ p->rule._P = 12;
+ _closure_P(a, c + 0);
+ }
+ /* P: ADDP(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[_P_NT]) {
+ p->cost[_P_NT] = c + 0;
+ p->rule._P = 13;
+ _closure_P(a, c + 0);
+ }
+ break;
+ case 321: /* SUBF */
+ _label(LEFT_CHILD(a));
+ _label(RIGHT_CHILD(a));
+ /* F: SUBF(F,F) */
+ c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_F_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_F_NT] + 0;
+ if (c + 0 < p->cost[_F_NT]) {
+ p->cost[_F_NT] = c + 0;
+ p->rule._F = 9;
+ _closure_F(a, c + 0);
+ }
+ break;
+ case 325: /* SUBI */
+ _label(LEFT_CHILD(a));
+ _label(RIGHT_CHILD(a));
+ /* I: SUBI(I,I) */
+ c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_I_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_I_NT] + 0;
+ if (c + 0 < p->cost[_I_NT]) {
+ p->cost[_I_NT] = c + 0;
+ p->rule._I = 10;
+ _closure_I(a, c + 0);
+ }
+ break;
+ case 326: /* SUBU */
+ _label(LEFT_CHILD(a));
+ _label(RIGHT_CHILD(a));
+ /* U: SUBU(U,U) */
+ c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_U_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_U_NT] + 0;
+ if (c + 0 < p->cost[_U_NT]) {
+ p->cost[_U_NT] = c + 0;
+ p->rule._U = 9;
+ _closure_U(a, c + 0);
+ }
+ break;
+ case 327: /* SUBP */
+ _label(LEFT_CHILD(a));
+ _label(RIGHT_CHILD(a));
+ /* P: SUBP(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[_P_NT]) {
+ p->cost[_P_NT] = c + 0;
+ p->rule._P = 14;
+ _closure_P(a, c + 0);
+ }
+ /* P: SUBP(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[_P_NT]) {
+ p->cost[_P_NT] = c + 0;
+ p->rule._P = 15;
+ _closure_P(a, c + 0);
+ }
+ break;
+ case 341: /* LSHI */
+ _label(LEFT_CHILD(a));
+ _label(RIGHT_CHILD(a));
+ /* I: LSHI(I,I) */
+ c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_I_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_I_NT] + 0;
+ if (c + 0 < p->cost[_I_NT]) {
+ p->cost[_I_NT] = c + 0;
+ p->rule._I = 11;
+ _closure_I(a, c + 0);
+ }
+ break;
+ case 342: /* LSHU */
+ _label(LEFT_CHILD(a));
+ _label(RIGHT_CHILD(a));
+ /* U: LSHU(U,I) */
+ c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_U_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_I_NT] + 0;
+ if (c + 0 < p->cost[_U_NT]) {
+ p->cost[_U_NT] = c + 0;
+ p->rule._U = 10;
+ _closure_U(a, c + 0);
+ }
+ break;
+ case 357: /* MODI */
+ _label(LEFT_CHILD(a));
+ _label(RIGHT_CHILD(a));
+ /* I: MODI(I,I) */
+ c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_I_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_I_NT] + 0;
+ if (c + 0 < p->cost[_I_NT]) {
+ p->cost[_I_NT] = c + 0;
+ p->rule._I = 12;
+ _closure_I(a, c + 0);
+ }
+ break;
+ case 358: /* MODU */
+ _label(LEFT_CHILD(a));
+ _label(RIGHT_CHILD(a));
+ /* U: MODU(U,U) */
+ c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_U_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_U_NT] + 0;
+ if (c + 0 < p->cost[_U_NT]) {
+ p->cost[_U_NT] = c + 0;
+ p->rule._U = 11;
+ _closure_U(a, c + 0);
+ }
+ break;
+ case 373: /* RSHI */
+ _label(LEFT_CHILD(a));
+ _label(RIGHT_CHILD(a));
+ /* I: RSHI(I,I) */
+ c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_I_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_I_NT] + 0;
+ if (c + 0 < p->cost[_I_NT]) {
+ p->cost[_I_NT] = c + 0;
+ p->rule._I = 13;
+ _closure_I(a, c + 0);
+ }
+ break;
+ case 374: /* RSHU */
+ _label(LEFT_CHILD(a));
+ _label(RIGHT_CHILD(a));
+ /* U: RSHU(U,I) */
+ c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_U_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_I_NT] + 0;
+ if (c + 0 < p->cost[_U_NT]) {
+ p->cost[_U_NT] = c + 0;
+ p->rule._U = 12;
+ _closure_U(a, c + 0);
+ }
+ break;
+ case 389: /* BANDI */
+ _label(LEFT_CHILD(a));
+ _label(RIGHT_CHILD(a));
+ /* I: BANDI(I,I) */
+ c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_I_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_I_NT] + 0;
+ if (c + 0 < p->cost[_I_NT]) {
+ p->cost[_I_NT] = c + 0;
+ p->rule._I = 14;
+ _closure_I(a, c + 0);
+ }
+ break;
+ case 390: /* BANDU */
+ _label(LEFT_CHILD(a));
+ _label(RIGHT_CHILD(a));
+ /* U: BANDU(U,U) */
+ c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_U_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_U_NT] + 0;
+ if (c + 0 < p->cost[_U_NT]) {
+ p->cost[_U_NT] = c + 0;
+ p->rule._U = 13;
+ _closure_U(a, c + 0);
+ }
+ break;
+ case 405: /* BCOMI */
+ _label(LEFT_CHILD(a));
+ /* I: BCOMI(I) */
+ c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_I_NT] + 0;
+ if (c + 0 < p->cost[_I_NT]) {
+ p->cost[_I_NT] = c + 0;
+ p->rule._I = 15;
+ _closure_I(a, c + 0);
+ }
+ break;
+ case 406: /* BCOMU */
+ _label(LEFT_CHILD(a));
+ /* U: BCOMU(U) */
+ c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_U_NT] + 0;
+ if (c + 0 < p->cost[_U_NT]) {
+ p->cost[_U_NT] = c + 0;
+ p->rule._U = 14;
+ _closure_U(a, c + 0);
+ }
+ break;
+ case 421: /* BORI */
+ _label(LEFT_CHILD(a));
+ _label(RIGHT_CHILD(a));
+ /* I: BORI(I,I) */
+ c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_I_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_I_NT] + 0;
+ if (c + 0 < p->cost[_I_NT]) {
+ p->cost[_I_NT] = c + 0;
+ p->rule._I = 16;
+ _closure_I(a, c + 0);
+ }
+ break;
+ case 422: /* BORU */
+ _label(LEFT_CHILD(a));
+ _label(RIGHT_CHILD(a));
+ /* U: BORU(U,U) */
+ c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_U_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_U_NT] + 0;
+ if (c + 0 < p->cost[_U_NT]) {
+ p->cost[_U_NT] = c + 0;
+ p->rule._U = 15;
+ _closure_U(a, c + 0);
+ }
+ break;
+ case 437: /* BXORI */
+ _label(LEFT_CHILD(a));
+ _label(RIGHT_CHILD(a));
+ /* I: BXORI(I,I) */
+ c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_I_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_I_NT] + 0;
+ if (c + 0 < p->cost[_I_NT]) {
+ p->cost[_I_NT] = c + 0;
+ p->rule._I = 17;
+ _closure_I(a, c + 0);
+ }
+ break;
+ case 438: /* BXORU */
+ _label(LEFT_CHILD(a));
+ _label(RIGHT_CHILD(a));
+ /* U: BXORU(U,U) */
+ c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_U_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_U_NT] + 0;
+ if (c + 0 < p->cost[_U_NT]) {
+ p->cost[_U_NT] = c + 0;
+ p->rule._U = 16;
+ _closure_U(a, c + 0);
+ }
+ break;
+ case 449: /* DIVF */
+ _label(LEFT_CHILD(a));
+ _label(RIGHT_CHILD(a));
+ /* F: DIVF(F,F) */
+ c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_F_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_F_NT] + 0;
+ if (c + 0 < p->cost[_F_NT]) {
+ p->cost[_F_NT] = c + 0;
+ p->rule._F = 10;
+ _closure_F(a, c + 0);
+ }
+ break;
+ case 453: /* DIVI */
+ _label(LEFT_CHILD(a));
+ _label(RIGHT_CHILD(a));
+ /* I: DIVI(I,I) */
+ c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_I_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_I_NT] + 0;
+ if (c + 0 < p->cost[_I_NT]) {
+ p->cost[_I_NT] = c + 0;
+ p->rule._I = 18;
+ _closure_I(a, c + 0);
+ }
+ break;
+ case 454: /* DIVU */
+ _label(LEFT_CHILD(a));
+ _label(RIGHT_CHILD(a));
+ /* U: DIVU(U,U) */
+ c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_U_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_U_NT] + 0;
+ if (c + 0 < p->cost[_U_NT]) {
+ p->cost[_U_NT] = c + 0;
+ p->rule._U = 17;
+ _closure_U(a, c + 0);
+ }
+ break;
+ case 465: /* MULF */
+ _label(LEFT_CHILD(a));
+ _label(RIGHT_CHILD(a));
+ /* F: MULF(F,F) */
+ c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_F_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_F_NT] + 0;
+ if (c + 0 < p->cost[_F_NT]) {
+ p->cost[_F_NT] = c + 0;
+ p->rule._F = 11;
+ _closure_F(a, c + 0);
+ }
+ break;
+ case 469: /* MULI */
+ _label(LEFT_CHILD(a));
+ _label(RIGHT_CHILD(a));
+ /* I: MULI(I,I) */
+ c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_I_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_I_NT] + 0;
+ if (c + 0 < p->cost[_I_NT]) {
+ p->cost[_I_NT] = c + 0;
+ p->rule._I = 19;
+ _closure_I(a, c + 0);
+ }
+ break;
+ case 470: /* MULU */
+ _label(LEFT_CHILD(a));
+ _label(RIGHT_CHILD(a));
+ /* U: MULU(U,U) */
+ c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_U_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_U_NT] + 0;
+ if (c + 0 < p->cost[_U_NT]) {
+ p->cost[_U_NT] = c + 0;
+ p->rule._U = 18;
+ _closure_U(a, c + 0);
+ }
+ break;
+ case 481: /* EQF */
+ _label(LEFT_CHILD(a));
+ _label(RIGHT_CHILD(a));
+ /* V: EQF(F,F) */
+ c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_F_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 = 19;
+ _closure_V(a, c + 0);
+ }
+ break;
+ case 485: /* EQI */
+ _label(LEFT_CHILD(a));
+ _label(RIGHT_CHILD(a));
+ /* V: EQI(I,I) */
+ c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_I_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 = 20;
+ _closure_V(a, c + 0);
+ }
+ break;
+ case 486: /* EQU */
+ _label(LEFT_CHILD(a));
+ _label(RIGHT_CHILD(a));
+ /* V: EQU(U,U) */
+ c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_U_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 = 21;
+ _closure_V(a, c + 0);
+ }
+ break;
+ case 497: /* GEF */
+ _label(LEFT_CHILD(a));
+ _label(RIGHT_CHILD(a));
+ /* V: GEF(F,F) */
+ c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_F_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 = 22;
+ _closure_V(a, c + 0);
+ }
+ break;
+ case 501: /* GEI */
+ _label(LEFT_CHILD(a));
+ _label(RIGHT_CHILD(a));
+ /* V: GEI(I,I) */
+ c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_I_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 = 23;
+ _closure_V(a, c + 0);
+ }
+ break;
+ case 502: /* GEU */
+ _label(LEFT_CHILD(a));
+ _label(RIGHT_CHILD(a));
+ /* V: GEU(U,U) */
+ c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_U_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 = 24;
+ _closure_V(a, c + 0);
+ }
+ break;
+ case 513: /* GTF */
+ _label(LEFT_CHILD(a));
+ _label(RIGHT_CHILD(a));
+ /* V: GTF(F,F) */
+ c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_F_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 = 25;
+ _closure_V(a, c + 0);
+ }
+ break;
+ case 517: /* GTI */
+ _label(LEFT_CHILD(a));
+ _label(RIGHT_CHILD(a));
+ /* V: GTI(I,I) */
+ c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_I_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 = 26;
+ _closure_V(a, c + 0);
+ }
+ break;
+ case 518: /* GTU */
+ _label(LEFT_CHILD(a));
+ _label(RIGHT_CHILD(a));
+ /* V: GTU(U,U) */
+ c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_U_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 = 27;
+ _closure_V(a, c + 0);
+ }
+ break;
+ case 529: /* LEF */
+ _label(LEFT_CHILD(a));
+ _label(RIGHT_CHILD(a));
+ /* V: LEF(F,F) */
+ c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_F_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 = 28;
+ _closure_V(a, c + 0);
+ }
+ break;
+ case 533: /* LEI */
+ _label(LEFT_CHILD(a));
+ _label(RIGHT_CHILD(a));
+ /* V: LEI(I,I) */
+ c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_I_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 = 29;
+ _closure_V(a, c + 0);
+ }
+ break;
+ case 534: /* LEU */
+ _label(LEFT_CHILD(a));
+ _label(RIGHT_CHILD(a));
+ /* V: LEU(U,U) */
+ c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_U_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 = 30;
+ _closure_V(a, c + 0);
+ }
+ break;
+ case 545: /* LTF */
+ _label(LEFT_CHILD(a));
+ _label(RIGHT_CHILD(a));
+ /* V: LTF(F,F) */
+ c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_F_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 = 31;
+ _closure_V(a, c + 0);
+ }
+ break;
+ case 549: /* LTI */
+ _label(LEFT_CHILD(a));
+ _label(RIGHT_CHILD(a));
+ /* V: LTI(I,I) */
+ c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_I_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 = 32;
+ _closure_V(a, c + 0);
+ }
+ break;
+ case 550: /* LTU */
+ _label(LEFT_CHILD(a));
+ _label(RIGHT_CHILD(a));
+ /* V: LTU(U,U) */
+ c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_U_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 = 33;
+ _closure_V(a, c + 0);
+ }
+ break;
+ case 561: /* NEF */
+ _label(LEFT_CHILD(a));
+ _label(RIGHT_CHILD(a));
+ /* V: NEF(F,F) */
+ c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_F_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 = 34;
+ _closure_V(a, c + 0);
+ }
+ break;
+ case 565: /* NEI */
+ _label(LEFT_CHILD(a));
+ _label(RIGHT_CHILD(a));
+ /* V: NEI(I,I) */
+ c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_I_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 = 35;
+ _closure_V(a, c + 0);
+ }
+ break;
+ case 566: /* NEU */
+ _label(LEFT_CHILD(a));
+ _label(RIGHT_CHILD(a));
+ /* V: NEU(U,U) */
+ c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_U_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 = 36;
+ _closure_V(a, c + 0);
+ }
+ break;
+ case 584: /* JUMPV */
+ _label(LEFT_CHILD(a));
+ /* V: JUMPV(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 = 37;
+ _closure_V(a, c + 0);
+ }
+ break;
+ case 600: /* LABELV */
+ /* V: LABELV */
+ if (0 + 0 < p->cost[_V_NT]) {
+ p->cost[_V_NT] = 0 + 0;
+ p->rule._V = 38;
+ _closure_V(a, 0 + 0);
+ }
+ break;
+ default:
+ fatal("_label", "Bad terminal %d\n", OP_LABEL(a));
+ }
+}
+
+static void _kids(NODEPTR_TYPE p, int eruleno, NODEPTR_TYPE kids[]) {
+ if (!p)
+ fatal("_kids", "Null tree\n", 0);
+ if (!kids)
+ fatal("_kids", "Null kids\n", 0);
+ switch (eruleno) {
+ case 118: /* V: JUMPV(P) */
+ case 89: /* I: BCOMI(I) */
+ case 88: /* U: BCOMU(U) */
+ case 63: /* V: RETP(P) */
+ case 62: /* V: RETU(U) */
+ case 61: /* V: RETI(I) */
+ case 60: /* V: RETF(F) */
+ case 59: /* V: CALLV(P) */
+ case 58: /* P: CALLP(P) */
+ case 57: /* U: CALLU(P) */
+ case 56: /* I: CALLI(P) */
+ case 55: /* F: CALLF(P) */
+ case 53: /* I: NEGI(I) */
+ case 52: /* F: NEGF(F) */
+ case 51: /* P: CVPP(P) */
+ case 50: /* P: CVUP(U) */
+ case 49: /* F: CVFF(F) */
+ case 48: /* F: CVIF(I) */
+ case 47: /* U: CVPU(P) */
+ case 46: /* U: CVUU(U) */
+ case 45: /* U: CVIU(I) */
+ case 44: /* I: CVFI(F) */
+ case 43: /* I: CVUI(U) */
+ case 42: /* I: CVII(I) */
+ case 41: /* P: INDIRP(P) */
+ case 40: /* U: INDIRU(P) */
+ case 39: /* I: INDIRI(P) */
+ case 38: /* F: INDIRF(P) */
+ case 37: /* B: INDIRB(P) */
+ case 31: /* V: ARGP(P) */
+ case 30: /* V: ARGU(U) */
+ case 29: /* V: ARGI(I) */
+ case 28: /* V: ARGF(F) */
+ case 27: /* V: ARGB(B) */
+ case 9: /* stmt: CALLP(P) */
+ case 8: /* stmt: CALLU(P) */
+ case 7: /* stmt: CALLI(P) */
+ case 6: /* stmt: CALLF(P) */
+ case 5: /* stmt: INDIRP(P) */
+ case 4: /* stmt: INDIRU(P) */
+ case 3: /* stmt: INDIRI(P) */
+ case 2: /* stmt: INDIRF(P) */
+ case 1: /* stmt: INDIRB(P) */
+ kids[0] = LEFT_CHILD(p);
+ break;
+ case 22: /* V: bogus */
+ case 21: /* B: bogus */
+ case 20: /* F: bogus */
+ case 19: /* P: bogus */
+ case 18: /* U: bogus */
+ case 17: /* I: bogus */
+ case 16: /* bogus: V */
+ case 15: /* bogus: B */
+ case 14: /* bogus: F */
+ case 13: /* bogus: P */
+ case 12: /* bogus: U */
+ case 11: /* bogus: I */
+ case 10: /* stmt: V */
+ kids[0] = p;
+ break;
+ case 119: /* V: LABELV */
+ case 67: /* P: ADDRLP */
+ case 66: /* P: ADDRFP */
+ case 65: /* P: ADDRGP */
+ case 64: /* V: RETV */
+ case 26: /* U: CNSTU */
+ case 25: /* P: CNSTP */
+ case 24: /* I: CNSTI */
+ case 23: /* F: CNSTF */
+ break;
+ case 117: /* V: NEU(U,U) */
+ case 116: /* V: NEI(I,I) */
+ case 115: /* V: NEF(F,F) */
+ case 114: /* V: LTU(U,U) */
+ case 113: /* V: LTI(I,I) */
+ case 112: /* V: LTF(F,F) */
+ case 111: /* V: LEU(U,U) */
+ case 110: /* V: LEI(I,I) */
+ case 109: /* V: LEF(F,F) */
+ case 108: /* V: GTU(U,U) */
+ case 107: /* V: GTI(I,I) */
+ case 106: /* V: GTF(F,F) */
+ case 105: /* V: GEU(U,U) */
+ case 104: /* V: GEI(I,I) */
+ case 103: /* V: GEF(F,F) */
+ case 102: /* V: EQU(U,U) */
+ case 101: /* V: EQI(I,I) */
+ case 100: /* V: EQF(F,F) */
+ case 99: /* U: MULU(U,U) */
+ case 98: /* I: MULI(I,I) */
+ case 97: /* F: MULF(F,F) */
+ case 96: /* U: DIVU(U,U) */
+ case 95: /* I: DIVI(I,I) */
+ case 94: /* F: DIVF(F,F) */
+ case 93: /* I: BXORI(I,I) */
+ case 92: /* U: BXORU(U,U) */
+ case 91: /* U: BORU(U,U) */
+ case 90: /* I: BORI(I,I) */
+ case 87: /* I: BANDI(I,I) */
+ case 86: /* U: BANDU(U,U) */
+ case 85: /* U: RSHU(U,I) */
+ case 84: /* I: RSHI(I,I) */
+ case 83: /* U: MODU(U,U) */
+ case 82: /* I: MODI(I,I) */
+ case 81: /* U: LSHU(U,I) */
+ case 80: /* I: LSHI(I,I) */
+ case 79: /* U: SUBU(U,U) */
+ case 78: /* P: SUBP(P,U) */
+ case 77: /* P: SUBP(P,I) */
+ case 76: /* I: SUBI(I,I) */
+ case 75: /* F: SUBF(F,F) */
+ case 74: /* U: ADDU(U,U) */
+ case 73: /* P: ADDP(P,U) */
+ case 72: /* P: ADDP(U,P) */
+ case 71: /* P: ADDP(I,P) */
+ case 70: /* P: ADDP(P,I) */
+ case 69: /* I: ADDI(I,I) */
+ case 68: /* F: ADDF(F,F) */
+ case 54: /* V: CALLB(P,P) */
+ case 36: /* V: ASGNP(P,P) */
+ case 35: /* V: ASGNU(P,U) */
+ case 34: /* V: ASGNI(P,I) */
+ case 33: /* V: ASGNF(P,F) */
+ case 32: /* V: ASGNB(P,B) */
+ kids[0] = LEFT_CHILD(p);
+ kids[1] = RIGHT_CHILD(p);
+ break;
+ default:
+ fatal("_kids", "Bad rule number %d\n", eruleno);
+ }
+}
+
+
+static void reduce(NODEPTR_TYPE p, int goalnt) {
+ int i, sz = opsize(p->op), rulenumber = _rule(p->x.state, goalnt);
+ short *nts = _nts[rulenumber];
+ NODEPTR_TYPE kids[10];
+
+ assert(rulenumber);
+ _kids(p, rulenumber, kids);
+ for (i = 0; nts[i]; i++)
+ reduce(kids[i], nts[i]);
+ switch (optype(p->op)) {
+#define xx(ty) if (sz == ty->size) return
+ case I:
+ case U:
+ xx(chartype);
+ xx(shorttype);
+ xx(inttype);
+ xx(longtype);
+ xx(longlong);
+ break;
+ case F:
+ xx(floattype);
+ xx(doubletype);
+ xx(longdouble);
+ break;
+ case P:
+ xx(voidptype);
+ xx(funcptype);
+ break;
+ case V:
+ case B: if (sz == 0) return;
+#undef xx
+ }
+ printdag(p, 2);
+ assert(0);
+}
+
+void check(Node p) {
+ struct _state { short cost[1]; };
+
+ _label(p);
+ if (((struct _state *)p->x.state)->cost[1] > 0) {
+ printdag(p, 2);
+ assert(0);
+ }
+ reduce(p, 1);
+}
generated by cgit (git 2.34.1) at 2024-11-15 13:13:39 +0000