WebSVN – planix.SVN – Blame – /os/branches/planix-v0/sys/src/cmd/hoc/code.c

Rev	Author	Line No.	Line
2	-	1	`#include <u.h>`
		2	`#include <libc.h>`
		3	`#include <bio.h>`
		4	`#include "hoc.h"`
		5	`#include "y.tab.h"`
		6
		7	`#define NSTACK 256`
		8
		9	`static Datum stack[NSTACK]; /* the stack */`
		10	`static Datum stackp; / next free spot on stack */`
		11
		12	`#define NPROG 2000`
		13	`Inst prog[NPROG]; /* the machine */`
		14	`Inst progp; / next free spot for code generation */`
		15	`Inst pc; / program counter during execution */`
		16	`Inst progbase = prog; / start of current subprogram */`
		17	`int returning; /* 1 if return stmt seen */`
		18	`int indef; /* 1 if parsing a func or proc */`
		19
		20	`typedef struct Frame { /* proc/func call stack frame */`
		21	`Symbol sp; / symbol table entry */`
		22	`Inst retpc; / where to resume after return */`
		23	`Datum argn; / n-th argument on stack */`
		24	`int nargs; /* number of arguments */`
		25	`} Frame;`
		26	`#define NFRAME 100`
		27	`Frame frame[NFRAME];`
		28	`Frame fp; / frame pointer */`
		29
		30	`void`
		31	`initcode(void)`
		32	`{`
		33	`progp = progbase;`
		34	`stackp = stack;`
		35	`fp = frame;`
		36	`returning = 0;`
		37	`indef = 0;`
		38	`}`
		39
		40	`void`
		41	`push(Datum d)`
		42	`{`
		43	`if (stackp >= &stack[NSTACK])`
		44	`execerror("stack too deep", 0);`
		45	`*stackp++ = d;`
		46	`}`
		47
		48	`Datum`
		49	`pop(void)`
		50	`{`
		51	`if (stackp == stack)`
		52	`execerror("stack underflow", 0);`
		53	`return *--stackp;`
		54	`}`
		55
		56	`void`
		57	`xpop(void) /* for when no value is wanted */`
		58	`{`
		59	`if (stackp == stack)`
		60	`execerror("stack underflow", (char *)0);`
		61	`--stackp;`
		62	`}`
		63
		64	`void`
		65	`constpush(void)`
		66	`{`
		67	`Datum d;`
		68	`d.val = ((Symbol )pc++)->u.val;`
		69	`push(d);`
		70	`}`
		71
		72	`void`
		73	`varpush(void)`
		74	`{`
		75	`Datum d;`
		76	`d.sym = (Symbol )(pc++);`
		77	`push(d);`
		78	`}`
		79
		80	`void`
		81	`whilecode(void)`
		82	`{`
		83	`Datum d;`
		84	`Inst *savepc = pc;`
		85
		86	`execute(savepc+2); /* condition */`
		87	`d = pop();`
		88	`while (d.val) {`
		89	`execute(((Inst )(savepc))); / body */`
		90	`if (returning)`
		91	`break;`
		92	`execute(savepc+2); /* condition */`
		93	`d = pop();`
		94	`}`
		95	`if (!returning)`
		96	`pc = ((Inst )(savepc+1)); / next stmt */`
		97	`}`
		98
		99	`void`
		100	`forcode(void)`
		101	`{`
		102	`Datum d;`
		103	`Inst *savepc = pc;`
		104
		105	`execute(savepc+4); /* precharge */`
		106	`pop();`
		107	`execute(((Inst )(savepc))); / condition */`
		108	`d = pop();`
		109	`while (d.val) {`
		110	`execute(((Inst )(savepc+2))); / body */`
		111	`if (returning)`
		112	`break;`
		113	`execute(((Inst )(savepc+1))); / post loop */`
		114	`pop();`
		115	`execute(((Inst )(savepc))); / condition */`
		116	`d = pop();`
		117	`}`
		118	`if (!returning)`
		119	`pc = ((Inst )(savepc+3)); / next stmt */`
		120	`}`
		121
		122	`void`
		123	`ifcode(void)`
		124	`{`
		125	`Datum d;`
		126	`Inst savepc = pc; / then part */`
		127
		128	`execute(savepc+3); /* condition */`
		129	`d = pop();`
		130	`if (d.val)`
		131	`execute(((Inst *)(savepc)));`
		132	`else if (((Inst )(savepc+1))) / else part? */`
		133	`execute(((Inst *)(savepc+1)));`
		134	`if (!returning)`
		135	`pc = ((Inst )(savepc+2)); / next stmt */`
		136	`}`
		137
		138	`void`
		139	`define(Symbol* sp, Formal f) / put func/proc in symbol table */`
		140	`{`
		141	`Fndefn *fd;`
		142	`int n;`
		143
		144	`fd = emalloc(sizeof(Fndefn));`
		145	`fd->code = progbase; /* start of code */`
		146	`progbase = progp; /* next code starts here */`
		147	`fd->formals = f;`
		148	`for(n=0; f; f=f->next)`
		149	`n++;`
		150	`fd->nargs = n;`
		151	`sp->u.defn = fd;`
		152	`}`
		153
		154	`void`
		155	`call(void) /* call a function */`
		156	`{`
		157	`Formal *f;`
		158	`Datum *arg;`
		159	`Saveval *s;`
		160	`int i;`
		161
		162	`Symbol sp = (Symbol )pc[0]; /* symbol table entry */`
		163	`/* for function */`
		164	`if (fp >= &frame[NFRAME-1])`
		165	`execerror(sp->name, "call nested too deeply");`
		166	`fp++;`
		167	`fp->sp = sp;`
		168	`fp->nargs = (int)(uintptr)pc[1];`
		169	`fp->retpc = pc + 2;`
		170	`fp->argn = stackp - 1; /* last argument */`
		171	`if(fp->nargs != sp->u.defn->nargs)`
		172	`execerror(sp->name, "called with wrong number of arguments");`
		173	`/* bind formals */`
		174	`f = sp->u.defn->formals;`
		175	`arg = stackp - fp->nargs;`
		176	`while(f){`
		177	`s = emalloc(sizeof(Saveval));`
		178	`s->val = f->sym->u;`
		179	`s->type = f->sym->type;`
		180	`s->next = f->save;`
		181	`f->save = s;`
		182	`f->sym->u.val = arg->val;`
		183	`f->sym->type = VAR;`
		184	`f = f->next;`
		185	`arg++;`
		186	`}`
		187	`for (i = 0; i < fp->nargs; i++)`
		188	`pop(); /* pop arguments; no longer needed */`
		189	`execute(sp->u.defn->code);`
		190	`returning = 0;`
		191	`}`
		192
		193	`void`
		194	`restore(Symbol sp) / restore formals associated with symbol */`
		195	`{`
		196	`Formal *f;`
		197	`Saveval *s;`
		198
		199	`f = sp->u.defn->formals;`
		200	`while(f){`
		201	`s = f->save;`
		202	`if(s == 0) /* more actuals than formals */`
		203	`break;`
		204	`f->sym->u = s->val;`
		205	`f->sym->type = s->type;`
		206	`f->save = s->next;`
		207	`free(s);`
		208	`f = f->next;`
		209	`}`
		210	`}`
		211
		212	`void`
		213	`restoreall(void) /* restore all variables in case of error */`
		214	`{`
		215	`while(fp>=frame && fp->sp){`
		216	`restore(fp->sp);`
		217	`--fp;`
		218	`}`
		219	`fp = frame;`
		220	`}`
		221
		222	`static void`
		223	`ret(void) /* common return from func or proc */`
		224	`{`
		225	`/* restore formals */`
		226	`restore(fp->sp);`
		227	`pc = (Inst *)fp->retpc;`
		228	`--fp;`
		229	`returning = 1;`
		230	`}`
		231
		232	`void`
		233	`funcret(void) /* return from a function */`
		234	`{`
		235	`Datum d;`
		236	`if (fp->sp->type == PROCEDURE)`
		237	`execerror(fp->sp->name, "(proc) returns value");`
		238	`d = pop(); /* preserve function return value */`
		239	`ret();`
		240	`push(d);`
		241	`}`
		242
		243	`void`
		244	`procret(void) /* return from a procedure */`
		245	`{`
		246	`if (fp->sp->type == FUNCTION)`
		247	`execerror(fp->sp->name,`
		248	`"(func) returns no value");`
		249	`ret();`
		250	`}`
		251
		252	`void`
		253	`bltin(void)`
		254	`{`
		255
		256	`Datum d;`
		257	`d = pop();`
		258	`d.val = ((double ()(double))*pc++)(d.val);`
		259	`push(d);`
		260	`}`
		261
		262	`void`
		263	`add(void)`
		264	`{`
		265	`Datum d1, d2;`
		266	`d2 = pop();`
		267	`d1 = pop();`
		268	`d1.val += d2.val;`
		269	`push(d1);`
		270	`}`
		271
		272	`void`
		273	`sub(void)`
		274	`{`
		275	`Datum d1, d2;`
		276	`d2 = pop();`
		277	`d1 = pop();`
		278	`d1.val -= d2.val;`
		279	`push(d1);`
		280	`}`
		281
		282	`void`
		283	`mul(void)`
		284	`{`
		285	`Datum d1, d2;`
		286	`d2 = pop();`
		287	`d1 = pop();`
		288	`d1.val *= d2.val;`
		289	`push(d1);`
		290	`}`
		291
		292	`void`
		293	`div(void)`
		294	`{`
		295	`Datum d1, d2;`
		296	`d2 = pop();`
		297	`if (d2.val == 0.0)`
		298	`execerror("division by zero", (char *)0);`
		299	`d1 = pop();`
		300	`d1.val /= d2.val;`
		301	`push(d1);`
		302	`}`
		303
		304	`void`
		305	`mod(void)`
		306	`{`
		307	`Datum d1, d2;`
		308	`d2 = pop();`
		309	`if (d2.val == 0.0)`
		310	`execerror("division by zero", (char *)0);`
		311	`d1 = pop();`
		312	`/* d1.val %= d2.val; */`
		313	`d1.val = fmod(d1.val, d2.val);`
		314	`push(d1);`
		315	`}`
		316
		317	`void`
		318	`negate(void)`
		319	`{`
		320	`Datum d;`
		321	`d = pop();`
		322	`d.val = -d.val;`
		323	`push(d);`
		324	`}`
		325
		326	`void`
		327	`verify(Symbol* s)`
		328	`{`
		329	`if (s->type != VAR && s->type != UNDEF)`
		330	`execerror("attempt to evaluate non-variable", s->name);`
		331	`if (s->type == UNDEF)`
		332	`execerror("undefined variable", s->name);`
		333	`}`
		334
		335	`void`
		336	`eval(void) /* evaluate variable on stack */`
		337	`{`
		338	`Datum d;`
		339	`d = pop();`
		340	`verify(d.sym);`
		341	`d.val = d.sym->u.val;`
		342	`push(d);`
		343	`}`
		344
		345	`void`
		346	`preinc(void)`
		347	`{`
		348	`Datum d;`
		349	`d.sym = (Symbol )(pc++);`
		350	`verify(d.sym);`
		351	`d.val = d.sym->u.val += 1.0;`
		352	`push(d);`
		353	`}`
		354
		355	`void`
		356	`predec(void)`
		357	`{`
		358	`Datum d;`
		359	`d.sym = (Symbol )(pc++);`
		360	`verify(d.sym);`
		361	`d.val = d.sym->u.val -= 1.0;`
		362	`push(d);`
		363	`}`
		364
		365	`void`
		366	`postinc(void)`
		367	`{`
		368	`Datum d;`
		369	`double v;`
		370	`d.sym = (Symbol )(pc++);`
		371	`verify(d.sym);`
		372	`v = d.sym->u.val;`
		373	`d.sym->u.val += 1.0;`
		374	`d.val = v;`
		375	`push(d);`
		376	`}`
		377
		378	`void`
		379	`postdec(void)`
		380	`{`
		381	`Datum d;`
		382	`double v;`
		383	`d.sym = (Symbol )(pc++);`
		384	`verify(d.sym);`
		385	`v = d.sym->u.val;`
		386	`d.sym->u.val -= 1.0;`
		387	`d.val = v;`
		388	`push(d);`
		389	`}`
		390
		391	`void`
		392	`gt(void)`
		393	`{`
		394	`Datum d1, d2;`
		395	`d2 = pop();`
		396	`d1 = pop();`
		397	`d1.val = (double)(d1.val > d2.val);`
		398	`push(d1);`
		399	`}`
		400
		401	`void`
		402	`lt(void)`
		403	`{`
		404	`Datum d1, d2;`
		405	`d2 = pop();`
		406	`d1 = pop();`
		407	`d1.val = (double)(d1.val < d2.val);`
		408	`push(d1);`
		409	`}`
		410
		411	`void`
		412	`ge(void)`
		413	`{`
		414	`Datum d1, d2;`
		415	`d2 = pop();`
		416	`d1 = pop();`
		417	`d1.val = (double)(d1.val >= d2.val);`
		418	`push(d1);`
		419	`}`
		420
		421	`void`
		422	`le(void)`
		423	`{`
		424	`Datum d1, d2;`
		425	`d2 = pop();`
		426	`d1 = pop();`
		427	`d1.val = (double)(d1.val <= d2.val);`
		428	`push(d1);`
		429	`}`
		430
		431	`void`
		432	`eq(void)`
		433	`{`
		434	`Datum d1, d2;`
		435	`d2 = pop();`
		436	`d1 = pop();`
		437	`d1.val = (double)(d1.val == d2.val);`
		438	`push(d1);`
		439	`}`
		440
		441	`void`
		442	`ne(void)`
		443	`{`
		444	`Datum d1, d2;`
		445	`d2 = pop();`
		446	`d1 = pop();`
		447	`d1.val = (double)(d1.val != d2.val);`
		448	`push(d1);`
		449	`}`
		450
		451	`void`
		452	`and(void)`
		453	`{`
		454	`Datum d1, d2;`
		455	`d2 = pop();`
		456	`d1 = pop();`
		457	`d1.val = (double)(d1.val != 0.0 && d2.val != 0.0);`
		458	`push(d1);`
		459	`}`
		460
		461	`void`
		462	`or(void)`
		463	`{`
		464	`Datum d1, d2;`
		465	`d2 = pop();`
		466	`d1 = pop();`
		467	`d1.val = (double)(d1.val != 0.0 \|\| d2.val != 0.0);`
		468	`push(d1);`
		469	`}`
		470
		471	`void`
		472	`not(void)`
		473	`{`
		474	`Datum d;`
		475	`d = pop();`
		476	`d.val = (double)(d.val == 0.0);`
		477	`push(d);`
		478	`}`
		479
		480	`void`
		481	`power(void)`
		482	`{`
		483	`Datum d1, d2;`
		484	`d2 = pop();`
		485	`d1 = pop();`
		486	`d1.val = Pow(d1.val, d2.val);`
		487	`push(d1);`
		488	`}`
		489
		490	`void`
		491	`assign(void)`
		492	`{`
		493	`Datum d1, d2;`
		494	`d1 = pop();`
		495	`d2 = pop();`
		496	`if (d1.sym->type != VAR && d1.sym->type != UNDEF)`
		497	`execerror("assignment to non-variable",`
		498	`d1.sym->name);`
		499	`d1.sym->u.val = d2.val;`
		500	`d1.sym->type = VAR;`
		501	`push(d2);`
		502	`}`
		503
		504	`void`
		505	`addeq(void)`
		506	`{`
		507	`Datum d1, d2;`
		508	`d1 = pop();`
		509	`d2 = pop();`
		510	`if (d1.sym->type != VAR && d1.sym->type != UNDEF)`
		511	`execerror("assignment to non-variable",`
		512	`d1.sym->name);`
		513	`d2.val = d1.sym->u.val += d2.val;`
		514	`d1.sym->type = VAR;`
		515	`push(d2);`
		516	`}`
		517
		518	`void`
		519	`subeq(void)`
		520	`{`
		521	`Datum d1, d2;`
		522	`d1 = pop();`
		523	`d2 = pop();`
		524	`if (d1.sym->type != VAR && d1.sym->type != UNDEF)`
		525	`execerror("assignment to non-variable",`
		526	`d1.sym->name);`
		527	`d2.val = d1.sym->u.val -= d2.val;`
		528	`d1.sym->type = VAR;`
		529	`push(d2);`
		530	`}`
		531
		532	`void`
		533	`muleq(void)`
		534	`{`
		535	`Datum d1, d2;`
		536	`d1 = pop();`
		537	`d2 = pop();`
		538	`if (d1.sym->type != VAR && d1.sym->type != UNDEF)`
		539	`execerror("assignment to non-variable",`
		540	`d1.sym->name);`
		541	`d2.val = d1.sym->u.val *= d2.val;`
		542	`d1.sym->type = VAR;`
		543	`push(d2);`
		544	`}`
		545
		546	`void`
		547	`diveq(void)`
		548	`{`
		549	`Datum d1, d2;`
		550	`d1 = pop();`
		551	`d2 = pop();`
		552	`if (d1.sym->type != VAR && d1.sym->type != UNDEF)`
		553	`execerror("assignment to non-variable",`
		554	`d1.sym->name);`
		555	`d2.val = d1.sym->u.val /= d2.val;`
		556	`d1.sym->type = VAR;`
		557	`push(d2);`
		558	`}`
		559
		560	`void`
		561	`modeq(void)`
		562	`{`
		563	`Datum d1, d2;`
		564	`long x;`
		565	`d1 = pop();`
		566	`d2 = pop();`
		567	`if (d1.sym->type != VAR && d1.sym->type != UNDEF)`
		568	`execerror("assignment to non-variable",`
		569	`d1.sym->name);`
		570	`/* d2.val = d1.sym->u.val %= d2.val; */`
		571	`x = d1.sym->u.val;`
		572	`x %= (long) d2.val;`
		573	`d2.val = d1.sym->u.val = x;`
		574	`d1.sym->type = VAR;`
		575	`push(d2);`
		576	`}`
		577
		578	`void`
		579	`printtop(void) /* pop top value from stack, print it */`
		580	`{`
		581	`Datum d;`
		582	`static Symbol s; / last value computed */`
		583	`if (s == 0)`
		584	`s = install("_", VAR, 0.0);`
		585	`d = pop();`
		586	`print("%.12g\n", d.val);`
		587	`s->u.val = d.val;`
		588	`}`
		589
		590	`void`
		591	`prexpr(void) /* print numeric value */`
		592	`{`
		593	`Datum d;`
		594	`d = pop();`
		595	`print("%.12g ", d.val);`
		596	`}`
		597
		598	`void`
		599	`prstr(void) /* print string value */`
		600	`{`
		601	`print("%s", (char ) pc++);`
		602	`}`
		603
		604	`void`
		605	`varread(void) /* read into variable */`
		606	`{`
		607	`Datum d;`
		608	`extern Biobuf *bin;`
		609	`Symbol var = (Symbol ) *pc++;`
		610	`int c;`
		611
		612	`Again:`
		613	`do`
		614	`c = Bgetc(bin);`
		615	`while(c==' ' \|\| c=='\t' \|\| c=='\n');`
		616	`if(c == Beof){`
		617	`Iseof:`
		618	`if(moreinput())`
		619	`goto Again;`
		620	`d.val = var->u.val = 0.0;`
		621	`goto Return;`
		622	`}`
		623
		624	`if(strchr("+-.0123456789", c) == 0)`
		625	`execerror("non-number read into", var->name);`
		626	`Bungetc(bin);`
		627	`if(Bgetd(bin, &var->u.val) == Beof)`
		628	`goto Iseof;`
		629	`else`
		630	`d.val = 1.0;`
		631	`Return:`
		632	`var->type = VAR;`
		633	`push(d);`
		634	`}`
		635
		636	`Inst*`
		637	`code(Inst f) /* install one instruction or operand */`
		638	`{`
		639	`Inst *oprogp = progp;`
		640	`if (progp >= &prog[NPROG])`
		641	`execerror("program too big", (char *)0);`
		642	`*progp++ = f;`
		643	`return oprogp;`
		644	`}`
		645
		646	`void`
		647	`execute(Inst* p)`
		648	`{`
		649	`for (pc = p; *pc != STOP && !returning; )`
		650	`(*((++pc)[-1]))();`
		651	`}`

Subversion Repositories planix.SVN

(root)/os/branches/planix-v0/sys/src/cmd/hoc/code.c – Rev 9