WebSVN – planix.SVN – Blame – /os/branches/feature_unix/sys/src/cmd/8c/txt.c

Rev	Author	Line No.	Line
2	-	1	`#include "gc.h"`
		2
		3	`void`
		4	`ginit(void)`
		5	`{`
		6	`int i;`
		7	`Type *t;`
		8
		9	`thechar = '8';`
		10	`thestring = "386";`
		11	`exregoffset = 0;`
		12	`exfregoffset = 0;`
		13	`listinit();`
		14	`nstring = 0;`
		15	`mnstring = 0;`
		16	`nrathole = 0;`
		17	`pc = 0;`
		18	`breakpc = -1;`
		19	`continpc = -1;`
		20	`cases = C;`
		21	`firstp = P;`
		22	`lastp = P;`
		23	`tfield = types[TLONG];`
		24
		25	`typeswitch = typechlv;`
		26
		27	`zprog.link = P;`
		28	`zprog.as = AGOK;`
		29	`zprog.from.type = D_NONE;`
		30	`zprog.from.index = D_NONE;`
		31	`zprog.from.scale = 0;`
		32	`zprog.to = zprog.from;`
		33
		34	`regnode.op = OREGISTER;`
		35	`regnode.class = CEXREG;`
		36	`regnode.reg = REGTMP;`
		37	`regnode.complex = 0;`
		38	`regnode.addable = 11;`
		39	`regnode.type = types[TLONG];`
		40
		41	`fregnode0 = regnode;`
		42	`fregnode0.reg = D_F0;`
		43	`fregnode0.type = types[TDOUBLE];`
		44
		45	`fregnode1 = fregnode0;`
		46	`fregnode1.reg = D_F0+1;`
		47
		48	`constnode.op = OCONST;`
		49	`constnode.class = CXXX;`
		50	`constnode.complex = 0;`
		51	`constnode.addable = 20;`
		52	`constnode.type = types[TLONG];`
		53
		54	`fconstnode.op = OCONST;`
		55	`fconstnode.class = CXXX;`
		56	`fconstnode.complex = 0;`
		57	`fconstnode.addable = 20;`
		58	`fconstnode.type = types[TDOUBLE];`
		59
		60	`nodsafe = new(ONAME, Z, Z);`
		61	`nodsafe->sym = slookup(".safe");`
		62	`nodsafe->type = types[TINT];`
		63	`nodsafe->etype = types[TINT]->etype;`
		64	`nodsafe->class = CAUTO;`
		65	`complex(nodsafe);`
		66
		67	`t = typ(TARRAY, types[TCHAR]);`
		68	`symrathole = slookup(".rathole");`
		69	`symrathole->class = CGLOBL;`
		70	`symrathole->type = t;`
		71
		72	`nodrat = new(ONAME, Z, Z);`
		73	`nodrat->sym = symrathole;`
		74	`nodrat->type = types[TIND];`
		75	`nodrat->etype = TVOID;`
		76	`nodrat->class = CGLOBL;`
		77	`complex(nodrat);`
		78	`nodrat->type = t;`
		79
		80	`nodret = new(ONAME, Z, Z);`
		81	`nodret->sym = slookup(".ret");`
		82	`nodret->type = types[TIND];`
		83	`nodret->etype = TIND;`
		84	`nodret->class = CPARAM;`
		85	`nodret = new(OIND, nodret, Z);`
		86	`complex(nodret);`
		87
		88	`com64init();`
		89
		90	`for(i=0; i<nelem(reg); i++) {`
		91	`reg[i] = 1;`
		92	`if(i >= D_AX && i <= D_DI && i != D_SP)`
		93	`reg[i] = 0;`
		94	`}`
		95	`}`
		96
		97	`void`
		98	`gclean(void)`
		99	`{`
		100	`int i;`
		101	`Sym *s;`
		102
		103	`reg[D_SP]--;`
		104	`for(i=D_AX; i<=D_DI; i++)`
		105	`if(reg[i])`
		106	`diag(Z, "reg %R left allocated", i);`
		107	`while(mnstring)`
		108	`outstring("", 1L);`
		109	`symstring->type->width = nstring;`
		110	`symrathole->type->width = nrathole;`
		111	`for(i=0; i<NHASH; i++)`
		112	`for(s = hash[i]; s != S; s = s->link) {`
		113	`if(s->type == T)`
		114	`continue;`
		115	`if(s->type->width == 0)`
		116	`continue;`
		117	`if(s->class != CGLOBL && s->class != CSTATIC)`
		118	`continue;`
		119	`if(s->type == types[TENUM])`
		120	`continue;`
		121	`gpseudo(AGLOBL, s, nodconst(s->type->width));`
		122	`}`
		123	`nextpc();`
		124	`p->as = AEND;`
		125	`outcode();`
		126	`}`
		127
		128	`void`
		129	`nextpc(void)`
		130	`{`
		131
		132	`p = alloc(sizeof(*p));`
		133	`*p = zprog;`
		134	`p->lineno = nearln;`
		135	`pc++;`
		136	`if(firstp == P) {`
		137	`firstp = p;`
		138	`lastp = p;`
		139	`return;`
		140	`}`
		141	`lastp->link = p;`
		142	`lastp = p;`
		143	`}`
		144
		145	`void`
		146	`gargs(Node n, Node tn1, Node *tn2)`
		147	`{`
		148	`long regs;`
		149	`Node fnxargs[20], *fnxp;`
		150
		151	`regs = cursafe;`
		152
		153	`fnxp = fnxargs;`
		154	`garg1(n, tn1, tn2, 0, &fnxp); /* compile fns to temps */`
		155
		156	`curarg = 0;`
		157	`fnxp = fnxargs;`
		158	`garg1(n, tn1, tn2, 1, &fnxp); /* compile normal args and temps */`
		159
		160	`cursafe = regs;`
		161	`}`
		162
		163	`int`
		164	`nareg(int notbp)`
		165	`{`
		166	`int i, n;`
		167
		168	`n = 0;`
		169	`for(i=D_AX; i<=D_DI; i++)`
		170	`if(reg[i] == 0)`
		171	`n++;`
		172	`if(notbp && reg[D_BP] == 0)`
		173	`n--;`
		174	`return n;`
		175	`}`
		176
		177	`void`
		178	`garg1(Node n, Node tn1, Node tn2, int f, Node *fnxp)`
		179	`{`
		180	`Node nod;`
		181
		182	`if(n == Z)`
		183	`return;`
		184	`if(n->op == OLIST) {`
		185	`garg1(n->left, tn1, tn2, f, fnxp);`
		186	`garg1(n->right, tn1, tn2, f, fnxp);`
		187	`return;`
		188	`}`
		189	`if(f == 0) {`
		190	`if(n->complex >= FNX) {`
		191	`regsalloc(*fnxp, n);`
		192	`nod = znode;`
		193	`nod.op = OAS;`
		194	`nod.left = *fnxp;`
		195	`nod.right = n;`
		196	`nod.type = n->type;`
		197	`cgen(&nod, Z);`
		198	`(*fnxp)++;`
		199	`}`
		200	`return;`
		201	`}`
		202	`if(typesu[n->type->etype] \|\| typev[n->type->etype]) {`
		203	`regaalloc(tn2, n);`
		204	`if(n->complex >= FNX) {`
		205	`sugen(*fnxp, tn2, n->type->width);`
		206	`(*fnxp)++;`
		207	`} else`
		208	`sugen(n, tn2, n->type->width);`
		209	`return;`
		210	`}`
		211	`if(REGARG>=0 && curarg == 0 && typeilp[n->type->etype]) {`
		212	`regaalloc1(tn1, n);`
		213	`if(n->complex >= FNX) {`
		214	`cgen(*fnxp, tn1);`
		215	`(*fnxp)++;`
		216	`} else`
		217	`cgen(n, tn1);`
		218	`return;`
		219	`}`
		220	`if(vconst(n) == 0) {`
		221	`regaalloc(tn2, n);`
		222	`gmove(n, tn2);`
		223	`return;`
		224	`}`
		225	`regalloc(tn1, n, Z);`
		226	`if(n->complex >= FNX) {`
		227	`cgen(*fnxp, tn1);`
		228	`(*fnxp)++;`
		229	`} else`
		230	`cgen(n, tn1);`
		231	`regaalloc(tn2, n);`
		232	`gmove(tn1, tn2);`
		233	`regfree(tn1);`
		234	`}`
		235
		236	`Node*`
		237	`nodconst(long v)`
		238	`{`
		239	`constnode.vconst = v;`
		240	`return &constnode;`
		241	`}`
		242
		243	`Node*`
		244	`nodfconst(double d)`
		245	`{`
		246	`fconstnode.fconst = d;`
		247	`return &fconstnode;`
		248	`}`
		249
		250	`int`
		251	`isreg(Node *n, int r)`
		252	`{`
		253
		254	`if(n->op == OREGISTER)`
		255	`if(n->reg == r)`
		256	`return 1;`
		257	`return 0;`
		258	`}`
		259
		260	`int`
		261	`nodreg(Node n, Node nn, int r)`
		262	`{`
		263
		264	`*n = regnode;`
		265	`n->reg = r;`
		266	`if(reg[r] == 0)`
		267	`return 0;`
		268	`if(nn != Z) {`
		269	`n->type = nn->type;`
		270	`n->lineno = nn->lineno;`
		271	`if(nn->op == OREGISTER)`
		272	`if(nn->reg == r)`
		273	`return 0;`
		274	`}`
		275	`return 1;`
		276	`}`
		277
		278	`void`
		279	`regret(Node n, Node nn)`
		280	`{`
		281	`int r;`
		282
		283	`r = REGRET;`
		284	`if(typefd[nn->type->etype])`
		285	`r = FREGRET;`
		286	`nodreg(n, nn, r);`
		287	`reg[r]++;`
		288	`}`
		289
		290	`void`
		291	`regalloc(Node n, Node tn, Node *o)`
		292	`{`
		293	`int i;`
		294
		295	`switch(tn->type->etype) {`
		296	`case TCHAR:`
		297	`case TUCHAR:`
		298	`case TSHORT:`
		299	`case TUSHORT:`
		300	`case TINT:`
		301	`case TUINT:`
		302	`case TLONG:`
		303	`case TULONG:`
		304	`case TIND:`
		305	`if(o != Z && o->op == OREGISTER) {`
		306	`i = o->reg;`
		307	`if(i >= D_AX && i <= D_DI)`
		308	`goto out;`
		309	`}`
		310	`for(i=D_AX; i<=D_DI; i++)`
		311	`if(reg[i] == 0)`
		312	`goto out;`
		313	`diag(tn, "out of fixed registers");`
		314	`abort();`
		315	`goto err;`
		316
		317	`case TFLOAT:`
		318	`case TDOUBLE:`
		319	`i = D_F0;`
		320	`goto out;`
		321
		322	`case TVLONG:`
		323	`case TUVLONG:`
		324	`n->op = OREGPAIR;`
		325	`n->complex = 0; /* already in registers */`
		326	`n->addable = 11;`
		327	`n->type = tn->type;`
		328	`n->lineno = nearln;`
		329	`n->left = alloc(sizeof(Node));`
		330	`n->right = alloc(sizeof(Node));`
		331	`if(o != Z && o->op == OREGPAIR) {`
		332	`regalloc(n->left, &regnode, o->left);`
		333	`regalloc(n->right, &regnode, o->right);`
		334	`} else {`
		335	`regalloc(n->left, &regnode, Z);`
		336	`regalloc(n->right, &regnode, Z);`
		337	`}`
		338	`n->right->type = types[TULONG];`
		339	`if(tn->type->etype == TUVLONG)`
		340	`n->left->type = types[TULONG];`
		341	`return;`
		342	`}`
		343	`diag(tn, "unknown type in regalloc: %T", tn->type);`
		344	`err:`
		345	`i = 0;`
		346	`out:`
		347	`if(i)`
		348	`reg[i]++;`
		349	`nodreg(n, tn, i);`
		350	`//print("+ %R %d\n", i, reg[i]);`
		351	`}`
		352
		353	`void`
		354	`regialloc(Node n, Node tn, Node *o)`
		355	`{`
		356	`Node nod;`
		357
		358	`nod = *tn;`
		359	`nod.type = types[TIND];`
		360	`regalloc(n, &nod, o);`
		361	`}`
		362
		363	`void`
		364	`regfree(Node *n)`
		365	`{`
		366	`int i;`
		367
		368	`if(n->op == OREGPAIR) {`
		369	`regfree(n->left);`
		370	`regfree(n->right);`
		371	`return;`
		372	`}`
		373
		374	`i = 0;`
		375	`if(n->op != OREGISTER && n->op != OINDREG)`
		376	`goto err;`
		377	`i = n->reg;`
		378	`if(i < 0 \|\| i >= sizeof(reg))`
		379	`goto err;`
		380	`if(reg[i] <= 0)`
		381	`goto err;`
		382	`reg[i]--;`
		383	`//print("- %R %d\n", i, reg[i]);`
		384	`return;`
		385	`err:`
		386	`diag(n, "error in regfree: %R", i);`
		387	`}`
		388
		389	`void`
		390	`regsalloc(Node n, Node nn)`
		391	`{`
		392	`cursafe = align(cursafe, nn->type, Aaut3);`
		393	`maxargsafe = maxround(maxargsafe, cursafe+curarg);`
		394	`n = nodsafe;`
		395	`n->xoffset = -(stkoff + cursafe);`
		396	`n->type = nn->type;`
		397	`n->etype = nn->type->etype;`
		398	`n->lineno = nn->lineno;`
		399	`}`
		400
		401	`void`
		402	`regaalloc1(Node n, Node nn)`
		403	`{`
		404	`USED(nn);`
		405
		406	`if(REGARG < 0) {`
		407	`diag(n, "regaalloc1");`
		408	`return;`
		409	`}`
		410	`/* not reached`
		411	`nodreg(n, nn, REGARG);`
		412	`reg[REGARG]++;`
		413	`curarg = align(curarg, nn->type, Aarg1);`
		414	`curarg = align(curarg, nn->type, Aarg2);`
		415	`maxargsafe = maxround(maxargsafe, cursafe+curarg);`
		416	`*/`
		417	`}`
		418
		419	`void`
		420	`regaalloc(Node n, Node nn)`
		421	`{`
		422	`curarg = align(curarg, nn->type, Aarg1);`
		423	`n = nn;`
		424	`n->op = OINDREG;`
		425	`n->reg = REGSP;`
		426	`n->xoffset = curarg;`
		427	`n->complex = 0;`
		428	`n->addable = 20;`
		429	`curarg = align(curarg, nn->type, Aarg2);`
		430	`maxargsafe = maxround(maxargsafe, cursafe+curarg);`
		431	`}`
		432
		433	`void`
		434	`regind(Node n, Node nn)`
		435	`{`
		436
		437	`if(n->op != OREGISTER) {`
		438	`diag(n, "regind not OREGISTER");`
		439	`return;`
		440	`}`
		441	`n->op = OINDREG;`
		442	`n->type = nn->type;`
		443	`}`
		444
		445	`void`
		446	`naddr(Node n, Adr a)`
		447	`{`
		448	`long v;`
		449
		450	`a->type = D_NONE;`
		451	`if(n == Z)`
		452	`return;`
		453	`switch(n->op) {`
		454	`default:`
		455	`bad:`
		456	`diag(n, "bad in naddr: %O %D", n->op, a);`
		457	`//prtree(n, "naddr");`
		458	`break;`
		459
		460	`case OREGISTER:`
		461	`a->type = n->reg;`
		462	`a->sym = S;`
		463	`break;`
		464
		465	`case OEXREG:`
		466	`a->type = D_INDIR + D_GS;`
		467	`a->offset = n->reg - 1;`
		468	`a->etype = n->etype;`
		469	`break;`
		470
		471	`case OIND:`
		472	`naddr(n->left, a);`
		473	`if(a->type >= D_AX && a->type <= D_DI)`
		474	`a->type += D_INDIR;`
		475	`else`
		476	`if(a->type == D_CONST)`
		477	`a->type = D_NONE+D_INDIR;`
		478	`else`
		479	`if(a->type == D_ADDR) {`
		480	`a->type = a->index;`
		481	`a->index = D_NONE;`
		482	`} else`
		483	`goto bad;`
		484	`break;`
		485
		486	`case OINDEX:`
		487	`a->type = idx.ptr;`
		488	`if(n->left->op == OADDR \|\| n->left->op == OCONST)`
		489	`naddr(n->left, a);`
		490	`if(a->type >= D_AX && a->type <= D_DI)`
		491	`a->type += D_INDIR;`
		492	`else`
		493	`if(a->type == D_CONST)`
		494	`a->type = D_NONE+D_INDIR;`
		495	`else`
		496	`if(a->type == D_ADDR) {`
		497	`a->type = a->index;`
		498	`a->index = D_NONE;`
		499	`} else`
		500	`goto bad;`
		501	`a->index = idx.reg;`
		502	`a->scale = n->scale;`
		503	`a->offset += n->xoffset;`
		504	`break;`
		505
		506	`case OINDREG:`
		507	`a->type = n->reg+D_INDIR;`
		508	`a->sym = S;`
		509	`a->offset = n->xoffset;`
		510	`break;`
		511
		512	`case ONAME:`
		513	`a->etype = n->etype;`
		514	`a->type = D_STATIC;`
		515	`a->sym = n->sym;`
		516	`a->offset = n->xoffset;`
		517	`if(n->class == CSTATIC)`
		518	`break;`
		519	`if(n->class == CEXTERN \|\| n->class == CGLOBL) {`
		520	`a->type = D_EXTERN;`
		521	`break;`
		522	`}`
		523	`if(n->class == CAUTO) {`
		524	`a->type = D_AUTO;`
		525	`break;`
		526	`}`
		527	`if(n->class == CPARAM) {`
		528	`a->type = D_PARAM;`
		529	`break;`
		530	`}`
		531	`goto bad;`
		532
		533	`case OCONST:`
		534	`if(typefd[n->type->etype]) {`
		535	`a->type = D_FCONST;`
		536	`a->dval = n->fconst;`
		537	`break;`
		538	`}`
		539	`a->sym = S;`
		540	`a->type = D_CONST;`
		541	`a->offset = n->vconst;`
		542	`break;`
		543
		544	`case OADDR:`
		545	`naddr(n->left, a);`
		546	`if(a->type >= D_INDIR) {`
		547	`a->type -= D_INDIR;`
		548	`break;`
		549	`}`
		550	`if(a->type == D_EXTERN \|\| a->type == D_STATIC \|\|`
		551	`a->type == D_AUTO \|\| a->type == D_PARAM)`
		552	`if(a->index == D_NONE) {`
		553	`a->index = a->type;`
		554	`a->type = D_ADDR;`
		555	`break;`
		556	`}`
		557	`goto bad;`
		558
		559	`case OADD:`
		560	`if(n->right->op == OCONST) {`
		561	`v = n->right->vconst;`
		562	`naddr(n->left, a);`
		563	`} else`
		564	`if(n->left->op == OCONST) {`
		565	`v = n->left->vconst;`
		566	`naddr(n->right, a);`
		567	`} else`
		568	`goto bad;`
		569	`a->offset += v;`
		570	`break;`
		571
		572	`}`
		573	`}`
		574
		575	`#define CASE(a,b) ((a<<8)\|(b<<0))`
		576
		577	`void`
		578	`gmove(Node f, Node t)`
		579	`{`
		580	`int ft, tt, a;`
		581	`Node nod, nod1;`
		582	`Prog *p1;`
		583
		584	`ft = f->type->etype;`
		585	`tt = t->type->etype;`
		586	`if(debug['M'])`
		587	`print("gop: %O %O[%s],%O[%s]\n", OAS,`
		588	`f->op, tnames[ft], t->op, tnames[tt]);`
		589	`if(typefd[ft] && f->op == OCONST) {`
		590	`if(f->fconst == 0)`
		591	`gins(AFLDZ, Z, Z);`
		592	`else`
		593	`if(f->fconst == 1)`
		594	`gins(AFLD1, Z, Z);`
		595	`else`
		596	`gins(AFMOVD, f, &fregnode0);`
		597	`gmove(&fregnode0, t);`
		598	`return;`
		599	`}`
		600	`/*`
		601	`* load`
		602	`*/`
		603	`if(f->op == ONAME \|\| f->op == OINDREG \|\|`
		604	`f->op == OIND \|\| f->op == OINDEX)`
		605	`switch(ft) {`
		606	`case TCHAR:`
		607	`a = AMOVBLSX;`
		608	`goto ld;`
		609	`case TUCHAR:`
		610	`a = AMOVBLZX;`
		611	`goto ld;`
		612	`case TSHORT:`
		613	`if(typefd[tt]) {`
		614	`gins(AFMOVW, f, &fregnode0);`
		615	`gmove(&fregnode0, t);`
		616	`return;`
		617	`}`
		618	`a = AMOVWLSX;`
		619	`goto ld;`
		620	`case TUSHORT:`
		621	`a = AMOVWLZX;`
		622	`goto ld;`
		623	`case TINT:`
		624	`case TUINT:`
		625	`case TLONG:`
		626	`case TULONG:`
		627	`case TIND:`
		628	`if(typefd[tt]) {`
		629	`gins(AFMOVL, f, &fregnode0);`
		630	`gmove(&fregnode0, t);`
		631	`return;`
		632	`}`
		633	`a = AMOVL;`
		634
		635	`ld:`
		636	`regalloc(&nod, f, t);`
		637	`nod.type = types[TLONG];`
		638	`gins(a, f, &nod);`
		639	`gmove(&nod, t);`
		640	`regfree(&nod);`
		641	`return;`
		642
		643	`case TFLOAT:`
		644	`gins(AFMOVF, f, t);`
		645	`return;`
		646	`case TDOUBLE:`
		647	`gins(AFMOVD, f, t);`
		648	`return;`
		649	`}`
		650
		651	`/*`
		652	`* store`
		653	`*/`
		654	`if(t->op == ONAME \|\| t->op == OINDREG \|\|`
		655	`t->op == OIND \|\| t->op == OINDEX)`
		656	`switch(tt) {`
		657	`case TCHAR:`
		658	`case TUCHAR:`
		659	`a = AMOVB; goto st;`
		660	`case TSHORT:`
		661	`case TUSHORT:`
		662	`a = AMOVW; goto st;`
		663	`case TINT:`
		664	`case TUINT:`
		665	`case TLONG:`
		666	`case TULONG:`
		667	`case TIND:`
		668	`a = AMOVL; goto st;`
		669
		670	`st:`
		671	`if(f->op == OCONST) {`
		672	`gins(a, f, t);`
		673	`return;`
		674	`}`
		675	`regalloc(&nod, t, f);`
		676	`gmove(f, &nod);`
		677	`gins(a, &nod, t);`
		678	`regfree(&nod);`
		679	`return;`
		680
		681	`case TFLOAT:`
		682	`gins(AFMOVFP, f, t);`
		683	`return;`
		684	`case TDOUBLE:`
		685	`gins(AFMOVDP, f, t);`
		686	`return;`
		687	`}`
		688
		689	`/*`
		690	`* convert`
		691	`*/`
		692	`switch(CASE(ft,tt)) {`
		693	`default:`
		694	`/*`
		695	`* integer to integer`
		696	`********`
		697	`a = AGOK; break;`
		698
		699	`case CASE( TCHAR, TCHAR):`
		700	`case CASE( TUCHAR, TCHAR):`
		701	`case CASE( TSHORT, TCHAR):`
		702	`case CASE( TUSHORT,TCHAR):`
		703	`case CASE( TINT, TCHAR):`
		704	`case CASE( TUINT, TCHAR):`
		705	`case CASE( TLONG, TCHAR):`
		706	`case CASE( TULONG, TCHAR):`
		707	`case CASE( TIND, TCHAR):`
		708
		709	`case CASE( TCHAR, TUCHAR):`
		710	`case CASE( TUCHAR, TUCHAR):`
		711	`case CASE( TSHORT, TUCHAR):`
		712	`case CASE( TUSHORT,TUCHAR):`
		713	`case CASE( TINT, TUCHAR):`
		714	`case CASE( TUINT, TUCHAR):`
		715	`case CASE( TLONG, TUCHAR):`
		716	`case CASE( TULONG, TUCHAR):`
		717	`case CASE( TIND, TUCHAR):`
		718
		719	`case CASE( TSHORT, TSHORT):`
		720	`case CASE( TUSHORT,TSHORT):`
		721	`case CASE( TINT, TSHORT):`
		722	`case CASE( TUINT, TSHORT):`
		723	`case CASE( TLONG, TSHORT):`
		724	`case CASE( TULONG, TSHORT):`
		725	`case CASE( TIND, TSHORT):`
		726
		727	`case CASE( TSHORT, TUSHORT):`
		728	`case CASE( TUSHORT,TUSHORT):`
		729	`case CASE( TINT, TUSHORT):`
		730	`case CASE( TUINT, TUSHORT):`
		731	`case CASE( TLONG, TUSHORT):`
		732	`case CASE( TULONG, TUSHORT):`
		733	`case CASE( TIND, TUSHORT):`
		734
		735	`case CASE( TINT, TINT):`
		736	`case CASE( TUINT, TINT):`
		737	`case CASE( TLONG, TINT):`
		738	`case CASE( TULONG, TINT):`
		739	`case CASE( TIND, TINT):`
		740
		741	`case CASE( TINT, TUINT):`
		742	`case CASE( TUINT, TUINT):`
		743	`case CASE( TLONG, TUINT):`
		744	`case CASE( TULONG, TUINT):`
		745	`case CASE( TIND, TUINT):`
		746
		747	`case CASE( TINT, TLONG):`
		748	`case CASE( TUINT, TLONG):`
		749	`case CASE( TLONG, TLONG):`
		750	`case CASE( TULONG, TLONG):`
		751	`case CASE( TIND, TLONG):`
		752
		753	`case CASE( TINT, TULONG):`
		754	`case CASE( TUINT, TULONG):`
		755	`case CASE( TLONG, TULONG):`
		756	`case CASE( TULONG, TULONG):`
		757	`case CASE( TIND, TULONG):`
		758
		759	`case CASE( TINT, TIND):`
		760	`case CASE( TUINT, TIND):`
		761	`case CASE( TLONG, TIND):`
		762	`case CASE( TULONG, TIND):`
		763	`case CASE( TIND, TIND):`
		764	`*****/`
		765	`a = AMOVL;`
		766	`break;`
		767
		768	`case CASE( TSHORT, TINT):`
		769	`case CASE( TSHORT, TUINT):`
		770	`case CASE( TSHORT, TLONG):`
		771	`case CASE( TSHORT, TULONG):`
		772	`case CASE( TSHORT, TIND):`
		773	`a = AMOVWLSX;`
		774	`if(f->op == OCONST) {`
		775	`f->vconst &= 0xffff;`
		776	`if(f->vconst & 0x8000)`
		777	`f->vconst \|= 0xffff0000;`
		778	`a = AMOVL;`
		779	`}`
		780	`break;`
		781
		782	`case CASE( TUSHORT,TINT):`
		783	`case CASE( TUSHORT,TUINT):`
		784	`case CASE( TUSHORT,TLONG):`
		785	`case CASE( TUSHORT,TULONG):`
		786	`case CASE( TUSHORT,TIND):`
		787	`a = AMOVWLZX;`
		788	`if(f->op == OCONST) {`
		789	`f->vconst &= 0xffff;`
		790	`a = AMOVL;`
		791	`}`
		792	`break;`
		793
		794	`case CASE( TCHAR, TSHORT):`
		795	`case CASE( TCHAR, TUSHORT):`
		796	`case CASE( TCHAR, TINT):`
		797	`case CASE( TCHAR, TUINT):`
		798	`case CASE( TCHAR, TLONG):`
		799	`case CASE( TCHAR, TULONG):`
		800	`case CASE( TCHAR, TIND):`
		801	`a = AMOVBLSX;`
		802	`if(f->op == OCONST) {`
		803	`f->vconst &= 0xff;`
		804	`if(f->vconst & 0x80)`
		805	`f->vconst \|= 0xffffff00;`
		806	`a = AMOVL;`
		807	`}`
		808	`break;`
		809
		810	`case CASE( TUCHAR, TSHORT):`
		811	`case CASE( TUCHAR, TUSHORT):`
		812	`case CASE( TUCHAR, TINT):`
		813	`case CASE( TUCHAR, TUINT):`
		814	`case CASE( TUCHAR, TLONG):`
		815	`case CASE( TUCHAR, TULONG):`
		816	`case CASE( TUCHAR, TIND):`
		817	`a = AMOVBLZX;`
		818	`if(f->op == OCONST) {`
		819	`f->vconst &= 0xff;`
		820	`a = AMOVL;`
		821	`}`
		822	`break;`
		823
		824	`/*`
		825	`* float to fix`
		826	`*/`
		827	`case CASE( TFLOAT, TCHAR):`
		828	`case CASE( TFLOAT, TUCHAR):`
		829	`case CASE( TFLOAT, TSHORT):`
		830	`case CASE( TFLOAT, TUSHORT):`
		831	`case CASE( TFLOAT, TINT):`
		832	`case CASE( TFLOAT, TLONG):`
		833	`case CASE( TFLOAT, TIND):`
		834
		835	`case CASE( TDOUBLE,TCHAR):`
		836	`case CASE( TDOUBLE,TUCHAR):`
		837	`case CASE( TDOUBLE,TSHORT):`
		838	`case CASE( TDOUBLE,TUSHORT):`
		839	`case CASE( TDOUBLE,TINT):`
		840	`case CASE( TDOUBLE,TLONG):`
		841	`case CASE( TDOUBLE,TIND):`
		842	`if(fproundflg) {`
		843	`regsalloc(&nod, &regnode);`
		844	`gins(AFMOVLP, f, &nod);`
		845	`gmove(&nod, t);`
		846	`return;`
		847	`}`
		848	`regsalloc(&nod, &regnode);`
		849	`regsalloc(&nod1, &regnode);`
		850	`gins(AFSTCW, Z, &nod1);`
		851	`nod1.xoffset += 2;`
		852	`gins(AMOVW, nodconst(0xf7f), &nod1);`
		853	`gins(AFLDCW, &nod1, Z);`
		854	`gins(AFMOVLP, f, &nod);`
		855	`nod1.xoffset -= 2;`
		856	`gins(AFLDCW, &nod1, Z);`
		857	`gmove(&nod, t);`
		858	`return;`
		859
		860	`/*`
		861	`* float to ulong`
		862	`*/`
		863	`case CASE( TDOUBLE, TULONG):`
		864	`case CASE( TFLOAT, TULONG):`
		865	`case CASE( TDOUBLE, TUINT):`
		866	`case CASE( TFLOAT, TUINT):`
		867	`regsalloc(&nod, &regnode);`
		868	`gmove(f, &fregnode0);`
		869	`gins(AFADDD, nodfconst(-2147483648.), &fregnode0);`
		870	`gins(AFMOVLP, f, &nod);`
		871	`gins(ASUBL, nodconst(-2147483648), &nod);`
		872	`gmove(&nod, t);`
		873	`return;`
		874
		875	`/*`
		876	`* ulong to float`
		877	`*/`
		878	`case CASE( TULONG, TDOUBLE):`
		879	`case CASE( TULONG, TFLOAT):`
		880	`case CASE( TUINT, TDOUBLE):`
		881	`case CASE( TUINT, TFLOAT):`
		882	`regalloc(&nod, f, f);`
		883	`gmove(f, &nod);`
		884	`regsalloc(&nod1, &regnode);`
		885	`gmove(&nod, &nod1);`
		886	`gins(AFMOVL, &nod1, &fregnode0);`
		887	`gins(ACMPL, &nod, nodconst(0));`
		888	`gins(AJGE, Z, Z);`
		889	`p1 = p;`
		890	`gins(AFADDD, nodfconst(4294967296.), &fregnode0);`
		891	`patch(p1, pc);`
		892	`regfree(&nod);`
		893	`return;`
		894
		895	`/*`
		896	`* fix to float`
		897	`*/`
		898	`case CASE( TCHAR, TFLOAT):`
		899	`case CASE( TUCHAR, TFLOAT):`
		900	`case CASE( TSHORT, TFLOAT):`
		901	`case CASE( TUSHORT,TFLOAT):`
		902	`case CASE( TINT, TFLOAT):`
		903	`case CASE( TLONG, TFLOAT):`
		904	`case CASE( TIND, TFLOAT):`
		905
		906	`case CASE( TCHAR, TDOUBLE):`
		907	`case CASE( TUCHAR, TDOUBLE):`
		908	`case CASE( TSHORT, TDOUBLE):`
		909	`case CASE( TUSHORT,TDOUBLE):`
		910	`case CASE( TINT, TDOUBLE):`
		911	`case CASE( TLONG, TDOUBLE):`
		912	`case CASE( TIND, TDOUBLE):`
		913	`regsalloc(&nod, &regnode);`
		914	`gmove(f, &nod);`
		915	`gins(AFMOVL, &nod, &fregnode0);`
		916	`return;`
		917
		918	`/*`
		919	`* float to float`
		920	`*/`
		921	`case CASE( TFLOAT, TFLOAT):`
		922	`case CASE( TDOUBLE,TFLOAT):`
		923
		924	`case CASE( TFLOAT, TDOUBLE):`
		925	`case CASE( TDOUBLE,TDOUBLE):`
		926	`a = AFMOVD; break;`
		927	`}`
		928	`if(a == AMOVL \|\| a == AFMOVD)`
		929	`if(samaddr(f, t))`
		930	`return;`
		931	`gins(a, f, t);`
		932	`}`
		933
		934	`void`
		935	`doindex(Node *n)`
		936	`{`
		937	`Node nod, nod1;`
		938	`long v;`
		939
		940	`if(debug['Y'])`
		941	`prtree(n, "index");`
		942
		943	`if(n->left->complex >= FNX)`
		944	`print("botch in doindex\n");`
		945
		946	`regalloc(&nod, &regnode, Z);`
		947	`v = constnode.vconst;`
		948	`cgen(n->right, &nod);`
		949	`idx.ptr = D_NONE;`
		950	`if(n->left->op == OCONST)`
		951	`idx.ptr = D_CONST;`
		952	`else if(n->left->op == OREGISTER)`
		953	`// else if(n->left->op == OREGISTER && typeil[n->left->type->etype])`
		954	`idx.ptr = n->left->reg;`
		955	`else if(n->left->op != OADDR) {`
		956	`reg[D_BP]++; // cant be used as a base`
		957	`regalloc(&nod1, &regnode, Z);`
		958	`cgen(n->left, &nod1);`
		959	`idx.ptr = nod1.reg;`
		960	`regfree(&nod1);`
		961	`reg[D_BP]--;`
		962	`}`
		963	`idx.reg = nod.reg;`
		964	`regfree(&nod);`
		965	`constnode.vconst = v;`
		966	`}`
		967
		968	`void`
		969	`gins(int a, Node f, Node t)`
		970	`{`
		971
		972	`if(f != Z && f->op == OINDEX)`
		973	`doindex(f);`
		974	`if(t != Z && t->op == OINDEX)`
		975	`doindex(t);`
		976	`nextpc();`
		977	`p->as = a;`
		978	`if(f != Z)`
		979	`naddr(f, &p->from);`
		980	`if(t != Z)`
		981	`naddr(t, &p->to);`
		982	`if(debug['g'])`
		983	`print("%P\n", p);`
		984	`}`
		985
		986	`void`
		987	`fgopcode(int o, Node f, Node t, int pop, int rev)`
		988	`{`
		989	`int a, et;`
		990	`Node nod;`
		991
		992	`et = TLONG;`
		993	`if(f != Z && f->type != T)`
		994	`et = f->type->etype;`
		995	`if(!typefd[et]) {`
		996	`diag(f, "fop: integer %O", o);`
		997	`return;`
		998	`}`
		999	`if(debug['M']) {`
		1000	`if(t != Z && t->type != T)`
		1001	`print("gop: %O %O-%s Z\n", o, f->op, tnames[et]);`
		1002	`else`
		1003	`print("gop: %O %O-%s %O-%s\n", o,`
		1004	`f->op, tnames[et], t->op, tnames[t->type->etype]);`
		1005	`}`
		1006	`a = AGOK;`
		1007	`switch(o) {`
		1008
		1009	`case OASADD:`
		1010	`case OADD:`
		1011	`if(et == TFLOAT)`
		1012	`a = AFADDF;`
		1013	`else`
		1014	`if(et == TDOUBLE) {`
		1015	`a = AFADDD;`
		1016	`if(pop)`
		1017	`a = AFADDDP;`
		1018	`}`
		1019	`break;`
		1020
		1021	`case OASSUB:`
		1022	`case OSUB:`
		1023	`if(et == TFLOAT) {`
		1024	`a = AFSUBF;`
		1025	`if(rev)`
		1026	`a = AFSUBRF;`
		1027	`} else`
		1028	`if(et == TDOUBLE) {`
		1029	`a = AFSUBD;`
		1030	`if(pop)`
		1031	`a = AFSUBDP;`
		1032	`if(rev) {`
		1033	`a = AFSUBRD;`
		1034	`if(pop)`
		1035	`a = AFSUBRDP;`
		1036	`}`
		1037	`}`
		1038	`break;`
		1039
		1040	`case OASMUL:`
		1041	`case OMUL:`
		1042	`if(et == TFLOAT)`
		1043	`a = AFMULF;`
		1044	`else`
		1045	`if(et == TDOUBLE) {`
		1046	`a = AFMULD;`
		1047	`if(pop)`
		1048	`a = AFMULDP;`
		1049	`}`
		1050	`break;`
		1051
		1052	`case OASMOD:`
		1053	`case OMOD:`
		1054	`case OASDIV:`
		1055	`case ODIV:`
		1056	`if(et == TFLOAT) {`
		1057	`a = AFDIVF;`
		1058	`if(rev)`
		1059	`a = AFDIVRF;`
		1060	`} else`
		1061	`if(et == TDOUBLE) {`
		1062	`a = AFDIVD;`
		1063	`if(pop)`
		1064	`a = AFDIVDP;`
		1065	`if(rev) {`
		1066	`a = AFDIVRD;`
		1067	`if(pop)`
		1068	`a = AFDIVRDP;`
		1069	`}`
		1070	`}`
		1071	`break;`
		1072
		1073	`case OEQ:`
		1074	`case ONE:`
		1075	`case OLT:`
		1076	`case OLE:`
		1077	`case OGE:`
		1078	`case OGT:`
		1079	`pop += rev;`
		1080	`if(et == TFLOAT) {`
		1081	`a = AFCOMF;`
		1082	`if(pop) {`
		1083	`a = AFCOMFP;`
		1084	`if(pop > 1)`
		1085	`a = AGOK;`
		1086	`}`
		1087	`} else`
		1088	`if(et == TDOUBLE) {`
		1089	`a = AFCOMF;`
		1090	`if(pop) {`
		1091	`a = AFCOMDP;`
		1092	`if(pop > 1)`
		1093	`a = AFCOMDPP;`
		1094	`}`
		1095	`}`
		1096	`gins(a, f, t);`
		1097	`regalloc(&nod, &regnode, Z);`
		1098	`if(nod.reg != D_AX) {`
		1099	`regfree(&nod);`
		1100	`nod.reg = D_AX;`
		1101	`gins(APUSHL, &nod, Z);`
		1102	`gins(AWAIT, Z, Z);`
		1103	`gins(AFSTSW, Z, &nod);`
		1104	`gins(ASAHF, Z, Z);`
		1105	`gins(APOPL, Z, &nod);`
		1106	`} else {`
		1107	`gins(AWAIT, Z, Z);`
		1108	`gins(AFSTSW, Z, &nod);`
		1109	`gins(ASAHF, Z, Z);`
		1110	`regfree(&nod);`
		1111	`}`
		1112	`switch(o) {`
		1113	`case OEQ: a = AJEQ; break;`
		1114	`case ONE: a = AJNE; break;`
		1115	`case OLT: a = AJCS; break;`
		1116	`case OLE: a = AJLS; break;`
		1117	`case OGE: a = AJCC; break;`
		1118	`case OGT: a = AJHI; break;`
		1119	`}`
		1120	`gins(a, Z, Z);`
		1121	`return;`
		1122	`}`
		1123	`if(a == AGOK)`
		1124	`diag(Z, "bad in gopcode %O", o);`
		1125	`gins(a, f, t);`
		1126	`}`
		1127
		1128	`void`
		1129	`gopcode(int o, Type ty, Node f, Node *t)`
		1130	`{`
		1131	`int a, et;`
		1132
		1133	`et = TLONG;`
		1134	`if(ty != T)`
		1135	`et = ty->etype;`
		1136	`if(typefd[et] && o != OADDR && o != OFUNC) {`
		1137	`diag(f, "gop: float %O", o);`
		1138	`return;`
		1139	`}`
		1140	`if(debug['M']) {`
		1141	`if(f != Z && f->type != T)`
		1142	`print("gop: %O %O[%s],", o, f->op, tnames[et]);`
		1143	`else`
		1144	`print("gop: %O Z,", o);`
		1145	`if(t != Z && t->type != T)`
		1146	`print("%O[%s]\n", t->op, tnames[t->type->etype]);`
		1147	`else`
		1148	`print("Z\n");`
		1149	`}`
		1150	`a = AGOK;`
		1151	`switch(o) {`
		1152	`case OCOM:`
		1153	`a = ANOTL;`
		1154	`if(et == TCHAR \|\| et == TUCHAR)`
		1155	`a = ANOTB;`
		1156	`if(et == TSHORT \|\| et == TUSHORT)`
		1157	`a = ANOTW;`
		1158	`break;`
		1159
		1160	`case ONEG:`
		1161	`a = ANEGL;`
		1162	`if(et == TCHAR \|\| et == TUCHAR)`
		1163	`a = ANEGB;`
		1164	`if(et == TSHORT \|\| et == TUSHORT)`
		1165	`a = ANEGW;`
		1166	`break;`
		1167
		1168	`case OADDR:`
		1169	`a = ALEAL;`
		1170	`break;`
		1171
		1172	`case OASADD:`
		1173	`case OADD:`
		1174	`a = AADDL;`
		1175	`if(et == TCHAR \|\| et == TUCHAR)`
		1176	`a = AADDB;`
		1177	`if(et == TSHORT \|\| et == TUSHORT)`
		1178	`a = AADDW;`
		1179	`break;`
		1180
		1181	`case OASSUB:`
		1182	`case OSUB:`
		1183	`a = ASUBL;`
		1184	`if(et == TCHAR \|\| et == TUCHAR)`
		1185	`a = ASUBB;`
		1186	`if(et == TSHORT \|\| et == TUSHORT)`
		1187	`a = ASUBW;`
		1188	`break;`
		1189
		1190	`case OASOR:`
		1191	`case OOR:`
		1192	`a = AORL;`
		1193	`if(et == TCHAR \|\| et == TUCHAR)`
		1194	`a = AORB;`
		1195	`if(et == TSHORT \|\| et == TUSHORT)`
		1196	`a = AORW;`
		1197	`break;`
		1198
		1199	`case OASAND:`
		1200	`case OAND:`
		1201	`a = AANDL;`
		1202	`if(et == TCHAR \|\| et == TUCHAR)`
		1203	`a = AANDB;`
		1204	`if(et == TSHORT \|\| et == TUSHORT)`
		1205	`a = AANDW;`
		1206	`break;`
		1207
		1208	`case OASXOR:`
		1209	`case OXOR:`
		1210	`a = AXORL;`
		1211	`if(et == TCHAR \|\| et == TUCHAR)`
		1212	`a = AXORB;`
		1213	`if(et == TSHORT \|\| et == TUSHORT)`
		1214	`a = AXORW;`
		1215	`break;`
		1216
		1217	`case OASLSHR:`
		1218	`case OLSHR:`
		1219	`a = ASHRL;`
		1220	`if(et == TCHAR \|\| et == TUCHAR)`
		1221	`a = ASHRB;`
		1222	`if(et == TSHORT \|\| et == TUSHORT)`
		1223	`a = ASHRW;`
		1224	`break;`
		1225
		1226	`case OASASHR:`
		1227	`case OASHR:`
		1228	`a = ASARL;`
		1229	`if(et == TCHAR \|\| et == TUCHAR)`
		1230	`a = ASARB;`
		1231	`if(et == TSHORT \|\| et == TUSHORT)`
		1232	`a = ASARW;`
		1233	`break;`
		1234
		1235	`case OASASHL:`
		1236	`case OASHL:`
		1237	`a = ASALL;`
		1238	`if(et == TCHAR \|\| et == TUCHAR)`
		1239	`a = ASALB;`
		1240	`if(et == TSHORT \|\| et == TUSHORT)`
		1241	`a = ASALW;`
		1242	`break;`
		1243
		1244	`case OFUNC:`
		1245	`a = ACALL;`
		1246	`break;`
		1247
		1248	`case OASMUL:`
		1249	`case OMUL:`
		1250	`if(f->op == OREGISTER && t != Z && isreg(t, D_AX) && reg[D_DX] == 0)`
		1251	`t = Z;`
		1252	`a = AIMULL;`
		1253	`break;`
		1254
		1255	`case OASMOD:`
		1256	`case OMOD:`
		1257	`case OASDIV:`
		1258	`case ODIV:`
		1259	`a = AIDIVL;`
		1260	`break;`
		1261
		1262	`case OASLMUL:`
		1263	`case OLMUL:`
		1264	`a = AMULL;`
		1265	`break;`
		1266
		1267	`case OASLMOD:`
		1268	`case OLMOD:`
		1269	`case OASLDIV:`
		1270	`case OLDIV:`
		1271	`a = ADIVL;`
		1272	`break;`
		1273
		1274	`case OEQ:`
		1275	`case ONE:`
		1276	`case OLT:`
		1277	`case OLE:`
		1278	`case OGE:`
		1279	`case OGT:`
		1280	`case OLO:`
		1281	`case OLS:`
		1282	`case OHS:`
		1283	`case OHI:`
		1284	`a = ACMPL;`
		1285	`if(et == TCHAR \|\| et == TUCHAR)`
		1286	`a = ACMPB;`
		1287	`if(et == TSHORT \|\| et == TUSHORT)`
		1288	`a = ACMPW;`
		1289	`gins(a, f, t);`
		1290	`switch(o) {`
		1291	`case OEQ: a = AJEQ; break;`
		1292	`case ONE: a = AJNE; break;`
		1293	`case OLT: a = AJLT; break;`
		1294	`case OLE: a = AJLE; break;`
		1295	`case OGE: a = AJGE; break;`
		1296	`case OGT: a = AJGT; break;`
		1297	`case OLO: a = AJCS; break;`
		1298	`case OLS: a = AJLS; break;`
		1299	`case OHS: a = AJCC; break;`
		1300	`case OHI: a = AJHI; break;`
		1301	`}`
		1302	`gins(a, Z, Z);`
		1303	`return;`
		1304	`}`
		1305	`if(a == AGOK)`
		1306	`diag(Z, "bad in gopcode %O", o);`
		1307	`gins(a, f, t);`
		1308	`}`
		1309
		1310	`int`
		1311	`samaddr(Node f, Node t)`
		1312	`{`
		1313
		1314	`if(f->op != t->op)`
		1315	`return 0;`
		1316	`switch(f->op) {`
		1317
		1318	`case OREGISTER:`
		1319	`if(f->reg != t->reg)`
		1320	`break;`
		1321	`return 1;`
		1322	`}`
		1323	`return 0;`
		1324	`}`
		1325
		1326	`void`
		1327	`gbranch(int o)`
		1328	`{`
		1329	`int a;`
		1330
		1331	`a = AGOK;`
		1332	`switch(o) {`
		1333	`case ORETURN:`
		1334	`a = ARET;`
		1335	`break;`
		1336	`case OGOTO:`
		1337	`a = AJMP;`
		1338	`break;`
		1339	`}`
		1340	`nextpc();`
		1341	`if(a == AGOK) {`
		1342	`diag(Z, "bad in gbranch %O", o);`
		1343	`nextpc();`
		1344	`}`
		1345	`p->as = a;`
		1346	`}`
		1347
		1348	`void`
		1349	`patch(Prog *op, long pc)`
		1350	`{`
		1351
		1352	`op->to.offset = pc;`
		1353	`op->to.type = D_BRANCH;`
		1354	`}`
		1355
		1356	`void`
		1357	`gpseudo(int a, Sym s, Node n)`
		1358	`{`
		1359
		1360	`nextpc();`
		1361	`p->as = a;`
		1362	`p->from.type = D_EXTERN;`
		1363	`p->from.sym = s;`
		1364	`p->from.scale = (profileflg ? 0 : NOPROF);`
		1365	`if(s->class == CSTATIC)`
		1366	`p->from.type = D_STATIC;`
		1367	`naddr(n, &p->to);`
		1368	`if(a == ADATA \|\| a == AGLOBL)`
		1369	`pc--;`
		1370	`}`
		1371
		1372	`int`
		1373	`sconst(Node *n)`
		1374	`{`
		1375	`long v;`
		1376
		1377	`if(n->op == OCONST && !typefd[n->type->etype]) {`
		1378	`v = n->vconst;`
		1379	`if(v >= -32766L && v < 32766L)`
		1380	`return 1;`
		1381	`}`
		1382	`return 0;`
		1383	`}`
		1384
		1385	`long`
		1386	`exreg(Type *t)`
		1387	`{`
		1388
		1389	`int o;`
		1390
		1391	`if(typechlp[t->etype]){`
		1392	`if(exregoffset >= 32)`
		1393	`return 0;`
		1394	`o = exregoffset;`
		1395	`exregoffset += 4;`
		1396	`return o+1; /* +1 to avoid 0 == failure; naddr case OEXREG will -1. */`
		1397	`}`
		1398	`return 0;`
		1399	`}`
		1400
		1401	`schar ewidth[NTYPE] =`
		1402	`{`
		1403	`-1, /[TXXX]/`
		1404	`SZ_CHAR, /[TCHAR]/`
		1405	`SZ_CHAR, /[TUCHAR]/`
		1406	`SZ_SHORT, /[TSHORT]/`
		1407	`SZ_SHORT, /[TUSHORT]/`
		1408	`SZ_INT, /[TINT]/`
		1409	`SZ_INT, /[TUINT]/`
		1410	`SZ_LONG, /[TLONG]/`
		1411	`SZ_LONG, /[TULONG]/`
		1412	`SZ_VLONG, /[TVLONG]/`
		1413	`SZ_VLONG, /[TUVLONG]/`
		1414	`SZ_FLOAT, /[TFLOAT]/`
		1415	`SZ_DOUBLE, /[TDOUBLE]/`
		1416	`SZ_IND, /[TIND]/`
		1417	`0, /[TFUNC]/`
		1418	`-1, /[TARRAY]/`
		1419	`0, /[TVOID]/`
		1420	`-1, /[TSTRUCT]/`
		1421	`-1, /[TUNION]/`
		1422	`SZ_INT, /[TENUM]/`
		1423	`};`
		1424	`long ncast[NTYPE] =`
		1425	`{`
		1426	`0, /[TXXX]/`
		1427	`BCHAR\|BUCHAR, /[TCHAR]/`
		1428	`BCHAR\|BUCHAR, /[TUCHAR]/`
		1429	`BSHORT\|BUSHORT, /[TSHORT]/`
		1430	`BSHORT\|BUSHORT, /[TUSHORT]/`
		1431	`BINT\|BUINT\|BLONG\|BULONG\|BIND, /[TINT]/`
		1432	`BINT\|BUINT\|BLONG\|BULONG\|BIND, /[TUINT]/`
		1433	`BINT\|BUINT\|BLONG\|BULONG\|BIND, /[TLONG]/`
		1434	`BINT\|BUINT\|BLONG\|BULONG\|BIND, /[TULONG]/`
		1435	`BVLONG\|BUVLONG, /[TVLONG]/`
		1436	`BVLONG\|BUVLONG, /[TUVLONG]/`
		1437	`BFLOAT, /[TFLOAT]/`
		1438	`BDOUBLE, /[TDOUBLE]/`
		1439	`BLONG\|BULONG\|BIND, /[TIND]/`
		1440	`0, /[TFUNC]/`
		1441	`0, /[TARRAY]/`
		1442	`0, /[TVOID]/`
		1443	`BSTRUCT, /[TSTRUCT]/`
		1444	`BUNION, /[TUNION]/`
		1445	`0, /[TENUM]/`
		1446	`};`

Subversion Repositories planix.SVN

(root)/os/branches/feature_unix/sys/src/cmd/8c/txt.c – Rev 60