WebSVN – planix.SVN – Blame – /os/branches/planix-v0/sys/src/cmd/units.y

Rev	Author	Line No.	Line
2	-	1	`%{`
		2	`#include <u.h>`
		3	`#include <libc.h>`
		4	`#include <bio.h>`
		5
		6	`enum`
		7	`{`
		8	`Ndim = 15, /* number of dimensions */`
		9	`Nsym = 40, /* size of a name */`
		10	`Nvar = 203, /* hash table size */`
		11	`Maxe = 695, /* log of largest number */`
		12	`};`
		13
		14	`typedef struct Var Var;`
		15	`typedef struct Node Node;`
		16	`typedef struct Prefix Prefix;`
		17
		18	`struct Node`
		19	`{`
		20	`double val;`
		21	`schar dim[Ndim];`
		22	`};`
		23	`struct Var`
		24	`{`
		25	`Rune name[Nsym];`
		26	`Node node;`
		27	`Var* link;`
		28	`};`
		29	`struct Prefix`
		30	`{`
		31	`double val;`
		32	`Rune* pname;`
		33	`};`
		34
		35	`char buf[100];`
		36	`int digval;`
		37	`Biobuf* fi;`
		38	`Biobuf linebuf;`
		39	`Var* fund[Ndim];`
		40	`Rune line[1000];`
		41	`ulong lineno;`
		42	`int linep;`
		43	`int nerrors;`
		44	`Node one;`
		45	`int peekrune;`
		46	`Node retnode1;`
		47	`Node retnode2;`
		48	`Node retnode;`
		49	`Rune sym[Nsym];`
		50	`Var* vars[Nvar];`
		51	`int vflag;`
		52
		53	`extern void add(Node, Node, Node*);`
		54	`extern void div(Node, Node, Node*);`
		55	`extern int specialcase(Node, Node, Node*);`
		56	`extern double fadd(double, double);`
		57	`extern double fdiv(double, double);`
		58	`extern double fmul(double, double);`
		59	`extern int gdigit(void*);`
		60	`extern Var* lookup(int);`
		61	`extern void main(int, char*[]);`
		62	`extern void mul(Node, Node, Node*);`
		63	`extern void ofile(void);`
		64	`extern double pname(void);`
		65	`extern void printdim(char*, int, int);`
		66	`extern int ralpha(int);`
		67	`extern int readline(void);`
		68	`extern void sub(Node, Node, Node*);`
		69	`extern int Ufmt(Fmt*);`
		70	`extern void xpn(Node, Node, int);`
		71	`extern void yyerror(char*, ...);`
		72	`extern int yylex(void);`
		73	`extern int yyparse(void);`
		74
		75	`typedef Node* indnode;`
		76	`#pragma varargck type "U" indnode`
		77
		78	`%}`
		79	`%union`
		80	`{`
		81	`Node node;`
		82	`Var* var;`
		83	`int numb;`
		84	`double val;`
		85	`}`
		86
		87	`%type <node> prog expr expr0 expr1 expr2 expr3 expr4`
		88
		89	`%token <val> VAL`
		90	`%token <var> VAR`
		91	`%token <numb> SUP`
		92	`%%`
		93	`prog:`
		94	`':' VAR expr`
		95	`{`
		96	`int f;`
		97
		98	`f = $2->node.dim[0];`
		99	`$2->node = $3;`
		100	`$2->node.dim[0] = 1;`
		101	`if(f)`
		102	`yyerror("redefinition of %S", $2->name);`
		103	`else`
		104	`if(vflag)`
		105	`print("%S\t%U\n", $2->name, &$2->node);`
		106	`}`
		107	`\| ':' VAR '#'`
		108	`{`
		109	`int f, i;`
		110
		111	`for(i=1; i<Ndim; i++)`
		112	`if(fund[i] == 0)`
		113	`break;`
		114	`if(i >= Ndim) {`
		115	`yyerror("too many dimensions");`
		116	`i = Ndim-1;`
		117	`}`
		118	`fund[i] = $2;`
		119
		120	`f = $2->node.dim[0];`
		121	`$2->node = one;`
		122	`$2->node.dim[0] = 1;`
		123	`$2->node.dim[i] = 1;`
		124	`if(f)`
		125	`yyerror("redefinition of %S", $2->name);`
		126	`else`
		127	`if(vflag)`
		128	`print("%S\t#\n", $2->name);`
		129	`}`
		130	`\| '?' expr`
		131	`{`
		132	`retnode1 = $2;`
		133	`}`
		134	`\| '?'`
		135	`{`
		136	`retnode1 = one;`
		137	`}`
		138
		139	`expr:`
		140	`expr4`
		141	`\| expr '+' expr4`
		142	`{`
		143	`add(&$$, &$1, &$3);`
		144	`}`
		145	`\| expr '-' expr4`
		146	`{`
		147	`sub(&$$, &$1, &$3);`
		148	`}`
		149
		150	`expr4:`
		151	`expr3`
		152	`\| expr4 '*' expr3`
		153	`{`
		154	`mul(&$$, &$1, &$3);`
		155	`}`
		156	`\| expr4 '/' expr3`
		157	`{`
		158	`div(&$$, &$1, &$3);`
		159	`}`
		160
		161	`expr3:`
		162	`expr2`
		163	`\| expr3 expr2`
		164	`{`
		165	`mul(&$$, &$1, &$2);`
		166	`}`
		167
		168	`expr2:`
		169	`expr1`
		170	`\| expr2 SUP`
		171	`{`
		172	`xpn(&$$, &$1, $2);`
		173	`}`
		174	`\| expr2 '^' expr1`
		175	`{`
		176	`int i;`
		177
		178	`for(i=1; i<Ndim; i++)`
		179	`if($3.dim[i]) {`
		180	`yyerror("exponent has units");`
		181	`$$ = $1;`
		182	`break;`
		183	`}`
		184	`if(i >= Ndim) {`
		185	`i = $3.val;`
		186	`if(i != $3.val)`
		187	`yyerror("exponent not integral");`
		188	`xpn(&$$, &$1, i);`
		189	`}`
		190	`}`
		191
		192	`expr1:`
		193	`expr0`
		194	`\| expr1 '\|' expr0`
		195	`{`
		196	`div(&$$, &$1, &$3);`
		197	`}`
		198
		199	`expr0:`
		200	`VAR`
		201	`{`
		202	`if($1->node.dim[0] == 0) {`
		203	`yyerror("undefined %S", $1->name);`
		204	`$$ = one;`
		205	`} else`
		206	`$$ = $1->node;`
		207	`}`
		208	`\| VAL`
		209	`{`
		210	`$$ = one;`
		211	`$$.val = $1;`
		212	`}`
		213	`\| '(' expr ')'`
		214	`{`
		215	`$$ = $2;`
		216	`}`
		217	`%%`
		218
		219	`int`
		220	`yylex(void)`
		221	`{`
		222	`int c, i;`
		223
		224	`c = peekrune;`
		225	`peekrune = ' ';`
		226
		227	`loop:`
		228	`if((c >= '0' && c <= '9') \|\| c == '.')`
		229	`goto numb;`
		230	`if(ralpha(c))`
		231	`goto alpha;`
		232	`switch(c) {`
		233	`case ' ':`
		234	`case '\t':`
		235	`c = line[linep++];`
		236	`goto loop;`
		237	`case L'×':`
		238	`return '*';`
		239	`case L'÷':`
		240	`return '/';`
		241	`case L'¹':`
		242	`case L'ⁱ':`
		243	`yylval.numb = 1;`
		244	`return SUP;`
		245	`case L'²':`
		246	`case L'⁲':`
		247	`yylval.numb = 2;`
		248	`return SUP;`
		249	`case L'³':`
		250	`case L'⁳':`
		251	`yylval.numb = 3;`
		252	`return SUP;`
		253	`}`
		254	`return c;`
		255
		256	`alpha:`
		257	`memset(sym, 0, sizeof(sym));`
		258	`for(i=0;; i++) {`
		259	`if(i < nelem(sym))`
		260	`sym[i] = c;`
		261	`c = line[linep++];`
		262	`if(!ralpha(c))`
		263	`break;`
		264	`}`
		265	`sym[nelem(sym)-1] = 0;`
		266	`peekrune = c;`
		267	`yylval.var = lookup(0);`
		268	`return VAR;`
		269
		270	`numb:`
		271	`digval = c;`
		272	`yylval.val = charstod(gdigit, 0);`
		273	`return VAL;`
		274	`}`
		275
		276	`void`
		277	`main(int argc, char *argv[])`
		278	`{`
		279	`char *file;`
		280
		281	`ARGBEGIN {`
		282	`default:`
		283	`print("usage: units [-v] [file]\n");`
		284	`exits("usage");`
		285	`case 'v':`
		286	`vflag = 1;`
		287	`break;`
		288	`} ARGEND`
		289
		290	`file = "/lib/units";`
		291	`if(argc > 0)`
		292	`file = argv[0];`
		293	`fi = Bopen(file, OREAD);`
		294	`if(fi == 0) {`
		295	`print("cant open: %s\n", file);`
		296	`exits("open");`
		297	`}`
		298	`fmtinstall('U', Ufmt);`
		299	`one.val = 1;`
		300
		301	`/*`
		302	`* read the 'units' file to`
		303	`* develope a database`
		304	`*/`
		305	`lineno = 0;`
		306	`for(;;) {`
		307	`lineno++;`
		308	`if(readline())`
		309	`break;`
		310	`if(line[0] == 0 \|\| line[0] == '/')`
		311	`continue;`
		312	`peekrune = ':';`
		313	`yyparse();`
		314	`}`
		315
		316	`/*`
		317	`* read the console to`
		318	`* print ratio of pairs`
		319	`*/`
		320	`Bterm(fi);`
		321	`fi = &linebuf;`
		322	`Binit(fi, 0, OREAD);`
		323	`lineno = 0;`
		324	`for(;;) {`
		325	`if(lineno & 1)`
		326	`print("you want: ");`
		327	`else`
		328	`print("you have: ");`
		329	`if(readline())`
		330	`break;`
		331	`peekrune = '?';`
		332	`nerrors = 0;`
		333	`yyparse();`
		334	`if(nerrors)`
		335	`continue;`
		336	`if(lineno & 1) {`
		337	`if(specialcase(&retnode, &retnode2, &retnode1))`
		338	`print("\tis %U\n", &retnode);`
		339	`else {`
		340	`div(&retnode, &retnode2, &retnode1);`
		341	`print("\t* %U\n", &retnode);`
		342	`div(&retnode, &retnode1, &retnode2);`
		343	`print("\t/ %U\n", &retnode);`
		344	`}`
		345	`} else`
		346	`retnode2 = retnode1;`
		347	`lineno++;`
		348	`}`
		349	`print("\n");`
		350	`exits(0);`
		351	`}`
		352
		353	`/*`
		354	`* all characters that have some`
		355	`* meaning. rest are usable as names`
		356	`*/`
		357	`int`
		358	`ralpha(int c)`
		359	`{`
		360	`switch(c) {`
		361	`case 0:`
		362	`case '+':`
		363	`case '-':`
		364	`case '*':`
		365	`case '/':`
		366	`case '[':`
		367	`case ']':`
		368	`case '(':`
		369	`case ')':`
		370	`case '^':`
		371	`case ':':`
		372	`case '?':`
		373	`case ' ':`
		374	`case '\t':`
		375	`case '.':`
		376	`case '\|':`
		377	`case '#':`
		378	`case L'¹':`
		379	`case L'ⁱ':`
		380	`case L'²':`
		381	`case L'⁲':`
		382	`case L'³':`
		383	`case L'⁳':`
		384	`case L'×':`
		385	`case L'÷':`
		386	`return 0;`
		387	`}`
		388	`return 1;`
		389	`}`
		390
		391	`int`
		392	`gdigit(void*)`
		393	`{`
		394	`int c;`
		395
		396	`c = digval;`
		397	`if(c) {`
		398	`digval = 0;`
		399	`return c;`
		400	`}`
		401	`c = line[linep++];`
		402	`peekrune = c;`
		403	`return c;`
		404	`}`
		405
		406	`void`
		407	`yyerror(char *fmt, ...)`
		408	`{`
		409	`va_list arg;`
		410
		411	`/*`
		412	`* hack to intercept message from yaccpar`
		413	`*/`
		414	`if(strcmp(fmt, "syntax error") == 0) {`
		415	`yyerror("syntax error, last name: %S", sym);`
		416	`return;`
		417	`}`
		418	`va_start(arg, fmt);`
		419	`vseprint(buf, buf+sizeof(buf), fmt, arg);`
		420	`va_end(arg);`
		421	`print("%ld: %S\n\t%s\n", lineno, line, buf);`
		422	`nerrors++;`
		423	`if(nerrors > 5) {`
		424	`print("too many errors\n");`
		425	`exits("errors");`
		426	`}`
		427	`}`
		428
		429	`void`
		430	`add(Node c, Node a, Node *b)`
		431	`{`
		432	`int i, d;`
		433
		434	`for(i=0; i<Ndim; i++) {`
		435	`d = a->dim[i];`
		436	`c->dim[i] = d;`
		437	`if(d != b->dim[i])`
		438	`yyerror("add must be like units");`
		439	`}`
		440	`c->val = fadd(a->val, b->val);`
		441	`}`
		442
		443	`void`
		444	`sub(Node c, Node a, Node *b)`
		445	`{`
		446	`int i, d;`
		447
		448	`for(i=0; i<Ndim; i++) {`
		449	`d = a->dim[i];`
		450	`c->dim[i] = d;`
		451	`if(d != b->dim[i])`
		452	`yyerror("sub must be like units");`
		453	`}`
		454	`c->val = fadd(a->val, -b->val);`
		455	`}`
		456
		457	`void`
		458	`mul(Node c, Node a, Node *b)`
		459	`{`
		460	`int i;`
		461
		462	`for(i=0; i<Ndim; i++)`
		463	`c->dim[i] = a->dim[i] + b->dim[i];`
		464	`c->val = fmul(a->val, b->val);`
		465	`}`
		466
		467	`void`
		468	`div(Node c, Node a, Node *b)`
		469	`{`
		470	`int i;`
		471
		472	`for(i=0; i<Ndim; i++)`
		473	`c->dim[i] = a->dim[i] - b->dim[i];`
		474	`c->val = fdiv(a->val, b->val);`
		475	`}`
		476
		477	`void`
		478	`xpn(Node c, Node a, int b)`
		479	`{`
		480	`int i;`
		481
		482	`*c = one;`
		483	`if(b < 0) {`
		484	`b = -b;`
		485	`for(i=0; i<b; i++)`
		486	`div(c, c, a);`
		487	`} else`
		488	`for(i=0; i<b; i++)`
		489	`mul(c, c, a);`
		490	`}`
		491
		492	`int`
		493	`specialcase(Node c, Node a, Node *b)`
		494	`{`
		495	`int i, d, d1, d2;`
		496
		497	`d1 = 0;`
		498	`d2 = 0;`
		499	`for(i=1; i<Ndim; i++) {`
		500	`d = a->dim[i];`
		501	`if(d) {`
		502	`if(d != 1 \|\| d1)`
		503	`return 0;`
		504	`d1 = i;`
		505	`}`
		506	`d = b->dim[i];`
		507	`if(d) {`
		508	`if(d != 1 \|\| d2)`
		509	`return 0;`
		510	`d2 = i;`
		511	`}`
		512	`}`
		513	`if(d1 == 0 \|\| d2 == 0)`
		514	`return 0;`
		515
		516	`if(memcmp(fund[d1]->name, L"°C", 3*sizeof(Rune)) == 0 &&`
		517	`memcmp(fund[d2]->name, L"°F", 3*sizeof(Rune)) == 0 &&`
		518	`b->val == 1) {`
		519	`memcpy(c->dim, b->dim, sizeof(c->dim));`
		520	`c->val = a->val * 9. / 5. + 32.;`
		521	`return 1;`
		522	`}`
		523
		524	`if(memcmp(fund[d1]->name, L"°F", 3*sizeof(Rune)) == 0 &&`
		525	`memcmp(fund[d2]->name, L"°C", 3*sizeof(Rune)) == 0 &&`
		526	`b->val == 1) {`
		527	`memcpy(c->dim, b->dim, sizeof(c->dim));`
		528	`c->val = (a->val - 32.) * 5. / 9.;`
		529	`return 1;`
		530	`}`
		531	`return 0;`
		532	`}`
		533
		534	`void`
		535	`printdim(char *str, int d, int n)`
		536	`{`
		537	`Var *v;`
		538
		539	`if(n) {`
		540	`v = fund[d];`
		541	`if(v)`
		542	`sprint(strchr(str, 0), " %S", v->name);`
		543	`else`
		544	`sprint(strchr(str, 0), " [%d]", d);`
		545	`switch(n) {`
		546	`case 1:`
		547	`break;`
		548	`case 2:`
		549	`strcat(str, "²");`
		550	`break;`
		551	`case 3:`
		552	`strcat(str, "³");`
		553	`break;`
		554	`default:`
		555	`sprint(strchr(str, 0), "^%d", n);`
		556	`}`
		557	`}`
		558	`}`
		559
		560	`int`
		561	`Ufmt(Fmt *fp)`
		562	`{`
		563	`char str[200];`
		564	`Node *n;`
		565	`int f, i, d;`
		566
		567	`n = va_arg(fp->args, Node*);`
		568	`sprint(str, "%g", n->val);`
		569
		570	`f = 0;`
		571	`for(i=1; i<Ndim; i++) {`
		572	`d = n->dim[i];`
		573	`if(d > 0)`
		574	`printdim(str, i, d);`
		575	`else`
		576	`if(d < 0)`
		577	`f = 1;`
		578	`}`
		579
		580	`if(f) {`
		581	`strcat(str, " /");`
		582	`for(i=1; i<Ndim; i++) {`
		583	`d = n->dim[i];`
		584	`if(d < 0)`
		585	`printdim(str, i, -d);`
		586	`}`
		587	`}`
		588
		589	`return fmtstrcpy(fp, str);`
		590	`}`
		591
		592	`int`
		593	`readline(void)`
		594	`{`
		595	`int i, c;`
		596
		597	`linep = 0;`
		598	`for(i=0;; i++) {`
		599	`c = Bgetrune(fi);`
		600	`if(c < 0)`
		601	`return 1;`
		602	`if(c == '\n')`
		603	`break;`
		604	`if(i < nelem(line))`
		605	`line[i] = c;`
		606	`}`
		607	`if(i >= nelem(line))`
		608	`i = nelem(line)-1;`
		609	`line[i] = 0;`
		610	`return 0;`
		611	`}`
		612
		613	`Var*`
		614	`lookup(int f)`
		615	`{`
		616	`int i;`
		617	`Var v, w;`
		618	`double p;`
		619	`ulong h;`
		620
		621	`h = 0;`
		622	`for(i=0; sym[i]; i++)`
		623	`h = h*13 + sym[i];`
		624	`h %= nelem(vars);`
		625
		626	`for(v=vars[h]; v; v=v->link)`
		627	`if(memcmp(sym, v->name, sizeof(sym)) == 0)`
		628	`return v;`
		629	`if(f)`
		630	`return 0;`
		631	`v = malloc(sizeof(*v));`
		632	`if(v == nil) {`
		633	`fprint(2, "out of memory\n");`
		634	`exits("mem");`
		635	`}`
		636	`memset(v, 0, sizeof(*v));`
		637	`memcpy(v->name, sym, sizeof(sym));`
		638	`v->link = vars[h];`
		639	`vars[h] = v;`
		640
		641	`p = 1;`
		642	`for(;;) {`
		643	`p = fmul(p, pname());`
		644	`if(p == 0)`
		645	`break;`
		646	`w = lookup(1);`
		647	`if(w) {`
		648	`v->node = w->node;`
		649	`v->node.val = fmul(v->node.val, p);`
		650	`break;`
		651	`}`
		652	`}`
		653	`return v;`
		654	`}`
		655
		656	`Prefix prefix[] =`
		657	`{`
		658	`1e-24, L"yocto",`
		659	`1e-21, L"zepto",`
		660	`1e-18, L"atto",`
		661	`1e-15, L"femto",`
		662	`1e-12, L"pico",`
		663	`1e-9, L"nano",`
		664	`1e-6, L"micro",`
		665	`1e-6, L"μ",`
		666	`1e-3, L"milli",`
		667	`1e-2, L"centi",`
		668	`1e-1, L"deci",`
		669	`1e1, L"deka",`
		670	`1e2, L"hecta",`
		671	`1e2, L"hecto",`
		672	`1e3, L"kilo",`
		673	`1e6, L"mega",`
		674	`1e6, L"meg",`
		675	`1e9, L"giga",`
		676	`1e12, L"tera",`
		677	`1e15, L"peta",`
		678	`1e18, L"exa",`
		679	`1e21, L"zetta",`
		680	`1e24, L"yotta",`
		681	`0, 0`
		682	`};`
		683
		684	`double`
		685	`pname(void)`
		686	`{`
		687	`Rune *p;`
		688	`int i, j, c;`
		689
		690	`/*`
		691	`* rip off normal prefixs`
		692	`*/`
		693	`for(i=0; p=prefix[i].pname; i++) {`
		694	`for(j=0; c=p[j]; j++)`
		695	`if(c != sym[j])`
		696	`goto no;`
		697	`memmove(sym, sym+j, (Nsym-j)sizeof(sym));`
		698	`memset(sym+(Nsym-j), 0, jsizeof(sym));`
		699	`return prefix[i].val;`
		700	`no:;`
		701	`}`
		702
		703	`/*`
		704	`* rip off 's' suffixes`
		705	`*/`
		706	`for(j=0; sym[j]; j++)`
		707	`;`
		708	`j--;`
		709	`/* j>1 is special hack to disallow ms finding m */`
		710	`if(j > 1 && sym[j] == 's') {`
		711	`sym[j] = 0;`
		712	`return 1;`
		713	`}`
		714	`return 0;`
		715	`}`
		716
		717	`/*`
		718	`* careful floating point`
		719	`*/`
		720	`double`
		721	`fmul(double a, double b)`
		722	`{`
		723	`double l;`
		724
		725	`if(a <= 0) {`
		726	`if(a == 0)`
		727	`return 0;`
		728	`l = log(-a);`
		729	`} else`
		730	`l = log(a);`
		731
		732	`if(b <= 0) {`
		733	`if(b == 0)`
		734	`return 0;`
		735	`l += log(-b);`
		736	`} else`
		737	`l += log(b);`
		738
		739	`if(l > Maxe) {`
		740	`yyerror("overflow in multiply");`
		741	`return 1;`
		742	`}`
		743	`if(l < -Maxe) {`
		744	`yyerror("underflow in multiply");`
		745	`return 0;`
		746	`}`
		747	`return a*b;`
		748	`}`
		749
		750	`double`
		751	`fdiv(double a, double b)`
		752	`{`
		753	`double l;`
		754
		755	`if(a <= 0) {`
		756	`if(a == 0)`
		757	`return 0;`
		758	`l = log(-a);`
		759	`} else`
		760	`l = log(a);`
		761
		762	`if(b <= 0) {`
		763	`if(b == 0) {`
		764	`yyerror("division by zero");`
		765	`return 1;`
		766	`}`
		767	`l -= log(-b);`
		768	`} else`
		769	`l -= log(b);`
		770
		771	`if(l > Maxe) {`
		772	`yyerror("overflow in divide");`
		773	`return 1;`
		774	`}`
		775	`if(l < -Maxe) {`
		776	`yyerror("underflow in divide");`
		777	`return 0;`
		778	`}`
		779	`return a/b;`
		780	`}`
		781
		782	`double`
		783	`fadd(double a, double b)`
		784	`{`
		785	`return a + b;`
		786	`}`

Subversion Repositories planix.SVN

(root)/os/branches/planix-v0/sys/src/cmd/units.y – Rev 2