WebSVN – planix.SVN – Blame – /os/trunk/sys/src/cmd/cc/sub.c

Rev	Author	Line No.	Line
2	-	1	`#include "cc.h"`
		2
		3	`Node*`
		4	`new(int t, Node l, Node r)`
		5	`{`
		6	`Node *n;`
		7
		8	`n = alloc(sizeof(*n));`
		9	`n->op = t;`
		10	`n->left = l;`
		11	`n->right = r;`
		12	`if(l && t != OGOTO)`
		13	`n->lineno = l->lineno;`
		14	`else if(r)`
		15	`n->lineno = r->lineno;`
		16	`else`
		17	`n->lineno = lineno;`
		18	`newflag = 1;`
		19	`return n;`
		20	`}`
		21
		22	`Node*`
		23	`new1(int o, Node l, Node r)`
		24	`{`
		25	`Node *n;`
		26
		27	`n = new(o, l, r);`
		28	`n->lineno = nearln;`
		29	`return n;`
		30	`}`
		31
		32	`void`
		33	`prtree(Node n, char s)`
		34	`{`
		35
		36	`print(" == %s ==\n", s);`
		37	`prtree1(n, 0, 0);`
		38	`print("\n");`
		39	`}`
		40
		41	`void`
		42	`prtree1(Node *n, int d, int f)`
		43	`{`
		44	`int i;`
		45
		46	`if(f)`
		47	`for(i=0; i<d; i++)`
		48	`print(" ");`
		49	`if(n == Z) {`
		50	`print("Z\n");`
		51	`return;`
		52	`}`
		53	`if(n->op == OLIST) {`
		54	`prtree1(n->left, d, 0);`
		55	`prtree1(n->right, d, 1);`
		56	`return;`
		57	`}`
		58	`d++;`
		59	`print("%O", n->op);`
		60	`i = 3;`
		61	`switch(n->op)`
		62	`{`
		63	`case ONAME:`
		64	`print(" \"%F\"", n);`
		65	`print(" %ld", n->xoffset);`
		66	`i = 0;`
		67	`break;`
		68
		69	`case OINDREG:`
		70	`print(" %ld(R%d)", n->xoffset, n->reg);`
		71	`i = 0;`
		72	`break;`
		73
		74	`case OREGISTER:`
		75	`if(n->xoffset)`
		76	`print(" %ld+R%d", n->xoffset, n->reg);`
		77	`else`
		78	`print(" R%d", n->reg);`
		79	`i = 0;`
		80	`break;`
		81
		82	`case OSTRING:`
		83	`print(" \"%s\"", n->cstring);`
		84	`i = 0;`
		85	`break;`
		86
		87	`case OLSTRING:`
		88	`if(sizeof(TRune) == sizeof(Rune))`
		89	`print(" \"%S\"", (Rune*)n->rstring);`
		90	`else`
		91	`print(" \"...\"");`
		92	`i = 0;`
		93	`break;`
		94
		95	`case ODOT:`
		96	`case OELEM:`
		97	`print(" \"%F\"", n);`
		98	`break;`
		99
		100	`case OCONST:`
		101	`if(typefd[n->type->etype])`
		102	`print(" \"%.8e\"", n->fconst);`
		103	`else`
		104	`print(" \"%lld\"", n->vconst);`
		105	`i = 0;`
		106	`break;`
		107	`}`
		108	`if(n->addable != 0)`
		109	`print(" <%d>", n->addable);`
		110	`if(n->type != T)`
		111	`print(" %T", n->type);`
		112	`if(n->complex != 0)`
		113	`print(" (%d)", n->complex);`
		114	`print(" %L\n", n->lineno);`
		115	`if(i & 2)`
		116	`prtree1(n->left, d, 1);`
		117	`if(i & 1)`
		118	`prtree1(n->right, d, 1);`
		119	`}`
		120
		121	`Type*`
		122	`typ(int et, Type *d)`
		123	`{`
		124	`Type *t;`
		125
		126	`t = alloc(sizeof(*t));`
		127	`t->etype = et;`
		128	`t->link = d;`
		129	`t->down = T;`
		130	`t->sym = S;`
		131	`t->width = ewidth[et];`
		132	`t->offset = 0;`
		133	`t->shift = 0;`
		134	`t->nbits = 0;`
		135	`t->garb = 0;`
		136	`return t;`
		137	`}`
		138
		139	`Type*`
		140	`copytyp(Type *t)`
		141	`{`
		142	`Type *nt;`
		143
		144	`nt = typ(TXXX, T);`
		145	`nt = t;`
		146	`return nt;`
		147	`}`
		148
		149	`Type*`
		150	`garbt(Type *t, long b)`
		151	`{`
		152	`Type *t1;`
		153
		154	`if(b & BGARB) {`
		155	`t1 = copytyp(t);`
		156	`t1->garb = simpleg(b);`
		157	`return t1;`
		158	`}`
		159	`return t;`
		160	`}`
		161
		162	`int`
		163	`simpleg(long b)`
		164	`{`
		165
		166	`b &= BGARB;`
		167	`switch(b) {`
		168	`case BCONSTNT:`
		169	`return GCONSTNT;`
		170	`case BVOLATILE:`
		171	`return GVOLATILE;`
		172	`case BVOLATILE\|BCONSTNT:`
		173	`return GCONSTNT\|GVOLATILE;`
		174	`}`
		175	`return GXXX;`
		176	`}`
		177
		178	`int`
		179	`simplec(long b)`
		180	`{`
		181
		182	`b &= BCLASS;`
		183	`switch(b) {`
		184	`case 0:`
		185	`case BREGISTER:`
		186	`return CXXX;`
		187	`case BAUTO:`
		188	`case BAUTO\|BREGISTER:`
		189	`return CAUTO;`
		190	`case BEXTERN:`
		191	`return CEXTERN;`
		192	`case BEXTERN\|BREGISTER:`
		193	`return CEXREG;`
		194	`case BSTATIC:`
		195	`return CSTATIC;`
		196	`case BTYPEDEF:`
		197	`return CTYPEDEF;`
		198	`case BTYPESTR:`
		199	`return CTYPESTR;`
		200	`}`
		201	`diag(Z, "illegal combination of classes %Q", b);`
		202	`return CXXX;`
		203	`}`
		204
		205	`Type*`
		206	`simplet(long b)`
		207	`{`
		208
		209	`b &= ~BCLASS & ~BGARB;`
		210	`switch(b) {`
		211	`case BCHAR:`
		212	`case BCHAR\|BSIGNED:`
		213	`return types[TCHAR];`
		214
		215	`case BCHAR\|BUNSIGNED:`
		216	`return types[TUCHAR];`
		217
		218	`case BSHORT:`
		219	`case BSHORT\|BINT:`
		220	`case BSHORT\|BSIGNED:`
		221	`case BSHORT\|BINT\|BSIGNED:`
		222	`return types[TSHORT];`
		223
		224	`case BUNSIGNED\|BSHORT:`
		225	`case BUNSIGNED\|BSHORT\|BINT:`
		226	`return types[TUSHORT];`
		227
		228	`case 0:`
		229	`case BINT:`
		230	`case BINT\|BSIGNED:`
		231	`case BSIGNED:`
		232	`return types[TINT];`
		233
		234	`case BUNSIGNED:`
		235	`case BUNSIGNED\|BINT:`
		236	`return types[TUINT];`
		237
		238	`case BLONG:`
		239	`case BLONG\|BINT:`
		240	`case BLONG\|BSIGNED:`
		241	`case BLONG\|BINT\|BSIGNED:`
		242	`return types[TLONG];`
		243
		244	`case BUNSIGNED\|BLONG:`
		245	`case BUNSIGNED\|BLONG\|BINT:`
		246	`return types[TULONG];`
		247
		248	`case BVLONG\|BLONG:`
		249	`case BVLONG\|BLONG\|BINT:`
		250	`case BVLONG\|BLONG\|BSIGNED:`
		251	`case BVLONG\|BLONG\|BINT\|BSIGNED:`
		252	`return types[TVLONG];`
		253
		254	`case BVLONG\|BLONG\|BUNSIGNED:`
		255	`case BVLONG\|BLONG\|BINT\|BUNSIGNED:`
		256	`return types[TUVLONG];`
		257
		258	`case BFLOAT:`
		259	`return types[TFLOAT];`
		260
		261	`case BDOUBLE:`
		262	`case BDOUBLE\|BLONG:`
		263	`case BFLOAT\|BLONG:`
		264	`return types[TDOUBLE];`
		265
		266	`case BVOID:`
		267	`return types[TVOID];`
		268	`}`
		269
		270	`diag(Z, "illegal combination of types %Q", b);`
		271	`return types[TINT];`
		272	`}`
		273
		274	`int`
		275	`stcompat(Node n, Type t1, Type *t2, long ttab[])`
		276	`{`
		277	`int i;`
		278	`ulong b;`
		279
		280	`i = 0;`
		281	`if(t2 != T)`
		282	`i = t2->etype;`
		283	`b = 1L << i;`
		284	`i = 0;`
		285	`if(t1 != T)`
		286	`i = t1->etype;`
		287	`if(b & ttab[i]) {`
		288	`if(ttab == tasign)`
		289	`if(b == BSTRUCT \|\| b == BUNION)`
		290	`if(!sametype(t1, t2))`
		291	`return 1;`
		292	`if(n->op != OCAST)`
		293	`if(b == BIND && i == TIND)`
		294	`if(!sametype(t1, t2))`
		295	`return 1;`
		296	`return 0;`
		297	`}`
		298	`return 1;`
		299	`}`
		300
		301	`int`
		302	`tcompat(Node n, Type t1, Type *t2, long ttab[])`
		303	`{`
		304
		305	`if(stcompat(n, t1, t2, ttab)) {`
		306	`if(t1 == T)`
		307	`diag(n, "incompatible type: \"%T\" for op \"%O\"",`
		308	`t2, n->op);`
		309	`else`
		310	`diag(n, "incompatible types: \"%T\" and \"%T\" for op \"%O\"",`
		311	`t1, t2, n->op);`
		312	`return 1;`
		313	`}`
		314	`return 0;`
		315	`}`
		316
		317	`void`
		318	`makedot(Node n, Type t, long o)`
		319	`{`
		320	`Node n1, n2;`
		321
		322	`if(t->nbits) {`
		323	`n1 = new(OXXX, Z, Z);`
		324	`n1 = n;`
		325	`n->op = OBIT;`
		326	`n->left = n1;`
		327	`n->right = Z;`
		328	`n->type = t;`
		329	`n->addable = n1->left->addable;`
		330	`n = n1;`
		331	`}`
		332	`n->addable = n->left->addable;`
		333	`if(n->addable == 0) {`
		334	`n1 = new1(OCONST, Z, Z);`
		335	`n1->vconst = o;`
		336	`n1->type = types[TLONG];`
		337	`n->right = n1;`
		338	`n->type = t;`
		339	`return;`
		340	`}`
		341	`n->left->type = t;`
		342	`if(o == 0) {`
		343	`n = n->left;`
		344	`return;`
		345	`}`
		346	`n->type = t;`
		347	`n1 = new1(OCONST, Z, Z);`
		348	`n1->vconst = o;`
		349	`t = typ(TIND, t);`
		350	`t->width = types[TIND]->width;`
		351	`n1->type = t;`
		352
		353	`n2 = new1(OADDR, n->left, Z);`
		354	`n2->type = t;`
		355
		356	`n1 = new1(OADD, n1, n2);`
		357	`n1->type = t;`
		358
		359	`n->op = OIND;`
		360	`n->left = n1;`
		361	`n->right = Z;`
		362	`}`
		363
		364	`Type*`
		365	`dotsearch(Sym s, Type t, Node n, long off)`
		366	`{`
		367	`Type t1, xt, *rt;`
		368
		369	`xt = T;`
		370
		371	`/*`
		372	`* look it up by name`
		373	`*/`
		374	`for(t1 = t; t1 != T; t1 = t1->down)`
		375	`if(t1->sym == s) {`
		376	`if(xt != T)`
		377	`goto ambig;`
		378	`xt = t1;`
		379	`}`
		380
		381	`/*`
		382	`* look it up by type`
		383	`*/`
		384	`if(s->class == CTYPEDEF \|\| s->class == CTYPESTR)`
		385	`for(t1 = t; t1 != T; t1 = t1->down)`
		386	`if(t1->sym == S && typesu[t1->etype])`
		387	`if(sametype(s->type, t1)) {`
		388	`if(xt != T)`
		389	`goto ambig;`
		390	`xt = t1;`
		391	`}`
		392	`if(xt != T) {`
		393	`*off = xt->offset;`
		394	`return xt;`
		395	`}`
		396
		397	`/*`
		398	`* look it up in unnamed substructures`
		399	`*/`
		400	`for(t1 = t; t1 != T; t1 = t1->down)`
		401	`if(t1->sym == S && typesu[t1->etype]){`
		402	`rt = dotsearch(s, t1->link, n, off);`
		403	`if(rt != T) {`
		404	`if(xt != T)`
		405	`goto ambig;`
		406	`xt = rt;`
		407	`*off += t1->offset;`
		408	`}`
		409	`}`
		410	`return xt;`
		411
		412	`ambig:`
		413	`diag(n, "ambiguous structure element: %s", s->name);`
		414	`return xt;`
		415	`}`
		416
		417	`long`
		418	`dotoffset(Type st, Type lt, Node *n)`
		419	`{`
		420	`Type *t;`
		421	`Sym *g;`
		422	`long o, o1;`
		423
		424	`o = -1;`
		425	`/*`
		426	`* first try matching at the top level`
		427	`* for matching tag names`
		428	`*/`
		429	`g = st->tag;`
		430	`if(g != S)`
		431	`for(t=lt->link; t!=T; t=t->down)`
		432	`if(t->sym == S)`
		433	`if(g == t->tag) {`
		434	`if(o >= 0)`
		435	`goto ambig;`
		436	`o = t->offset;`
		437	`}`
		438	`if(o >= 0)`
		439	`return o;`
		440
		441	`/*`
		442	`* second try matching at the top level`
		443	`* for similar types`
		444	`*/`
		445	`for(t=lt->link; t!=T; t=t->down)`
		446	`if(t->sym == S)`
		447	`if(sametype(st, t)) {`
		448	`if(o >= 0)`
		449	`goto ambig;`
		450	`o = t->offset;`
		451	`}`
		452	`if(o >= 0)`
		453	`return o;`
		454
		455	`/*`
		456	`* last try matching sub-levels`
		457	`*/`
		458	`for(t=lt->link; t!=T; t=t->down)`
		459	`if(t->sym == S)`
		460	`if(typesu[t->etype]) {`
		461	`o1 = dotoffset(st, t, n);`
		462	`if(o1 >= 0) {`
		463	`if(o >= 0)`
		464	`goto ambig;`
		465	`o = o1 + t->offset;`
		466	`}`
		467	`}`
		468	`return o;`
		469
		470	`ambig:`
		471	`diag(n, "ambiguous unnamed structure element");`
		472	`return o;`
		473	`}`
		474
		475	`/*`
		476	`* look into tree for floating point constant expressions`
		477	`*/`
		478	`int`
		479	`allfloat(Node *n, int flag)`
		480	`{`
		481
		482	`if(n != Z) {`
		483	`if(n->type->etype != TDOUBLE)`
		484	`return 1;`
		485	`switch(n->op) {`
		486	`case OCONST:`
		487	`if(flag)`
		488	`n->type = types[TFLOAT];`
		489	`return 1;`
		490	`case OADD: /* no need to get more exotic than this */`
		491	`case OSUB:`
		492	`case OMUL:`
		493	`case ODIV:`
		494	`if(!allfloat(n->right, flag))`
		495	`break;`
		496	`case OCAST:`
		497	`if(!allfloat(n->left, flag))`
		498	`break;`
		499	`if(flag)`
		500	`n->type = types[TFLOAT];`
		501	`return 1;`
		502	`}`
		503	`}`
		504	`return 0;`
		505	`}`
		506
		507	`void`
		508	`constas(Node n, Type il, Type *ir)`
		509	`{`
		510	`Type l, r;`
		511
		512	`l = il;`
		513	`r = ir;`
		514
		515	`if(l == T)`
		516	`return;`
		517	`if(l->garb & GCONSTNT) {`
		518	`warn(n, "assignment to a constant type (%T)", il);`
		519	`return;`
		520	`}`
		521	`if(r == T)`
		522	`return;`
		523	`for(;;) {`
		524	`if(l->etype != TIND \|\| r->etype != TIND)`
		525	`break;`
		526	`l = l->link;`
		527	`r = r->link;`
		528	`if(l == T \|\| r == T)`
		529	`break;`
		530	`if(r->garb & GCONSTNT)`
		531	`if(!(l->garb & GCONSTNT)) {`
		532	`warn(n, "assignment of a constant pointer type (%T)", ir);`
		533	`break;`
		534	`}`
		535	`}`
		536	`}`
		537
		538	`void`
		539	`typeext1(Type st, Node l)`
		540	`{`
		541	`if(st->etype == TFLOAT && allfloat(l, 0))`
		542	`allfloat(l, 1);`
		543	`}`
		544
		545	`void`
		546	`typeext(Type st, Node l)`
		547	`{`
		548	`Type *lt;`
		549	`Node n1, n2;`
		550	`long o;`
		551
		552	`lt = l->type;`
		553	`if(lt == T)`
		554	`return;`
		555	`if(st->etype == TIND && vconst(l) == 0) {`
		556	`l->type = st;`
		557	`l->vconst = 0;`
		558	`return;`
		559	`}`
		560	`typeext1(st, l);`
		561
		562	`/*`
		563	`* extension of C`
		564	`* if assign of struct containing unnamed sub-struct`
		565	`* to type of sub-struct, insert the DOT.`
		566	`* if assign of *struct containing unnamed substruct`
		567	`* to type of *sub-struct, insert the add-offset`
		568	`*/`
		569	`if(typesu[st->etype] && typesu[lt->etype]) {`
		570	`o = dotoffset(st, lt, l);`
		571	`if(o >= 0) {`
		572	`n1 = new1(OXXX, Z, Z);`
		573	`n1 = l;`
		574	`l->op = ODOT;`
		575	`l->left = n1;`
		576	`l->right = Z;`
		577	`makedot(l, st, o);`
		578	`}`
		579	`return;`
		580	`}`
		581	`if(st->etype == TIND && typesu[st->link->etype])`
		582	`if(lt->etype == TIND && typesu[lt->link->etype]) {`
		583	`o = dotoffset(st->link, lt->link, l);`
		584	`if(o >= 0) {`
		585	`l->type = st;`
		586	`if(o == 0)`
		587	`return;`
		588	`n1 = new1(OXXX, Z, Z);`
		589	`n1 = l;`
		590	`n2 = new1(OCONST, Z, Z);`
		591	`n2->vconst = o;`
		592	`n2->type = st;`
		593	`l->op = OADD;`
		594	`l->left = n1;`
		595	`l->right = n2;`
		596	`}`
		597	`return;`
		598	`}`
		599	`}`
		600
		601	`/*`
		602	`* a cast that generates no code`
		603	`* (same size move)`
		604	`*/`
		605	`int`
		606	`nocast(Type t1, Type t2)`
		607	`{`
		608	`int i, b;`
		609
		610	`if(t1->nbits)`
		611	`return 0;`
		612	`i = 0;`
		613	`if(t2 != T)`
		614	`i = t2->etype;`
		615	`b = 1<<i;`
		616	`i = 0;`
		617	`if(t1 != T)`
		618	`i = t1->etype;`
		619	`if(b & ncast[i])`
		620	`return 1;`
		621	`return 0;`
		622	`}`
		623
		624	`/*`
		625	`* a cast that has a noop semantic`
		626	`* (small to large, convert)`
		627	`*/`
		628	`int`
		629	`nilcast(Type t1, Type t2)`
		630	`{`
		631	`int et1, et2;`
		632
		633	`if(t1 == T)`
		634	`return 0;`
		635	`if(t1->nbits)`
		636	`return 0;`
		637	`if(t2 == T)`
		638	`return 0;`
		639	`et1 = t1->etype;`
		640	`et2 = t2->etype;`
		641	`if(et1 == et2)`
		642	`return 1;`
		643	`if(typefd[et1] && typefd[et2]) {`
		644	`if(ewidth[et1] < ewidth[et2])`
		645	`return 1;`
		646	`return 0;`
		647	`}`
		648	`if(typechlp[et1] && typechlp[et2]) {`
		649	`if(ewidth[et1] < ewidth[et2])`
		650	`return 1;`
		651	`return 0;`
		652	`}`
		653	`return 0;`
		654	`}`
		655
		656	`/*`
		657	`* "the usual arithmetic conversions are performed"`
		658	`*/`
		659	`void`
		660	`arith(Node *n, int f)`
		661	`{`
		662	`Type t1, t2;`
		663	`int i, j, k;`
		664	`Node *n1;`
		665	`long w;`
		666
		667	`t1 = n->left->type;`
		668	`if(n->right == Z)`
		669	`t2 = t1;`
		670	`else`
		671	`t2 = n->right->type;`
		672	`i = TXXX;`
		673	`if(t1 != T)`
		674	`i = t1->etype;`
		675	`j = TXXX;`
		676	`if(t2 != T)`
		677	`j = t2->etype;`
		678	`k = tab[i][j];`
		679	`if(k == TIND) {`
		680	`if(i == TIND)`
		681	`n->type = t1;`
		682	`else`
		683	`if(j == TIND)`
		684	`n->type = t2;`
		685	`} else {`
		686	`/* convert up to at least int */`
		687	`if(f == 1)`
		688	`while(k < TINT)`
		689	`k += 2;`
		690	`n->type = types[k];`
		691	`}`
		692	`if(n->op == OSUB)`
		693	`if(i == TIND && j == TIND) {`
		694	`w = n->right->type->link->width;`
		695	`if(w < 1 \|\| n->left->type->link == T \|\| n->left->type->link->width < 1)`
		696	`goto bad;`
		697	`n->type = types[ewidth[TIND] <= ewidth[TLONG]? TLONG: TVLONG];`
		698	`if(1 && ewidth[TIND] > ewidth[TLONG]){`
		699	`n1 = new1(OXXX, Z, Z);`
		700	`n1 = n;`
		701	`n->op = OCAST;`
		702	`n->left = n1;`
		703	`n->right = Z;`
		704	`n->type = types[TLONG];`
		705	`}`
		706	`if(w > 1) {`
		707	`n1 = new1(OXXX, Z, Z);`
		708	`n1 = n;`
		709	`n->op = ODIV;`
		710	`n->left = n1;`
		711	`n1 = new1(OCONST, Z, Z);`
		712	`n1->vconst = w;`
		713	`n1->type = n->type;`
		714	`n->right = n1;`
		715	`w = vlog(n1);`
		716	`if(w >= 0) {`
		717	`n->op = OASHR;`
		718	`n1->vconst = w;`
		719	`}`
		720	`}`
		721	`return;`
		722	`}`
		723	`if(!sametype(n->type, n->left->type)) {`
		724	`n->left = new1(OCAST, n->left, Z);`
		725	`n->left->type = n->type;`
		726	`if(n->type->etype == TIND) {`
		727	`w = n->type->link->width;`
		728	`if(w < 1) {`
		729	`snap(n->type->link);`
		730	`w = n->type->link->width;`
		731	`if(w < 1)`
		732	`goto bad;`
		733	`}`
		734	`if(w > 1) {`
		735	`n1 = new1(OCONST, Z, Z);`
		736	`n1->vconst = w;`
		737	`n1->type = n->type;`
		738	`n->left = new1(OMUL, n->left, n1);`
		739	`n->left->type = n->type;`
		740	`}`
		741	`}`
		742	`}`
		743	`if(n->right != Z)`
		744	`if(!sametype(n->type, n->right->type)) {`
		745	`n->right = new1(OCAST, n->right, Z);`
		746	`n->right->type = n->type;`
		747	`if(n->type->etype == TIND) {`
		748	`w = n->type->link->width;`
		749	`if(w < 1) {`
		750	`snap(n->type->link);`
		751	`w = n->type->link->width;`
		752	`if(w < 1)`
		753	`goto bad;`
		754	`}`
		755	`if(w != 1) {`
		756	`n1 = new1(OCONST, Z, Z);`
		757	`n1->vconst = w;`
		758	`n1->type = n->type;`
		759	`n->right = new1(OMUL, n->right, n1);`
		760	`n->right->type = n->type;`
		761	`}`
		762	`}`
		763	`}`
		764	`return;`
		765	`bad:`
		766	`diag(n, "pointer addition not fully declared: %T", n->type->link);`
		767	`}`
		768
		769	`/*`
		770	`* try to rewrite shift & mask`
		771	`*/`
		772	`void`
		773	`simplifyshift(Node *n)`
		774	`{`
		775	`ulong c3;`
		776	`int o, s1, s2, c1, c2;`
		777
		778	`if(!typechlp[n->type->etype])`
		779	`return;`
		780	`switch(n->op) {`
		781	`default:`
		782	`return;`
		783	`case OASHL:`
		784	`s1 = 0;`
		785	`break;`
		786	`case OLSHR:`
		787	`s1 = 1;`
		788	`break;`
		789	`case OASHR:`
		790	`s1 = 2;`
		791	`break;`
		792	`}`
		793	`if(n->right->op != OCONST)`
		794	`return;`
		795	`if(n->left->op != OAND)`
		796	`return;`
		797	`if(n->left->right->op != OCONST)`
		798	`return;`
		799	`switch(n->left->left->op) {`
		800	`default:`
		801	`return;`
		802	`case OASHL:`
		803	`s2 = 0;`
		804	`break;`
		805	`case OLSHR:`
		806	`s2 = 1;`
		807	`break;`
		808	`case OASHR:`
		809	`s2 = 2;`
		810	`break;`
		811	`}`
		812	`if(n->left->left->right->op != OCONST)`
		813	`return;`
		814
		815	`c1 = n->right->vconst;`
		816	`c2 = n->left->left->right->vconst;`
		817	`c3 = n->left->right->vconst;`
		818
		819	`/*`
		820	`if(debug['h'])`
		821	`print("%.3o %ld %ld %d #%.lux\n",`
		822	`(s1<<3)\|s2, c1, c2, topbit(c3), c3);`
		823	`*/`
		824
		825	`o = n->op;`
		826	`switch((s1<<3)\|s2) {`
		827	`case 000: /* (((e <<u c2) & c3) <<u c1) */`
		828	`c3 >>= c2;`
		829	`c1 += c2;`
		830	`if(c1 >= 32)`
		831	`break;`
		832	`goto rewrite1;`
		833
		834	`case 002: /* (((e >>s c2) & c3) <<u c1) */`
		835	`if(topbit(c3) >= (32-c2))`
		836	`break;`
		837	`case 001: /* (((e >>u c2) & c3) <<u c1) */`
		838	`if(c1 > c2) {`
		839	`c3 <<= c2;`
		840	`c1 -= c2;`
		841	`o = OASHL;`
		842	`goto rewrite1;`
		843	`}`
		844	`c3 <<= c1;`
		845	`if(c1 == c2)`
		846	`goto rewrite0;`
		847	`c1 = c2-c1;`
		848	`o = OLSHR;`
		849	`goto rewrite2;`
		850
		851	`case 022: /* (((e >>s c2) & c3) >>s c1) */`
		852	`if(c2 <= 0)`
		853	`break;`
		854	`case 012: /* (((e >>s c2) & c3) >>u c1) */`
		855	`if(topbit(c3) >= (32-c2))`
		856	`break;`
		857	`goto s11;`
		858	`case 021: /* (((e >>u c2) & c3) >>s c1) */`
		859	`if(topbit(c3) >= 31 && c2 <= 0)`
		860	`break;`
		861	`goto s11;`
		862	`case 011: /* (((e >>u c2) & c3) >>u c1) */`
		863	`s11:`
		864	`c3 <<= c2;`
		865	`c1 += c2;`
		866	`if(c1 >= 32)`
		867	`break;`
		868	`o = OLSHR;`
		869	`goto rewrite1;`
		870
		871	`case 020: /* (((e <<u c2) & c3) >>s c1) */`
		872	`if(topbit(c3) >= 31)`
		873	`break;`
		874	`case 010: /* (((e <<u c2) & c3) >>u c1) */`
		875	`c3 >>= c1;`
		876	`if(c1 == c2)`
		877	`goto rewrite0;`
		878	`if(c1 > c2) {`
		879	`c1 -= c2;`
		880	`goto rewrite2;`
		881	`}`
		882	`c1 = c2 - c1;`
		883	`o = OASHL;`
		884	`goto rewrite2;`
		885	`}`
		886	`return;`
		887
		888	`rewrite0: /* get rid of both shifts */`
		889	`if(debug['<'])prtree(n, "rewrite0");`
		890	`n = n->left;`
		891	`n->left = n->left->left;`
		892	`n->right->vconst = c3;`
		893	`return;`
		894	`rewrite1: /* get rid of lower shift */`
		895	`if(debug['<'])prtree(n, "rewrite1");`
		896	`n->left->left = n->left->left->left;`
		897	`n->left->right->vconst = c3;`
		898	`n->right->vconst = c1;`
		899	`n->op = o;`
		900	`return;`
		901	`rewrite2: /* get rid of upper shift */`
		902	`if(debug['<'])prtree(n, "rewrite2");`
		903	`n = n->left;`
		904	`n->right->vconst = c3;`
		905	`n->left->right->vconst = c1;`
		906	`n->left->op = o;`
		907	`}`
		908
		909	`int`
		910	`side(Node *n)`
		911	`{`
		912
		913	`loop:`
		914	`if(n != Z)`
		915	`switch(n->op) {`
		916	`case OCAST:`
		917	`case ONOT:`
		918	`case OADDR:`
		919	`case OIND:`
		920	`n = n->left;`
		921	`goto loop;`
		922
		923	`case OCOND:`
		924	`if(side(n->left))`
		925	`break;`
		926	`n = n->right;`
		927
		928	`case OEQ:`
		929	`case ONE:`
		930	`case OLT:`
		931	`case OGE:`
		932	`case OGT:`
		933	`case OLE:`
		934	`case OADD:`
		935	`case OSUB:`
		936	`case OMUL:`
		937	`case OLMUL:`
		938	`case ODIV:`
		939	`case OLDIV:`
		940	`case OLSHR:`
		941	`case OASHL:`
		942	`case OASHR:`
		943	`case OAND:`
		944	`case OOR:`
		945	`case OXOR:`
		946	`case OMOD:`
		947	`case OLMOD:`
		948	`case OANDAND:`
		949	`case OOROR:`
		950	`case OCOMMA:`
		951	`case ODOT:`
		952	`if(side(n->left))`
		953	`break;`
		954	`n = n->right;`
		955	`goto loop;`
		956
		957	`case OSIGN:`
		958	`case OSIZE:`
		959	`case OCONST:`
		960	`case OSTRING:`
		961	`case OLSTRING:`
		962	`case ONAME:`
		963	`return 0;`
		964	`}`
		965	`return 1;`
		966	`}`
		967
		968	`int`
		969	`vconst(Node *n)`
		970	`{`
		971	`int i;`
		972
		973	`if(n == Z)`
		974	`goto no;`
		975	`if(n->op != OCONST)`
		976	`goto no;`
		977	`if(n->type == T)`
		978	`goto no;`
		979	`switch(n->type->etype)`
		980	`{`
		981	`case TFLOAT:`
		982	`case TDOUBLE:`
		983	`i = 100;`
		984	`if(n->fconst > i \|\| n->fconst < -i)`
		985	`goto no;`
		986	`i = n->fconst;`
		987	`if(i != n->fconst)`
		988	`goto no;`
		989	`return i;`
		990
		991	`case TVLONG:`
		992	`case TUVLONG:`
		993	`i = n->vconst;`
		994	`if(i != n->vconst)`
		995	`goto no;`
		996	`return i;`
		997
		998	`case TCHAR:`
		999	`case TUCHAR:`
		1000	`case TSHORT:`
		1001	`case TUSHORT:`
		1002	`case TINT:`
		1003	`case TUINT:`
		1004	`case TLONG:`
		1005	`case TULONG:`
		1006	`case TIND:`
		1007	`i = n->vconst;`
		1008	`if(i != n->vconst)`
		1009	`goto no;`
		1010	`return i;`
		1011	`}`
		1012	`no:`
		1013	`return -159; /* first uninteresting constant */`
		1014	`}`
		1015
		1016	`/*`
		1017	`* return log(n) if n is a power of 2 constant`
		1018	`*/`
		1019	`int`
		1020	`log2(uvlong v)`
		1021	`{`
		1022	`int s, i;`
		1023	`uvlong m;`
		1024
		1025	`s = 0;`
		1026	`m = MASK(8*sizeof(uvlong));`
		1027	`for(i=32; i; i>>=1) {`
		1028	`m >>= i;`
		1029	`if(!(v & m)) {`
		1030	`v >>= i;`
		1031	`s += i;`
		1032	`}`
		1033	`}`
		1034	`if(v == 1)`
		1035	`return s;`
		1036	`return -1;`
		1037	`}`
		1038
		1039	`int`
		1040	`vlog(Node *n)`
		1041	`{`
		1042	`if(n->op != OCONST)`
		1043	`goto bad;`
		1044	`if(typefd[n->type->etype])`
		1045	`goto bad;`
		1046
		1047	`return log2(n->vconst);`
		1048
		1049	`bad:`
		1050	`return -1;`
		1051	`}`
		1052
		1053	`int`
		1054	`topbit(ulong v)`
		1055	`{`
		1056	`int i;`
		1057
		1058	`for(i = -1; v; i++)`
		1059	`v >>= 1;`
		1060	`return i;`
		1061	`}`
		1062
		1063	`/*`
		1064	`* try to cast a constant down`
		1065	`* rather than cast a variable up`
		1066	`* example:`
		1067	`* if(c == 'a')`
		1068	`*/`
		1069	`void`
		1070	`relcon(Node l, Node r)`
		1071	`{`
		1072	`vlong v;`
		1073
		1074	`if(l->op != OCONST)`
		1075	`return;`
		1076	`if(r->op != OCAST)`
		1077	`return;`
		1078	`if(!nilcast(r->left->type, r->type))`
		1079	`return;`
		1080	`switch(r->type->etype) {`
		1081	`default:`
		1082	`return;`
		1083	`case TCHAR:`
		1084	`case TUCHAR:`
		1085	`case TSHORT:`
		1086	`case TUSHORT:`
		1087	`v = convvtox(l->vconst, r->type->etype);`
		1088	`if(v != l->vconst)`
		1089	`return;`
		1090	`break;`
		1091	`}`
		1092	`l->type = r->left->type;`
		1093	`r = r->left;`
		1094	`}`
		1095
		1096	`int`
		1097	`relindex(int o)`
		1098	`{`
		1099
		1100	`switch(o) {`
		1101	`default:`
		1102	`diag(Z, "bad in relindex: %O", o);`
		1103	`case OEQ: return 0;`
		1104	`case ONE: return 1;`
		1105	`case OLE: return 2;`
		1106	`case OLS: return 3;`
		1107	`case OLT: return 4;`
		1108	`case OLO: return 5;`
		1109	`case OGE: return 6;`
		1110	`case OHS: return 7;`
		1111	`case OGT: return 8;`
		1112	`case OHI: return 9;`
		1113	`}`
		1114	`}`
		1115
		1116	`Node*`
		1117	`invert(Node *n)`
		1118	`{`
		1119	`Node *i;`
		1120
		1121	`if(n == Z \|\| n->op != OLIST)`
		1122	`return n;`
		1123	`i = n;`
		1124	`for(n = n->left; n != Z; n = n->left) {`
		1125	`if(n->op != OLIST)`
		1126	`break;`
		1127	`i->left = n->right;`
		1128	`n->right = i;`
		1129	`i = n;`
		1130	`}`
		1131	`i->left = n;`
		1132	`return i;`
		1133	`}`
		1134
		1135	`int`
		1136	`bitno(long b)`
		1137	`{`
		1138	`int i;`
		1139
		1140	`for(i=0; i<32; i++)`
		1141	`if(b & (1L<<i))`
		1142	`return i;`
		1143	`diag(Z, "bad in bitno");`
		1144	`return 0;`
		1145	`}`
		1146
		1147	`long`
		1148	`typebitor(long a, long b)`
		1149	`{`
		1150	`long c;`
		1151
		1152	`c = a \| b;`
		1153	`if(a & b)`
		1154	`if((a & b) == BLONG)`
		1155	`c \|= BVLONG; /* long long => vlong */`
		1156	`else`
		1157	`warn(Z, "once is enough: %Q", a & b);`
		1158	`return c;`
		1159	`}`
		1160
		1161	`void`
		1162	`diag(Node n, char fmt, ...)`
		1163	`{`
		1164	`char buf[STRINGSZ];`
		1165	`va_list arg;`
		1166
		1167	`va_start(arg, fmt);`
		1168	`vseprint(buf, buf+sizeof(buf), fmt, arg);`
		1169	`va_end(arg);`
		1170	`Bprint(&diagbuf, "%L %s\n", (n==Z)? nearln: n->lineno, buf);`
		1171
		1172	`if(debug['X']){`
		1173	`Bflush(&diagbuf);`
		1174	`abort();`
		1175	`}`
		1176	`if(n != Z)`
		1177	`if(debug['v'])`
		1178	`prtree(n, "diagnostic");`
		1179
		1180	`nerrors++;`
		1181	`if(nerrors > 10) {`
		1182	`Bprint(&diagbuf, "too many errors\n");`
		1183	`errorexit();`
		1184	`}`
		1185	`}`
		1186
		1187	`void`
		1188	`warn(Node n, char fmt, ...)`
		1189	`{`
		1190	`char buf[STRINGSZ];`
		1191	`va_list arg;`
		1192
		1193	`if(debug['w'] \|\| debug['W']) {`
		1194	`va_start(arg, fmt);`
		1195	`vseprint(buf, buf+sizeof(buf), fmt, arg);`
		1196	`va_end(arg);`
		1197	`if(debug['W']) {`
		1198	`diag(n, "%s", buf);`
		1199	`return;`
		1200	`}`
		1201	`Bprint(&diagbuf, "warning: %L %s\n", (n==Z)? nearln: n->lineno, buf);`
		1202
		1203	`if(n != Z)`
		1204	`if(debug['v'])`
		1205	`prtree(n, "warning");`
		1206	`}`
		1207	`}`
		1208
		1209	`void`
		1210	`yyerror(char *fmt, ...)`
		1211	`{`
		1212	`char buf[STRINGSZ];`
		1213	`va_list arg;`
		1214
		1215	`/*`
		1216	`* hack to intercept message from yaccpar`
		1217	`*/`
		1218	`if(strcmp(fmt, "syntax error") == 0) {`
		1219	`yyerror("syntax error, last name: %s", symb);`
		1220	`return;`
		1221	`}`
		1222	`va_start(arg, fmt);`
		1223	`vseprint(buf, buf+sizeof(buf), fmt, arg);`
		1224	`va_end(arg);`
		1225	`Bprint(&diagbuf, "%L %s\n", lineno, buf);`
		1226	`nerrors++;`
		1227	`if(nerrors > 10) {`
		1228	`Bprint(&diagbuf, "too many errors\n");`
		1229	`errorexit();`
		1230	`}`
		1231	`}`
		1232
		1233	`void`
		1234	`fatal(Node n, char fmt, ...)`
		1235	`{`
		1236	`char buf[STRINGSZ];`
		1237	`va_list arg;`
		1238
		1239	`va_start(arg, fmt);`
		1240	`vseprint(buf, buf+sizeof(buf), fmt, arg);`
		1241	`va_end(arg);`
		1242	`Bprint(&diagbuf, "%L %s\n", (n==Z)? nearln: n->lineno, buf);`
		1243
		1244	`if(debug['X']){`
		1245	`Bflush(&diagbuf);`
		1246	`abort();`
		1247	`}`
		1248	`if(n != Z)`
		1249	`if(debug['v'])`
		1250	`prtree(n, "diagnostic");`
		1251
		1252	`nerrors++;`
		1253	`errorexit();`
		1254	`}`
		1255
		1256	`ulong thash1 = 0x2edab8c9;`
		1257	`ulong thash2 = 0x1dc74fb8;`
		1258	`ulong thash3 = 0x1f241331;`
		1259	`ulong thash[NALLTYPES];`
		1260	`Init thashinit[] =`
		1261	`{`
		1262	`TXXX, 0x17527bbd, 0,`
		1263	`TCHAR, 0x5cedd32b, 0,`
		1264	`TUCHAR, 0x552c4454, 0,`
		1265	`TSHORT, 0x63040b4b, 0,`
		1266	`TUSHORT, 0x32a45878, 0,`
		1267	`TINT, 0x4151d5bd, 0,`
		1268	`TUINT, 0x5ae707d6, 0,`
		1269	`TLONG, 0x5ef20f47, 0,`
		1270	`TULONG, 0x36d8eb8f, 0,`
		1271	`TVLONG, 0x6e5e9590, 0,`
		1272	`TUVLONG, 0x75910105, 0,`
		1273	`TFLOAT, 0x25fd7af1, 0,`
		1274	`TDOUBLE, 0x7c40a1b2, 0,`
		1275	`TIND, 0x1b832357, 0,`
		1276	`TFUNC, 0x6babc9cb, 0,`
		1277	`TARRAY, 0x7c50986d, 0,`
		1278	`TVOID, 0x44112eff, 0,`
		1279	`TSTRUCT, 0x7c2da3bf, 0,`
		1280	`TUNION, 0x3eb25e98, 0,`
		1281	`TENUM, 0x44b54f61, 0,`
		1282	`TFILE, 0x19242ac3, 0,`
		1283	`TOLD, 0x22b15988, 0,`
		1284	`TDOT, 0x0204f6b3, 0,`
		1285	`-1, 0, 0,`
		1286	`};`
		1287
		1288	`char* bnames[NALIGN];`
		1289	`Init bnamesinit[] =`
		1290	`{`
		1291	`Axxx, 0, "Axxx",`
		1292	`Ael1, 0, "el1",`
		1293	`Ael2, 0, "el2",`
		1294	`Asu2, 0, "su2",`
		1295	`Aarg0, 0, "arg0",`
		1296	`Aarg1, 0, "arg1",`
		1297	`Aarg2, 0, "arg2",`
		1298	`Aaut3, 0, "aut3",`
		1299	`-1, 0, 0,`
		1300	`};`
		1301
		1302	`char* tnames[NALLTYPES];`
		1303	`Init tnamesinit[] =`
		1304	`{`
		1305	`TXXX, 0, "TXXX",`
		1306	`TCHAR, 0, "CHAR",`
		1307	`TUCHAR, 0, "UCHAR",`
		1308	`TSHORT, 0, "SHORT",`
		1309	`TUSHORT, 0, "USHORT",`
		1310	`TINT, 0, "INT",`
		1311	`TUINT, 0, "UINT",`
		1312	`TLONG, 0, "LONG",`
		1313	`TULONG, 0, "ULONG",`
		1314	`TVLONG, 0, "VLONG",`
		1315	`TUVLONG, 0, "UVLONG",`
		1316	`TFLOAT, 0, "FLOAT",`
		1317	`TDOUBLE, 0, "DOUBLE",`
		1318	`TIND, 0, "IND",`
		1319	`TFUNC, 0, "FUNC",`
		1320	`TARRAY, 0, "ARRAY",`
		1321	`TVOID, 0, "VOID",`
		1322	`TSTRUCT, 0, "STRUCT",`
		1323	`TUNION, 0, "UNION",`
		1324	`TENUM, 0, "ENUM",`
		1325	`TFILE, 0, "FILE",`
		1326	`TOLD, 0, "OLD",`
		1327	`TDOT, 0, "DOT",`
		1328	`-1, 0, 0,`
		1329	`};`
		1330
		1331	`char* gnames[NGTYPES];`
		1332	`Init gnamesinit[] =`
		1333	`{`
		1334	`GXXX, 0, "GXXX",`
		1335	`GCONSTNT, 0, "CONST",`
		1336	`GVOLATILE, 0, "VOLATILE",`
		1337	`GVOLATILE\|GCONSTNT, 0, "CONST-VOLATILE",`
		1338	`-1, 0, 0,`
		1339	`};`
		1340
		1341	`char* qnames[NALLTYPES];`
		1342	`Init qnamesinit[] =`
		1343	`{`
		1344	`TXXX, 0, "TXXX",`
		1345	`TCHAR, 0, "CHAR",`
		1346	`TUCHAR, 0, "UCHAR",`
		1347	`TSHORT, 0, "SHORT",`
		1348	`TUSHORT, 0, "USHORT",`
		1349	`TINT, 0, "INT",`
		1350	`TUINT, 0, "UINT",`
		1351	`TLONG, 0, "LONG",`
		1352	`TULONG, 0, "ULONG",`
		1353	`TVLONG, 0, "VLONG",`
		1354	`TUVLONG, 0, "UVLONG",`
		1355	`TFLOAT, 0, "FLOAT",`
		1356	`TDOUBLE, 0, "DOUBLE",`
		1357	`TIND, 0, "IND",`
		1358	`TFUNC, 0, "FUNC",`
		1359	`TARRAY, 0, "ARRAY",`
		1360	`TVOID, 0, "VOID",`
		1361	`TSTRUCT, 0, "STRUCT",`
		1362	`TUNION, 0, "UNION",`
		1363	`TENUM, 0, "ENUM",`
		1364
		1365	`TAUTO, 0, "AUTO",`
		1366	`TEXTERN, 0, "EXTERN",`
		1367	`TSTATIC, 0, "STATIC",`
		1368	`TTYPEDEF, 0, "TYPEDEF",`
		1369	`TTYPESTR, 0, "TYPESTR",`
		1370	`TREGISTER, 0, "REGISTER",`
		1371	`TCONSTNT, 0, "CONSTNT",`
		1372	`TVOLATILE, 0, "VOLATILE",`
		1373	`TUNSIGNED, 0, "UNSIGNED",`
		1374	`TSIGNED, 0, "SIGNED",`
		1375	`TDOT, 0, "DOT",`
		1376	`TFILE, 0, "FILE",`
		1377	`TOLD, 0, "OLD",`
		1378	`-1, 0, 0,`
		1379	`};`
		1380	`char* cnames[NCTYPES];`
		1381	`Init cnamesinit[] =`
		1382	`{`
		1383	`CXXX, 0, "CXXX",`
		1384	`CAUTO, 0, "AUTO",`
		1385	`CEXTERN, 0, "EXTERN",`
		1386	`CGLOBL, 0, "GLOBL",`
		1387	`CSTATIC, 0, "STATIC",`
		1388	`CLOCAL, 0, "LOCAL",`
		1389	`CTYPEDEF, 0, "TYPEDEF",`
		1390	`CTYPESTR, 0, "TYPESTR",`
		1391	`CPARAM, 0, "PARAM",`
		1392	`CSELEM, 0, "SELEM",`
		1393	`CLABEL, 0, "LABEL",`
		1394	`CEXREG, 0, "EXREG",`
		1395	`-1, 0, 0,`
		1396	`};`
		1397
		1398	`char* onames[OEND+1];`
		1399	`Init onamesinit[] =`
		1400	`{`
		1401	`OXXX, 0, "OXXX",`
		1402	`OADD, 0, "ADD",`
		1403	`OADDR, 0, "ADDR",`
		1404	`OAND, 0, "AND",`
		1405	`OANDAND, 0, "ANDAND",`
		1406	`OARRAY, 0, "ARRAY",`
		1407	`OAS, 0, "AS",`
		1408	`OASI, 0, "ASI",`
		1409	`OASADD, 0, "ASADD",`
		1410	`OASAND, 0, "ASAND",`
		1411	`OASASHL, 0, "ASASHL",`
		1412	`OASASHR, 0, "ASASHR",`
		1413	`OASDIV, 0, "ASDIV",`
		1414	`OASHL, 0, "ASHL",`
		1415	`OASHR, 0, "ASHR",`
		1416	`OASLDIV, 0, "ASLDIV",`
		1417	`OASLMOD, 0, "ASLMOD",`
		1418	`OASLMUL, 0, "ASLMUL",`
		1419	`OASLSHR, 0, "ASLSHR",`
		1420	`OASMOD, 0, "ASMOD",`
		1421	`OASMUL, 0, "ASMUL",`
		1422	`OASOR, 0, "ASOR",`
		1423	`OASSUB, 0, "ASSUB",`
		1424	`OASXOR, 0, "ASXOR",`
		1425	`OBIT, 0, "BIT",`
		1426	`OBREAK, 0, "BREAK",`
		1427	`OCASE, 0, "CASE",`
		1428	`OCAST, 0, "CAST",`
		1429	`OCOMMA, 0, "COMMA",`
		1430	`OCOND, 0, "COND",`
		1431	`OCONST, 0, "CONST",`
		1432	`OCONTINUE, 0, "CONTINUE",`
		1433	`ODIV, 0, "DIV",`
		1434	`ODOT, 0, "DOT",`
		1435	`ODOTDOT, 0, "DOTDOT",`
		1436	`ODWHILE, 0, "DWHILE",`
		1437	`OENUM, 0, "ENUM",`
		1438	`OEQ, 0, "EQ",`
		1439	`OFOR, 0, "FOR",`
		1440	`OFUNC, 0, "FUNC",`
		1441	`OGE, 0, "GE",`
		1442	`OGOTO, 0, "GOTO",`
		1443	`OGT, 0, "GT",`
		1444	`OHI, 0, "HI",`
		1445	`OHS, 0, "HS",`
		1446	`OIF, 0, "IF",`
		1447	`OIND, 0, "IND",`
		1448	`OINDREG, 0, "INDREG",`
		1449	`OINIT, 0, "INIT",`
		1450	`OLABEL, 0, "LABEL",`
		1451	`OLDIV, 0, "LDIV",`
		1452	`OLE, 0, "LE",`
		1453	`OLIST, 0, "LIST",`
		1454	`OLMOD, 0, "LMOD",`
		1455	`OLMUL, 0, "LMUL",`
		1456	`OLO, 0, "LO",`
		1457	`OLS, 0, "LS",`
		1458	`OLSHR, 0, "LSHR",`
		1459	`OLT, 0, "LT",`
		1460	`OMOD, 0, "MOD",`
		1461	`OMUL, 0, "MUL",`
		1462	`ONAME, 0, "NAME",`
		1463	`ONE, 0, "NE",`
		1464	`ONOT, 0, "NOT",`
		1465	`OOR, 0, "OR",`
		1466	`OOROR, 0, "OROR",`
		1467	`OPOSTDEC, 0, "POSTDEC",`
		1468	`OPOSTINC, 0, "POSTINC",`
		1469	`OPREDEC, 0, "PREDEC",`
		1470	`OPREINC, 0, "PREINC",`
		1471	`OPROTO, 0, "PROTO",`
		1472	`OREGISTER, 0, "REGISTER",`
		1473	`ORETURN, 0, "RETURN",`
		1474	`OSET, 0, "SET",`
		1475	`OSIGN, 0, "SIGN",`
		1476	`OSIZE, 0, "SIZE",`
		1477	`OSTRING, 0, "STRING",`
		1478	`OLSTRING, 0, "LSTRING",`
		1479	`OSTRUCT, 0, "STRUCT",`
		1480	`OSUB, 0, "SUB",`
		1481	`OSWITCH, 0, "SWITCH",`
		1482	`OUNION, 0, "UNION",`
		1483	`OUSED, 0, "USED",`
		1484	`OWHILE, 0, "WHILE",`
		1485	`OXOR, 0, "XOR",`
		1486	`OPOS, 0, "POS",`
		1487	`ONEG, 0, "NEG",`
		1488	`OCOM, 0, "COM",`
		1489	`OELEM, 0, "ELEM",`
		1490	`OTST, 0, "TST",`
		1491	`OINDEX, 0, "INDEX",`
		1492	`OFAS, 0, "FAS",`
		1493	`OREGPAIR, 0, "REGPAIR",`
		1494	`OEXREG, 0, "EXREG",`
		1495	`OEND, 0, "END",`
		1496	`-1, 0, 0,`
		1497	`};`
		1498
		1499	`/* OEQ, ONE, OLE, OLS, OLT, OLO, OGE, OHS, OGT, OHI */`
		1500	`char comrel[12] =`
		1501	`{`
		1502	`ONE, OEQ, OGT, OHI, OGE, OHS, OLT, OLO, OLE, OLS,`
		1503	`};`
		1504	`char invrel[12] =`
		1505	`{`
		1506	`OEQ, ONE, OGE, OHS, OGT, OHI, OLE, OLS, OLT, OLO,`
		1507	`};`
		1508	`char logrel[12] =`
		1509	`{`
		1510	`OEQ, ONE, OLS, OLS, OLO, OLO, OHS, OHS, OHI, OHI,`
		1511	`};`
		1512
		1513	`char typei[NTYPE];`
		1514	`int typeiinit[] =`
		1515	`{`
		1516	`TCHAR, TUCHAR, TSHORT, TUSHORT, TINT, TUINT, TLONG, TULONG, TVLONG, TUVLONG, -1,`
		1517	`};`
		1518	`char typeu[NTYPE];`
		1519	`int typeuinit[] =`
		1520	`{`
		1521	`TUCHAR, TUSHORT, TUINT, TULONG, TUVLONG, TIND, -1,`
		1522	`};`
		1523
		1524	`char typesuv[NTYPE];`
		1525	`int typesuvinit[] =`
		1526	`{`
		1527	`TVLONG, TUVLONG, TSTRUCT, TUNION, -1,`
		1528	`};`
		1529
		1530	`char typeilp[NTYPE];`
		1531	`int typeilpinit[] =`
		1532	`{`
		1533	`TINT, TUINT, TLONG, TULONG, TIND, -1`
		1534	`};`
		1535
		1536	`char typechl[NTYPE];`
		1537	`char typechlv[NTYPE];`
		1538	`char typechlvp[NTYPE];`
		1539	`int typechlinit[] =`
		1540	`{`
		1541	`TCHAR, TUCHAR, TSHORT, TUSHORT, TINT, TUINT, TLONG, TULONG, -1,`
		1542	`};`
		1543
		1544	`char typechlp[NTYPE];`
		1545	`int typechlpinit[] =`
		1546	`{`
		1547	`TCHAR, TUCHAR, TSHORT, TUSHORT, TINT, TUINT, TLONG, TULONG, TIND, -1,`
		1548	`};`
		1549
		1550	`char typechlpfd[NTYPE];`
		1551	`int typechlpfdinit[] =`
		1552	`{`
		1553	`TCHAR, TUCHAR, TSHORT, TUSHORT, TINT, TUINT, TLONG, TULONG, TFLOAT, TDOUBLE, TIND, -1,`
		1554	`};`
		1555
		1556	`char typec[NTYPE];`
		1557	`int typecinit[] =`
		1558	`{`
		1559	`TCHAR, TUCHAR, -1`
		1560	`};`
		1561
		1562	`char typeh[NTYPE];`
		1563	`int typehinit[] =`
		1564	`{`
		1565	`TSHORT, TUSHORT, -1,`
		1566	`};`
		1567
		1568	`char typeil[NTYPE];`
		1569	`int typeilinit[] =`
		1570	`{`
		1571	`TINT, TUINT, TLONG, TULONG, -1,`
		1572	`};`
		1573
		1574	`char typev[NTYPE];`
		1575	`int typevinit[] =`
		1576	`{`
		1577	`TVLONG, TUVLONG, -1,`
		1578	`};`
		1579
		1580	`char typefd[NTYPE];`
		1581	`int typefdinit[] =`
		1582	`{`
		1583	`TFLOAT, TDOUBLE, -1,`
		1584	`};`
		1585
		1586	`char typeaf[NTYPE];`
		1587	`int typeafinit[] =`
		1588	`{`
		1589	`TFUNC, TARRAY, -1,`
		1590	`};`
		1591
		1592	`char typesu[NTYPE];`
		1593	`int typesuinit[] =`
		1594	`{`
		1595	`TSTRUCT, TUNION, -1,`
		1596	`};`
		1597
		1598	`long tasign[NTYPE];`
		1599	`Init tasigninit[] =`
		1600	`{`
		1601	`TCHAR, BNUMBER, 0,`
		1602	`TUCHAR, BNUMBER, 0,`
		1603	`TSHORT, BNUMBER, 0,`
		1604	`TUSHORT, BNUMBER, 0,`
		1605	`TINT, BNUMBER, 0,`
		1606	`TUINT, BNUMBER, 0,`
		1607	`TLONG, BNUMBER, 0,`
		1608	`TULONG, BNUMBER, 0,`
		1609	`TVLONG, BNUMBER, 0,`
		1610	`TUVLONG, BNUMBER, 0,`
		1611	`TFLOAT, BNUMBER, 0,`
		1612	`TDOUBLE, BNUMBER, 0,`
		1613	`TIND, BIND, 0,`
		1614	`TSTRUCT, BSTRUCT, 0,`
		1615	`TUNION, BUNION, 0,`
		1616	`-1, 0, 0,`
		1617	`};`
		1618
		1619	`long tasadd[NTYPE];`
		1620	`Init tasaddinit[] =`
		1621	`{`
		1622	`TCHAR, BNUMBER, 0,`
		1623	`TUCHAR, BNUMBER, 0,`
		1624	`TSHORT, BNUMBER, 0,`
		1625	`TUSHORT, BNUMBER, 0,`
		1626	`TINT, BNUMBER, 0,`
		1627	`TUINT, BNUMBER, 0,`
		1628	`TLONG, BNUMBER, 0,`
		1629	`TULONG, BNUMBER, 0,`
		1630	`TVLONG, BNUMBER, 0,`
		1631	`TUVLONG, BNUMBER, 0,`
		1632	`TFLOAT, BNUMBER, 0,`
		1633	`TDOUBLE, BNUMBER, 0,`
		1634	`TIND, BINTEGER, 0,`
		1635	`-1, 0, 0,`
		1636	`};`
		1637
		1638	`long tcast[NTYPE];`
		1639	`Init tcastinit[] =`
		1640	`{`
		1641	`TCHAR, BNUMBER\|BIND\|BVOID, 0,`
		1642	`TUCHAR, BNUMBER\|BIND\|BVOID, 0,`
		1643	`TSHORT, BNUMBER\|BIND\|BVOID, 0,`
		1644	`TUSHORT, BNUMBER\|BIND\|BVOID, 0,`
		1645	`TINT, BNUMBER\|BIND\|BVOID, 0,`
		1646	`TUINT, BNUMBER\|BIND\|BVOID, 0,`
		1647	`TLONG, BNUMBER\|BIND\|BVOID, 0,`
		1648	`TULONG, BNUMBER\|BIND\|BVOID, 0,`
		1649	`TVLONG, BNUMBER\|BIND\|BVOID, 0,`
		1650	`TUVLONG, BNUMBER\|BIND\|BVOID, 0,`
		1651	`TFLOAT, BNUMBER\|BVOID, 0,`
		1652	`TDOUBLE, BNUMBER\|BVOID, 0,`
		1653	`TIND, BINTEGER\|BIND\|BVOID, 0,`
		1654	`TVOID, BVOID, 0,`
		1655	`TSTRUCT, BSTRUCT\|BVOID, 0,`
		1656	`TUNION, BUNION\|BVOID, 0,`
		1657	`-1, 0, 0,`
		1658	`};`
		1659
		1660	`long tadd[NTYPE];`
		1661	`Init taddinit[] =`
		1662	`{`
		1663	`TCHAR, BNUMBER\|BIND, 0,`
		1664	`TUCHAR, BNUMBER\|BIND, 0,`
		1665	`TSHORT, BNUMBER\|BIND, 0,`
		1666	`TUSHORT, BNUMBER\|BIND, 0,`
		1667	`TINT, BNUMBER\|BIND, 0,`
		1668	`TUINT, BNUMBER\|BIND, 0,`
		1669	`TLONG, BNUMBER\|BIND, 0,`
		1670	`TULONG, BNUMBER\|BIND, 0,`
		1671	`TVLONG, BNUMBER\|BIND, 0,`
		1672	`TUVLONG, BNUMBER\|BIND, 0,`
		1673	`TFLOAT, BNUMBER, 0,`
		1674	`TDOUBLE, BNUMBER, 0,`
		1675	`TIND, BINTEGER, 0,`
		1676	`-1, 0, 0,`
		1677	`};`
		1678
		1679	`long tsub[NTYPE];`
		1680	`Init tsubinit[] =`
		1681	`{`
		1682	`TCHAR, BNUMBER, 0,`
		1683	`TUCHAR, BNUMBER, 0,`
		1684	`TSHORT, BNUMBER, 0,`
		1685	`TUSHORT, BNUMBER, 0,`
		1686	`TINT, BNUMBER, 0,`
		1687	`TUINT, BNUMBER, 0,`
		1688	`TLONG, BNUMBER, 0,`
		1689	`TULONG, BNUMBER, 0,`
		1690	`TVLONG, BNUMBER, 0,`
		1691	`TUVLONG, BNUMBER, 0,`
		1692	`TFLOAT, BNUMBER, 0,`
		1693	`TDOUBLE, BNUMBER, 0,`
		1694	`TIND, BINTEGER\|BIND, 0,`
		1695	`-1, 0, 0,`
		1696	`};`
		1697
		1698	`long tmul[NTYPE];`
		1699	`Init tmulinit[] =`
		1700	`{`
		1701	`TCHAR, BNUMBER, 0,`
		1702	`TUCHAR, BNUMBER, 0,`
		1703	`TSHORT, BNUMBER, 0,`
		1704	`TUSHORT, BNUMBER, 0,`
		1705	`TINT, BNUMBER, 0,`
		1706	`TUINT, BNUMBER, 0,`
		1707	`TLONG, BNUMBER, 0,`
		1708	`TULONG, BNUMBER, 0,`
		1709	`TVLONG, BNUMBER, 0,`
		1710	`TUVLONG, BNUMBER, 0,`
		1711	`TFLOAT, BNUMBER, 0,`
		1712	`TDOUBLE, BNUMBER, 0,`
		1713	`-1, 0, 0,`
		1714	`};`
		1715
		1716	`long tand[NTYPE];`
		1717	`Init tandinit[] =`
		1718	`{`
		1719	`TCHAR, BINTEGER, 0,`
		1720	`TUCHAR, BINTEGER, 0,`
		1721	`TSHORT, BINTEGER, 0,`
		1722	`TUSHORT, BINTEGER, 0,`
		1723	`TINT, BNUMBER, 0,`
		1724	`TUINT, BNUMBER, 0,`
		1725	`TLONG, BINTEGER, 0,`
		1726	`TULONG, BINTEGER, 0,`
		1727	`TVLONG, BINTEGER, 0,`
		1728	`TUVLONG, BINTEGER, 0,`
		1729	`-1, 0, 0,`
		1730	`};`
		1731
		1732	`long trel[NTYPE];`
		1733	`Init trelinit[] =`
		1734	`{`
		1735	`TCHAR, BNUMBER, 0,`
		1736	`TUCHAR, BNUMBER, 0,`
		1737	`TSHORT, BNUMBER, 0,`
		1738	`TUSHORT, BNUMBER, 0,`
		1739	`TINT, BNUMBER, 0,`
		1740	`TUINT, BNUMBER, 0,`
		1741	`TLONG, BNUMBER, 0,`
		1742	`TULONG, BNUMBER, 0,`
		1743	`TVLONG, BNUMBER, 0,`
		1744	`TUVLONG, BNUMBER, 0,`
		1745	`TFLOAT, BNUMBER, 0,`
		1746	`TDOUBLE, BNUMBER, 0,`
		1747	`TIND, BIND, 0,`
		1748	`-1, 0, 0,`
		1749	`};`
		1750
		1751	`long tfunct[1] =`
		1752	`{`
		1753	`BFUNC,`
		1754	`};`
		1755
		1756	`long tindir[1] =`
		1757	`{`
		1758	`BIND,`
		1759	`};`
		1760
		1761	`long tdot[1] =`
		1762	`{`
		1763	`BSTRUCT\|BUNION,`
		1764	`};`
		1765
		1766	`long tnot[1] =`
		1767	`{`
		1768	`BNUMBER\|BIND,`
		1769	`};`
		1770
		1771	`long targ[1] =`
		1772	`{`
		1773	`BNUMBER\|BIND\|BSTRUCT\|BUNION,`
		1774	`};`
		1775
		1776	`char tab[NTYPE][NTYPE] =`
		1777	`{`
		1778	`/TXXX/ { 0,`
		1779	`},`
		1780
		1781	`/TCHAR/ { 0, TCHAR, TUCHAR, TSHORT, TUSHORT, TINT, TUINT, TLONG,`
		1782	`TULONG, TVLONG, TUVLONG, TFLOAT, TDOUBLE, TIND,`
		1783	`},`
		1784	`/TUCHAR/ { 0, TUCHAR, TUCHAR, TUSHORT, TUSHORT, TUINT, TUINT, TULONG,`
		1785	`TULONG, TUVLONG, TUVLONG, TFLOAT, TDOUBLE, TIND,`
		1786	`},`
		1787	`/TSHORT/ { 0, TSHORT, TUSHORT, TSHORT, TUSHORT, TINT, TUINT, TLONG,`
		1788	`TULONG, TVLONG, TUVLONG, TFLOAT, TDOUBLE, TIND,`
		1789	`},`
		1790	`/TUSHORT/ { 0, TUSHORT, TUSHORT, TUSHORT, TUSHORT, TUINT, TUINT, TULONG,`
		1791	`TULONG, TUVLONG, TUVLONG, TFLOAT, TDOUBLE, TIND,`
		1792	`},`
		1793	`/TINT/ { 0, TINT, TUINT, TINT, TUINT, TINT, TUINT, TLONG,`
		1794	`TULONG, TVLONG, TUVLONG, TFLOAT, TDOUBLE, TIND,`
		1795	`},`
		1796	`/TUINT/ { 0, TUINT, TUINT, TUINT, TUINT, TUINT, TUINT, TULONG,`
		1797	`TULONG, TUVLONG, TUVLONG, TFLOAT, TDOUBLE, TIND,`
		1798	`},`
		1799	`/TLONG/ { 0, TLONG, TULONG, TLONG, TULONG, TLONG, TULONG, TLONG,`
		1800	`TULONG, TVLONG, TUVLONG, TFLOAT, TDOUBLE, TIND,`
		1801	`},`
		1802	`/TULONG/ { 0, TULONG, TULONG, TULONG, TULONG, TULONG, TULONG, TULONG,`
		1803	`TULONG, TUVLONG, TUVLONG, TFLOAT, TDOUBLE, TIND,`
		1804	`},`
		1805	`/TVLONG/ { 0, TVLONG, TUVLONG, TVLONG, TUVLONG, TVLONG, TUVLONG, TVLONG,`
		1806	`TUVLONG, TVLONG, TUVLONG, TFLOAT, TDOUBLE, TIND,`
		1807	`},`
		1808	`/TUVLONG/ { 0, TUVLONG, TUVLONG, TUVLONG, TUVLONG, TUVLONG, TUVLONG, TUVLONG,`
		1809	`TUVLONG, TUVLONG, TUVLONG, TFLOAT, TDOUBLE, TIND,`
		1810	`},`
		1811	`/TFLOAT/ { 0, TFLOAT, TFLOAT, TFLOAT, TFLOAT, TFLOAT, TFLOAT, TFLOAT,`
		1812	`TFLOAT, TFLOAT, TFLOAT, TFLOAT, TDOUBLE, TIND,`
		1813	`},`
		1814	`/TDOUBLE/ { 0, TDOUBLE, TDOUBLE, TDOUBLE, TDOUBLE, TDOUBLE, TDOUBLE, TDOUBLE,`
		1815	`TDOUBLE, TDOUBLE, TDOUBLE, TFLOAT, TDOUBLE, TIND,`
		1816	`},`
		1817	`/TIND/ { 0, TIND, TIND, TIND, TIND, TIND, TIND, TIND,`
		1818	`TIND, TIND, TIND, TIND, TIND, TIND,`
		1819	`},`
		1820	`};`
		1821
		1822	`void`
		1823	`urk(char *name, int max, int i)`
		1824	`{`
		1825	`if(i >= max) {`
		1826	`fprint(2, "bad tinit: %s %d>=%d\n", name, i, max);`
		1827	`exits("init");`
		1828	`}`
		1829	`}`
		1830
		1831	`void`
		1832	`tinit(void)`
		1833	`{`
		1834	`int *ip;`
		1835	`Init *p;`
		1836
		1837	`for(p=thashinit; p->code >= 0; p++) {`
		1838	`urk("thash", nelem(thash), p->code);`
		1839	`thash[p->code] = p->value;`
		1840	`}`
		1841	`for(p=bnamesinit; p->code >= 0; p++) {`
		1842	`urk("bnames", nelem(bnames), p->code);`
		1843	`bnames[p->code] = p->s;`
		1844	`}`
		1845	`for(p=tnamesinit; p->code >= 0; p++) {`
		1846	`urk("tnames", nelem(tnames), p->code);`
		1847	`tnames[p->code] = p->s;`
		1848	`}`
		1849	`for(p=gnamesinit; p->code >= 0; p++) {`
		1850	`urk("gnames", nelem(gnames), p->code);`
		1851	`gnames[p->code] = p->s;`
		1852	`}`
		1853	`for(p=qnamesinit; p->code >= 0; p++) {`
		1854	`urk("qnames", nelem(qnames), p->code);`
		1855	`qnames[p->code] = p->s;`
		1856	`}`
		1857	`for(p=cnamesinit; p->code >= 0; p++) {`
		1858	`urk("cnames", nelem(cnames), p->code);`
		1859	`cnames[p->code] = p->s;`
		1860	`}`
		1861	`for(p=onamesinit; p->code >= 0; p++) {`
		1862	`urk("onames", nelem(onames), p->code);`
		1863	`onames[p->code] = p->s;`
		1864	`}`
		1865	`for(ip=typeiinit; *ip>=0; ip++) {`
		1866	`urk("typei", nelem(typei), *ip);`
		1867	`typei[*ip] = 1;`
		1868	`}`
		1869	`for(ip=typeuinit; *ip>=0; ip++) {`
		1870	`urk("typeu", nelem(typeu), *ip);`
		1871	`typeu[*ip] = 1;`
		1872	`}`
		1873	`for(ip=typesuvinit; *ip>=0; ip++) {`
		1874	`urk("typesuv", nelem(typesuv), *ip);`
		1875	`typesuv[*ip] = 1;`
		1876	`}`
		1877	`for(ip=typeilpinit; *ip>=0; ip++) {`
		1878	`urk("typeilp", nelem(typeilp), *ip);`
		1879	`typeilp[*ip] = 1;`
		1880	`}`
		1881	`for(ip=typechlinit; *ip>=0; ip++) {`
		1882	`urk("typechl", nelem(typechl), *ip);`
		1883	`typechl[*ip] = 1;`
		1884	`typechlv[*ip] = 1;`
		1885	`typechlvp[*ip] = 1;`
		1886	`}`
		1887	`for(ip=typechlpinit; *ip>=0; ip++) {`
		1888	`urk("typechlp", nelem(typechlp), *ip);`
		1889	`typechlp[*ip] = 1;`
		1890	`typechlvp[*ip] = 1;`
		1891	`}`
		1892	`for(ip=typechlpfdinit; *ip>=0; ip++) {`
		1893	`urk("typechlpfd", nelem(typechlpfd), *ip);`
		1894	`typechlpfd[*ip] = 1;`
		1895	`}`
		1896	`for(ip=typecinit; *ip>=0; ip++) {`
		1897	`urk("typec", nelem(typec), *ip);`
		1898	`typec[*ip] = 1;`
		1899	`}`
		1900	`for(ip=typehinit; *ip>=0; ip++) {`
		1901	`urk("typeh", nelem(typeh), *ip);`
		1902	`typeh[*ip] = 1;`
		1903	`}`
		1904	`for(ip=typeilinit; *ip>=0; ip++) {`
		1905	`urk("typeil", nelem(typeil), *ip);`
		1906	`typeil[*ip] = 1;`
		1907	`}`
		1908	`for(ip=typevinit; *ip>=0; ip++) {`
		1909	`urk("typev", nelem(typev), *ip);`
		1910	`typev[*ip] = 1;`
		1911	`typechlv[*ip] = 1;`
		1912	`typechlvp[*ip] = 1;`
		1913	`}`
		1914	`for(ip=typefdinit; *ip>=0; ip++) {`
		1915	`urk("typefd", nelem(typefd), *ip);`
		1916	`typefd[*ip] = 1;`
		1917	`}`
		1918	`for(ip=typeafinit; *ip>=0; ip++) {`
		1919	`urk("typeaf", nelem(typeaf), *ip);`
		1920	`typeaf[*ip] = 1;`
		1921	`}`
		1922	`for(ip=typesuinit; *ip >= 0; ip++) {`
		1923	`urk("typesu", nelem(typesu), *ip);`
		1924	`typesu[*ip] = 1;`
		1925	`}`
		1926	`for(p=tasigninit; p->code >= 0; p++) {`
		1927	`urk("tasign", nelem(tasign), p->code);`
		1928	`tasign[p->code] = p->value;`
		1929	`}`
		1930	`for(p=tasaddinit; p->code >= 0; p++) {`
		1931	`urk("tasadd", nelem(tasadd), p->code);`
		1932	`tasadd[p->code] = p->value;`
		1933	`}`
		1934	`for(p=tcastinit; p->code >= 0; p++) {`
		1935	`urk("tcast", nelem(tcast), p->code);`
		1936	`tcast[p->code] = p->value;`
		1937	`}`
		1938	`for(p=taddinit; p->code >= 0; p++) {`
		1939	`urk("tadd", nelem(tadd), p->code);`
		1940	`tadd[p->code] = p->value;`
		1941	`}`
		1942	`for(p=tsubinit; p->code >= 0; p++) {`
		1943	`urk("tsub", nelem(tsub), p->code);`
		1944	`tsub[p->code] = p->value;`
		1945	`}`
		1946	`for(p=tmulinit; p->code >= 0; p++) {`
		1947	`urk("tmul", nelem(tmul), p->code);`
		1948	`tmul[p->code] = p->value;`
		1949	`}`
		1950	`for(p=tandinit; p->code >= 0; p++) {`
		1951	`urk("tand", nelem(tand), p->code);`
		1952	`tand[p->code] = p->value;`
		1953	`}`
		1954	`for(p=trelinit; p->code >= 0; p++) {`
		1955	`urk("trel", nelem(trel), p->code);`
		1956	`trel[p->code] = p->value;`
		1957	`}`
		1958
		1959	`/* 32-bit defaults */`
		1960	`typeword = typechlp;`
		1961	`typeswitch = typechl;`
		1962	`typecmplx = typesuv;`
		1963	`}`
		1964
		1965	`/*`
		1966	`* return 1 if it is impossible to jump into the middle of n.`
		1967	`*/`
		1968	`static int`
		1969	`deadhead(Node *n, int caseok)`
		1970	`{`
		1971	`loop:`
		1972	`if(n == Z)`
		1973	`return 1;`
		1974	`switch(n->op) {`
		1975	`case OLIST:`
		1976	`if(!deadhead(n->left, caseok))`
		1977	`return 0;`
		1978	`rloop:`
		1979	`n = n->right;`
		1980	`goto loop;`
		1981
		1982	`case ORETURN:`
		1983	`break;`
		1984
		1985	`case OLABEL:`
		1986	`return 0;`
		1987
		1988	`case OGOTO:`
		1989	`break;`
		1990
		1991	`case OCASE:`
		1992	`if(!caseok)`
		1993	`return 0;`
		1994	`goto rloop;`
		1995
		1996	`case OSWITCH:`
		1997	`return deadhead(n->right, 1);`
		1998
		1999	`case OWHILE:`
		2000	`case ODWHILE:`
		2001	`goto rloop;`
		2002
		2003	`case OFOR:`
		2004	`goto rloop;`
		2005
		2006	`case OCONTINUE:`
		2007	`break;`
		2008
		2009	`case OBREAK:`
		2010	`break;`
		2011
		2012	`case OIF:`
		2013	`return deadhead(n->right->left, caseok) && deadhead(n->right->right, caseok);`
		2014
		2015	`case OSET:`
		2016	`case OUSED:`
		2017	`break;`
		2018	`}`
		2019	`return 1;`
		2020	`}`
		2021
		2022	`int`
		2023	`deadheads(Node *c)`
		2024	`{`
		2025	`return deadhead(c->left, 0) && deadhead(c->right, 0);`
		2026	`}`
		2027
		2028	`int`
		2029	`mixedasop(Type l, Type r)`
		2030	`{`
		2031	`return !typefd[l->etype] && typefd[r->etype];`
		2032	`}`

Subversion Repositories planix.SVN

(root)/os/trunk/sys/src/cmd/cc/sub.c – Rev 2