WebSVN – planix.SVN – Blame – /os/trunk/sys/src/cmd/abaco/util.c

Rev	Author	Line No.	Line
2	-	1	`#include <u.h>`
		2	`#include <libc.h>`
		3	`#include <bio.h>`
		4	`#include <draw.h>`
		5	`#include <memdraw.h>`
		6	`#include <thread.h>`
		7	`#include <cursor.h>`
		8	`#include <mouse.h>`
		9	`#include <keyboard.h>`
		10	`#include <frame.h>`
		11	`#include <plumb.h>`
		12	`#include <html.h>`
		13	`#include <regexp.h>`
		14	`#include "dat.h"`
		15	`#include "fns.h"`
		16
		17	`static Point prevmouse;`
		18	`static Window *mousew;`
		19
		20	`int`
		21	`min(int a, int b)`
		22	`{`
		23	`if(a < b)`
		24	`return a;`
		25	`return b;`
		26	`}`
		27
		28	`int`
		29	`max(int a, int b)`
		30	`{`
		31	`if(a > b)`
		32	`return a;`
		33	`return b;`
		34	`}`
		35
		36	`void`
		37	`cvttorunes(char p, int n, Rune r, int nb, int nr, int *nulls)`
		38	`{`
		39	`uchar *q;`
		40	`Rune *s;`
		41	`int j, w;`
		42
		43	`/*`
		44	`* Always guaranteed that n bytes may be interpreted`
		45	`* without worrying about partial runes. This may mean`
		46	`* reading up to UTFmax-1 more bytes than n; the caller`
		47	`* knows this. If n is a firm limit, the caller should`
		48	`* set p[n] = 0.`
		49	`*/`
		50	`q = (uchar*)p;`
		51	`s = r;`
		52	`for(j=0; j<n; j+=w){`
		53	`if(*q < Runeself){`
		54	`w = 1;`
		55	`s = q++;`
		56	`}else{`
		57	`w = chartorune(s, (char*)q);`
		58	`q += w;`
		59	`}`
		60	`if(*s)`
		61	`s++;`
		62	`else if(nulls)`
		63	`*nulls = TRUE;`
		64	`}`
		65	`nb = (char)q-p;`
		66	`*nr = s-r;`
		67	`}`
		68
		69	`void`
		70	`bytetorunestr(char s, Runestr rs)`
		71	`{`
		72	`Rune *r;`
		73	`int nb, nr;`
		74
		75	`nb = strlen(s);`
		76	`r = runemalloc(nb+1);`
		77	`cvttorunes(s, nb, r, &nb, &nr, nil);`
		78	`r[nr] = '\0';`
		79	`rs->nr = nr;`
		80	`rs->r = r;`
		81	`}`
		82
		83	`void`
		84	`error(char *s)`
		85	`{`
		86	`fprint(2, "abaco: %s: %r\n", s);`
		87	`// abort();`
		88	`threadexitsall(s);`
		89	`}`
		90
		91	`void*`
		92	`emalloc(ulong n)`
		93	`{`
		94	`void *p;`
		95
		96	`p = malloc(n);`
		97	`if(p == nil)`
		98	`error("malloc failed");`
		99	`setmalloctag(p, getcallerpc(&n));`
		100	`memset(p, 0, n);`
		101	`return p;`
		102	`}`
		103
		104	`void*`
		105	`erealloc(void *p, ulong n)`
		106	`{`
		107	`p = realloc(p, n);`
		108	`if(p == nil)`
		109	`error("realloc failed");`
		110	`setmalloctag(p, getcallerpc(&n));`
		111	`return p;`
		112	`}`
		113
		114	`Rune*`
		115	`erunestrdup(Rune *r)`
		116	`{`
		117	`void *p;`
		118
		119	`if(r == nil)`
		120	`return nil;`
		121	`p = runestrdup(r);`
		122	`if(p == nil)`
		123	`error("runestrdup failed");`
		124	`setmalloctag(p, getcallerpc(&r));`
		125	`return p;`
		126	`}`
		127
		128	`char*`
		129	`estrdup(char *s)`
		130	`{`
		131	`char *t;`
		132
		133	`t = strdup(s);`
		134	`if(t == nil)`
		135	`error("strdup failed");`
		136	`setmalloctag(t, getcallerpc(&s));`
		137	`return t;`
		138	`}`
		139
		140	`int`
		141	`runestreq(Runestr a, Runestr b)`
		142	`{`
		143	`return runeeq(a.r, a.nr, b.r, b.nr);`
		144	`}`
		145
		146	`int`
		147	`runeeq(Rune s1, uint n1, Rune s2, uint n2)`
		148	`{`
		149	`if(n1 != n2)`
		150	`return FALSE;`
		151	`return memcmp(s1, s2, n1*sizeof(Rune)) == 0;`
		152	`}`
		153
		154	`void`
		155	`closerunestr(Runestr *rs)`
		156	`{`
		157
		158	`rs->nr = 0;`
		159	`if(rs->r)`
		160	`free(rs->r);`
		161	`rs->r = nil;`
		162	`}`
		163
		164	`void`
		165	`copyrunestr(Runestr a, Runestr b)`
		166	`{`
		167	`closerunestr(a);`
		168	`a->r = runemalloc(b->nr+1);`
		169	`runemove(a->r, b->r, b->nr);`
		170	`a->r[b->nr] = 0;`
		171	`a->nr = b->nr;`
		172	`}`
		173
		174	`int`
		175	`isalnum(Rune c)`
		176	`{`
		177	`/*`
		178	`* Hard to get absolutely right. Use what we know about ASCII`
		179	`* and assume anything above the Latin control characters is`
		180	`* potentially an alphanumeric.`
		181	`*/`
		182	`if(c <= ' ')`
		183	`return FALSE;`
		184	`if(0x7F<=c && c<=0xA0)`
		185	`return FALSE;`
		186	if(utfrune("!\"#$%&'()*+,-./:;<=>?@[\\]^`{\|}~", c))
		187	`return FALSE;`
		188	`return TRUE;`
		189	`}`
		190
		191	`Rune*`
		192	`skipbl(Rune r, int n, int np)`
		193	`{`
		194	`while(n>0 && (r==' ' \|\| r=='\t' \|\| *r=='\n')){`
		195	`--n;`
		196	`r++;`
		197	`}`
		198	`*np = n;`
		199	`return r;`
		200	`}`
		201
		202	`Rune*`
		203	`findbl(Rune r, int n, int np)`
		204	`{`
		205	`while(n>0 && r!=' ' && r!='\t' && *r!='\n'){`
		206	`--n;`
		207	`r++;`
		208	`}`
		209	`*np = n;`
		210	`return r;`
		211	`}`
		212
		213	`int`
		214	`istextfield(Item *i)`
		215	`{`
		216	`Formfield *ff;`
		217
		218	`ff = ((Iformfield *)i)->formfield;`
		219	`if(ff->ftype==Ftext \|\| ff->ftype==Ftextarea \|\| ff->ftype==Fpassword)`
		220	`return TRUE;`
		221
		222	`return FALSE;`
		223	`}`
		224
		225	`int`
		226	`forceitem(Item *i)`
		227	`{`
		228	`if(i->state&IFwrap && i->tag!=Iruletag && i->tag!=Itabletag)`
		229	`return FALSE;`
		230
		231	`return TRUE;`
		232	`}`
		233
		234	`int`
		235	`dimwidth(Dimen d, int w)`
		236	`{`
		237	`int s, k;`
		238
		239	`k = dimenkind(d);`
		240	`if(k == Dnone)`
		241	`return w;`
		242	`s = dimenspec(d);`
		243	`if(k == Dpixels)`
		244	`w = s;`
		245	`else if(k==Dpercent && s<100)`
		246	`w = s*w/100;`
		247
		248	`return w;`
		249	`}`
		250
		251	`void`
		252	`frdims(Dimen d, int n, int t, int *ret)`
		253	`{`
		254	`int totpix, totpcnt, totrel;`
		255	`double spix, spcnt, relu, vd;`
		256	`int tt, trest, totpixrel, minrelu, i;`
		257	`int x, spec, *kind;`
		258
		259	`if(n == 1){`
		260	`*ret = x = emalloc(sizeof(int));`
		261	`x[0] = t;`
		262	`return;`
		263	`}`
		264	`totpix = totpcnt = totrel = 0;`
		265	`spec = emalloc(n*sizeof(int));`
		266	`kind = emalloc(n*sizeof(int));`
		267	`for(i=0; i<n; i++){`
		268	`spec[i] = dimenspec(d[i]);`
		269	`if(spec[i] < 0)`
		270	`spec[i] = 0;`
		271	`kind[i] = dimenkind(d[i]);`
		272	`switch(kind[i]){`
		273	`case Dpixels:`
		274	`totpix += spec[i];`
		275	`break;`
		276	`case Dpercent:`
		277	`totpcnt += spec[i];`
		278	`break;`
		279	`case Drelative:`
		280	`totrel += spec[i];`
		281	`break;`
		282	`case Dnone:`
		283	`totrel++;`
		284	`break;`
		285	`}`
		286	`}`
		287	`spix = spcnt = 1.0;`
		288	`minrelu = 0;`
		289	`if(totrel > 0)`
		290	`minrelu = Scrollsize+Scrollgap;`
		291	`relu = (double)minrelu;`
		292	`tt = totpix + ttotpcnt/100 + totrelminrelu;`
		293	`if(tt < t){`
		294	`if(totrel == 0){`
		295	`if(totpcnt != 0)`
		296	`spcnt = (double)((t-totpix)100)/(double)(ttotpcnt);`
		297	`else`
		298	`spix = (double)t/(double)totpix;`
		299	`}else`
		300	`relu += (double)(t-tt)/(double)totrel;`
		301	`}else{`
		302	`totpixrel = totpix + totrel*minrelu;`
		303	`if(totpixrel < t)`
		304	`spcnt = (double)((t-totpixrel)100)/(double)(ttotpcnt);`
		305	`else{`
		306	`trest = t - totrel*minrelu;`
		307	`if(trest > 0)`
		308	`spcnt = (double)trest/(double)(totpix + (t*totpcnt/100));`
		309	`else{`
		310	`spcnt = (double)t/(double)tt;`
		311	`relu = 0.0;`
		312	`}`
		313	`spix = spcnt;`
		314	`}`
		315	`}`
		316	`x = emalloc(n * sizeof(int));`
		317	`tt = 0;`
		318	`for(i=0; i<n-1; i++){`
		319	`vd = (double)spec[i];`
		320	`switch(kind[i]){`
		321	`case Dpixels:`
		322	`vd = vd*spix;`
		323	`break;`
		324	`case Dpercent:`
		325	`vd = vd(double)tspcnt/100.0;`
		326	`break;`
		327	`case Drelative:`
		328	`vd = vd*relu;`
		329	`break;`
		330	`case Dnone:`
		331	`vd = relu;`
		332	`break;`
		333	`}`
		334	`x[i] = (int)(vd+.5);`
		335	`tt += x[i];`
		336	`}`
		337	`x[n - 1] = t - tt;`
		338	`*ret = x;`
		339	`free(spec);`
		340	`free(kind);`
		341	`}`
		342
		343	`Image *`
		344	`getbg(Page *p)`
		345	`{`
		346	`Docinfo *d;`
		347	`Cimage *ci;`
		348	`Image *bg;`
		349
		350	`d = p->doc;`
		351	`if(d->backgrounditem){`
		352	`if(d->backgrounditem->aux){`
		353	`ci = d->backgrounditem->aux;`
		354	`if(ci->mi)`
		355	`getimage(ci, d->backgrounditem->altrep);`
		356	`bg = ci->i;`
		357	`}else`
		358	`bg = display->white;`
		359	`}else`
		360	`bg = getcolor(d->background.color);`
		361
		362	`return bg;`
		363	`}`
		364
		365	`Rune *`
		366	`getbase(Page *p)`
		367	`{`
		368	`if(p->doc)`
		369	`return p->doc->base;`
		370	`if(p->url->act.r)`
		371	`return p->url->act.r;`
		372	`return p->url->src.r;`
		373	`}`
		374
		375	`Image *`
		376	`eallocimage(Display *d, Rectangle r, ulong chan, int repl, int col)`
		377	`{`
		378	`Image *i;`
		379
		380	`i = allocimage(d, r, chan, repl, col);`
		381	`if(i == nil)`
		382	`error("allocimage failed");`
		383	`return i;`
		384	`}`
		385
		386	`void`
		387	`rect3d(Image im, Rectangle r, int i, Image *c, Point sp)`
		388	`{`
		389	`Point p[6];`
		390
		391	`if(i < 0){`
		392	`r = insetrect(r, i);`
		393	`sp = addpt(sp, Pt(i,i));`
		394	`i = -i;`
		395	`}`
		396	`draw(im, Rect(r.min.x+i, r.min.y+i, r.max.x-i, r.max.y-i), c[2], nil, sp);`
		397	`p[0] = r.min;`
		398	`p[1] = Pt(r.min.x, r.max.y);`
		399	`p[2] = Pt(r.min.x+i, r.max.y-i);`
		400	`p[3] = Pt(r.min.x+i, r.min.y+i);`
		401	`p[4] = Pt(r.max.x-i, r.min.y+i);`
		402	`p[5] = Pt(r.max.x, r.min.y);`
		403	`fillpoly(im, p, 6, 0, c[0], sp);`
		404	`p[0] = r.max;`
		405	`p[1] = Pt(r.min.x, r.max.y);`
		406	`p[2] = Pt(r.min.x+i, r.max.y-i);`
		407	`p[3] = Pt(r.max.x-i, r.max.y-i);`
		408	`p[4] = Pt(r.max.x-i, r.min.y+i);`
		409	`p[5] = Pt(r.max.x, r.min.y);`
		410	`fillpoly(im, p, 6, 0, c[1], sp);`
		411	`}`
		412
		413	`void`
		414	`ellipse3d(Image im, Point p, int rad, int i, Image *c, Point sp)`
		415	`{`
		416	`fillarc(im, p, rad, rad, c[0], sp, 45, 180);`
		417	`fillarc(im, p, rad, rad, c[1], sp, 45, -180);`
		418	`fillellipse(im, p, rad-i, rad-i, c[2], sp);`
		419	`}`
		420
		421	`void`
		422	`colarray(Image *c, Image c0, Image c1, Image c2, int checked)`
		423	`{`
		424	`if(checked){`
		425	`c[0] = c0;`
		426	`c[1] = c1;`
		427	`}else{`
		428	`c[0] = c1;`
		429	`c[1] = c0;`
		430	`}`
		431	`c[2] = c2;`
		432	`}`
		433
		434	`static char *deffontpaths[] = {`
		435	`#include "fonts.h"`
		436	`};`
		437
		438	`static char *fontpaths[NumFnt];`
		439	`static Font *fonts[NumFnt];`
		440
		441	`void`
		442	`initfontpaths(void)`
		443	`{`
		444	`Biobufhdr *bp;`
		445	`char buf[128];`
		446	`int i;`
		447
		448	`/* we don't care if getenv(2) fails */`
		449	`snprint(buf, sizeof(buf)-1, "%s/lib/abaco.fonts", getenv("home"));`
		450	`if((bp=Bopen(buf, OREAD)) == nil)`
		451	`goto Default;`
		452
		453	`for(i=0; i<NumFnt; i++)`
		454	`if((fontpaths[i]=Brdstr(bp, '\n', 1)) == nil)`
		455	`goto Error;`
		456
		457	`Bterm(bp);`
		458	`return;`
		459	`Error:`
		460	`fprint(2, "abaco: not enough fontpaths in '%s'\n", buf);`
		461	`Bterm(bp);`
		462	`for(i--; i>=0; i--)`
		463	`free(fontpaths[i]);`
		464	`Default:`
		465	`for(i=0; i<NumFnt; i++)`
		466	`fontpaths[i] = deffontpaths[i];`
		467	`}`
		468
		469	`Font *`
		470	`getfont(int i)`
		471	`{`
		472	`if(fonts[i] == nil){`
		473	`fonts[i] = openfont(display, fontpaths[i]);`
		474	`if(fonts[i] == nil)`
		475	`error("can't open font file");`
		476	`}`
		477	`return fonts[i];`
		478	`}`
		479
		480	`typedef struct Color Color;`
		481
		482	`struct Color {`
		483	`int rgb;`
		484	`Image *i;`
		485	`Color *next;`
		486	`};`
		487
		488	`enum {`
		489	`NHASH = 19,`
		490	`};`
		491
		492	`static Color *colortab[NHASH];`
		493
		494	`Image *`
		495	`getcolor(int rgb)`
		496	`{`
		497	`Color *c;`
		498	`int h;`
		499
		500	`if(rgb == 0xFFFFFF)`
		501	`return display->white;`
		502	`else if(rgb == 0x000000)`
		503	`return display->black;`
		504
		505	`h = rgb%NHASH;`
		506	`for(c=colortab[h]; c!=nil; c=c->next)`
		507	`if(c->rgb == rgb){`
		508	`flushimage(display, 0); /* BUG? */`
		509	`return c->i;`
		510	`}`
		511	`c = emalloc(sizeof(Color));`
		512	`c->i = eallocimage(display, Rect(0,0,1,1), screen->chan, 1, (rgb<<8)\|0xFF);`
		513	`c->rgb = rgb;`
		514	`c->next = colortab[h];`
		515	`colortab[h] = c;`
		516
		517	`return c->i;`
		518	`}`
		519
		520	`int`
		521	`plumbrunestr(Runestr rs, char attr)`
		522	`{`
		523	`Plumbmsg *m;`
		524	`int i;`
		525
		526	`i = -1;`
		527	`if(plumbsendfd >= 0){`
		528	`m = emalloc(sizeof(Plumbmsg));`
		529	`m->src = estrdup("abaco");`
		530	`m->dst = nil;`
		531	`m->wdir = estrdup("/tmp");`
		532	`m->type = estrdup("text");`
		533	`if(attr)`
		534	`m->attr = plumbunpackattr(attr);`
		535	`else`
		536	`m->attr = nil;`
		537	`m->data = smprint("%.*S", rs->nr, rs->r);`
		538	`m->ndata = -1;`
		539	`i = plumbsend(plumbsendfd, m);`
		540	`plumbfree(m);`
		541	`}`
		542	`return i;`
		543	`}`
		544
		545	`int`
		546	`hexdigit(int v)`
		547	`{`
		548	`if(0<=v && v<=9)`
		549	`return '0' + v;`
		550	`else`
		551	`return 'A' + v - 10;`
		552	`}`
		553
		554	`static int`
		555	`inclass(char c, Rune* cl)`
		556	`{`
		557	`int n, ans, negate, i;`
		558
		559	`n = runestrlen(cl);`
		560	`if(n == 0)`
		561	`return 0;`
		562	`ans = 0;`
		563	`negate = 0;`
		564	`if(cl[0] == '^'){`
		565	`negate = 1;`
		566	`cl++;`
		567	`n--;`
		568	`}`
		569	`for(i=0; i<n; i++){`
		570	`if(cl[i]=='-' && i>0 && i<n-1){`
		571	`if(c>=cl[i - 1] && c<=cl[i+1]){`
		572	`ans = 1;`
		573	`break;`
		574	`}`
		575	`i++;`
		576	`}`
		577	`else if(c == cl[i]){`
		578	`ans = 1;`
		579	`break;`
		580	`}`
		581	`}`
		582	`if(negate)`
		583	`ans = !ans;`
		584	`return ans;`
		585	`}`
		586
		587	`Rune*`
		588	`ucvt(Rune* s)`
		589	`{`
		590	`Rune* u;`
		591	`char *t;`
		592	`int i, c, n, j, len;`
		593
		594	`t = smprint("%S", s);`
		595	`n = strlen(t);`
		596	`len = 0;`
		597	`for(i=0; i<n; i++){`
		598	`c = t[i];`
		599	`if(inclass(c, L"- /$_@.!*'(),a-zA-Z0-9"))`
		600	`len++;`
		601	`else`
		602	`len += 3;`
		603	`}`
		604	`u = runemalloc(len+1);`
		605	`j = 0;`
		606
		607	`for(i=0; i<n; i++){`
		608	`c = t[i];`
		609	`if(inclass(c, L"-/$_@.!*'(),a-zA-Z0-9"))`
		610	`u[j++] = c;`
		611	`else if(c == ' ')`
		612	`u[j++] = '+';`
		613	`else {`
		614	`u[j++] = '%';`
		615	`u[j++] = hexdigit((c >> 4)&15);`
		616	`u[j++] = hexdigit(c&15);`
		617	`}`
		618	`}`
		619	`u[j] = 0;`
		620	`free(t);`
		621	`return u;`
		622	`}`
		623
		624	`void`
		625	`reverseimages(Iimage **head)`
		626	`{`
		627	`Iimage r, c, *n;`
		628
		629	`r = nil;`
		630	`for(c=*head; c!=nil; c=n){`
		631	`n = c->nextimage;`
		632	`c->nextimage = r;`
		633	`r = c;`
		634	`}`
		635	`*head = r;`
		636	`}`
		637
		638	`char urlexpr[] = "^(https?\|ftp\|file\|gopher\|mailto\|news\|nntp\|telnet\|wais\|"`
		639	`"prospero)://([a-zA-Z0-9_@\\-]+([.:][a-zA-Z0-9_@\\-]+)*)";`
		640	`Reprog *urlprog;`
		641
		642	`int`
		643	`validurl(Rune *r)`
		644	`{`
		645	`Resub rs[10];`
		646
		647	`if(urlprog == nil){`
		648	`urlprog = regcomp(urlexpr);`
		649	`if(urlprog == nil)`
		650	`error("regcomp");`
		651	`}`
		652	`memset(rs, 0, sizeof(rs));`
		653	`if(rregexec(urlprog, r, rs, nelem(rs)) == 0)`
		654	`return FALSE;`
		655	`return TRUE;`
		656	`}`
		657
		658	`void`
		659	`execproc(void *v)`
		660	`{`
		661	`Channel *sync;`
		662	`Exec *e;`
		663	`int p[2], q[2];`
		664	`char *cmd;`
		665
		666	`threadsetname("execproc");`
		667	`e = v;`
		668	`p[0] = e->p[0];`
		669	`p[1] = e->p[1];`
		670	`q[0] = e->q[0];`
		671	`q[1] = e->q[1];`
		672	`cmd = e->cmd;`
		673	`sync = e->sync;`
		674	`rfork(RFFDG);`
		675	`free(e);`
		676	`dup(p[0], 0);`
		677	`close(p[0]);`
		678	`close(p[1]);`
		679	`if(q[0]){`
		680	`dup(q[1], 1);`
		681	`close(q[0]);`
		682	`close(q[1]);`
		683	`}`
		684	`if(!procstderr)`
		685	`close(2);`
		686	`procexecl(sync, "/bin/rc", "rc", "-c", cmd, 0);`
		687	`error("can't exec");`
		688	`}`
		689
		690	`static void`
		691	`writeproc(void *v)`
		692	`{`
		693	`Channel *sync;`
		694	`void **a;`
		695	`char *s;`
		696	`long np;`
		697	`int fd, i, n;`
		698
		699	`threadsetname("writeproc");`
		700	`a = v;`
		701	`sync = a[0];`
		702	`fd = (uintptr)a[1];`
		703	`s = a[2];`
		704	`np =(uintptr)a[3];`
		705	`free(a);`
		706
		707	`for(i=0; i<np; i+=n){`
		708	`n = np-i;`
		709	`if(n > BUFSIZE)`
		710	`n = BUFSIZE;`
		711	`if(write(fd, s+i, n) != n)`
		712	`break;`
		713	`}`
		714	`close(fd);`
		715	`sendul(sync, i);`
		716	`}`
		717
		718	`struct {`
		719	`char *mime;`
		720	`char *tcs;`
		721	`}tcstab[] = {`
		722
		723	`#include "tcs.h"`
		724
		725	`/* not generated by the script */`
		726	`"euc_jp", "jis",`
		727	`"euc_kr", "euc-k",`
		728	`"windows-874", "tis",`
		729	`nil, nil,`
		730	`};`
		731
		732	`enum {`
		733	`Winstart = 127,`
		734	`Winend = 159`
		735	`};`
		736
		737	`static int winchars[] = {`
		738	`8226, /* 8226 is a bullet */`
		739	`8226, 8226, 8218, 402, 8222, 8230, 8224, 8225,`
		740	`710, 8240, 352, 8249, 338, 8226, 8226, 8226,`
		741	`8226, 8216, 8217, 8220, 8221, 8226, 8211, 8212,`
		742	`732, 8482, 353, 8250, 339, 8226, 8226, 376`
		743	`};`
		744
		745	`char *`
		746	`tcs(char cs, char s, long *np)`
		747	`{`
		748	`Channel *sync;`
		749	`Exec *e;`
		750	`Rune r;`
		751	`long i, n;`
		752	`void **a;`
		753	`uchar *us;`
		754	`char buf[BUFSIZE], cmd[50];`
		755	`char t, u;`
		756	`int p[2], q[2];`
		757
		758
		759	`if(s==nil \|\| s=='\0' \|\| np==0){`
		760	`werrstr("tcs failed: no data");`
		761	`return s;`
		762	`}`
		763
		764	`if(cs == nil){`
		765	`werrstr("tcs failed: no charset");`
		766	`return s;`
		767	`}`
		768
		769	`if(cistrncmp(cs, "utf-8", 5)==0 \|\| cistrncmp(cs, "utf8", 4)==0)`
		770	`return s;`
		771
		772	`for(i=0; tcstab[i].mime!=nil; i++)`
		773	`if(cistrncmp(cs, tcstab[i].mime, strlen(tcstab[i].mime)) == 0)`
		774	`break;`
		775
		776	`if(tcstab[i].mime == nil){`
		777	`fprint(2, "abaco: charset: %s not supported\n", cs);`
		778	`goto latin1;`
		779	`}`
		780	`if(cistrcmp(tcstab[i].tcs, "8859-1")==0 \|\| cistrcmp(tcstab[i].tcs, "ascii")==0){`
		781	`latin1:`
		782	`n = 0;`
		783	`for(us=(uchar)s; us; us++)`
		784	`n += runelen(*us);`
		785	`n++;`
		786	`t = emalloc(n);`
		787	`for(us=(uchar)s, u=t; us; us++){`
		788	`if(us>=Winstart && us<=Winend)`
		789	`u++ = winchars[us-Winstart];`
		790	`else{`
		791	`r = *us;`
		792	`u += runetochar(u, &r);`
		793	`}`
		794	`}`
		795	`*u = 0;`
		796	`free(s);`
		797	`return t;`
		798	`}`
		799
		800	`if(pipe(p)<0 \|\| pipe(q)<0)`
		801	`error("can't create pipe");`
		802
		803	`sync = chancreate(sizeof(ulong), 0);`
		804	`if(sync == nil)`
		805	`error("can't create channel");`
		806
		807	`snprint(cmd, sizeof cmd, "tcs -f %s", tcstab[i].tcs);`
		808	`e = emalloc(sizeof(Exec));`
		809	`e->p[0] = p[0];`
		810	`e->p[1] = p[1];`
		811	`e->q[0] = q[0];`
		812	`e->q[1] = q[1];`
		813	`e->cmd = cmd;`
		814	`e->sync = sync;`
		815	`proccreate(execproc, e, STACK);`
		816	`recvul(sync);`
		817	`chanfree(sync);`
		818	`close(p[0]);`
		819	`close(q[1]);`
		820
		821	`/* in case tcs fails */`
		822	`t = s;`
		823	`sync = chancreate(sizeof(ulong), 0);`
		824	`if(sync == nil)`
		825	`error("can't create channel");`
		826
		827	`a = emalloc(4sizeof(void ));`
		828	`a[0] = sync;`
		829	`a[1] = (void *)p[1];`
		830	`a[2] = s;`
		831	`a[3] = (void )np;`
		832	`proccreate(writeproc, a, STACK);`
		833
		834	`s = nil;`
		835	`while((n = read(q[0], buf, sizeof(buf))) > 0){`
		836	`s = erealloc(s, i+n+1);`
		837	`memmove(s+i, buf, n);`
		838	`i += n;`
		839	`s[i] = '\0';`
		840	`}`
		841	`n = recvul(sync);`
		842	`if(n != *np)`
		843	`fprint(2, "tcs: did not write %ld; wrote %uld\n", *np, n);`
		844
		845	`*np = i;`
		846	`chanfree(sync);`
		847	`close(q[0]);`
		848
		849	`if(s == nil){`
		850	`fprint(2, "tcs failed: can't convert charset=%s to %s\n", cs, tcstab[i].tcs);`
		851	`return t;`
		852	`}`
		853	`free(t);`
		854
		855	`return s;`
		856	`}`
		857
		858	`static`
		859	`int`
		860	`isspace(char c)`
		861	`{`
		862	`return c==' ' \|\| c== '\t' \|\| c=='\r' \|\| c=='\n';`
		863	`}`
		864
		865	`static`
		866	`int`
		867	`findctype(char b, int l, char keyword, char *s)`
		868	`{`
		869	`char p, e;`
		870	`int i;`
		871
		872	`p = cistrstr(s, keyword);`
		873	`if(!p)`
		874	`return -1;`
		875	`p += strlen(keyword);`
		876	`while(p && isspace(p))`
		877	`p++;`
		878	`if(*p != '=')`
		879	`return -1;`
		880	`p++;`
		881	`while(p && isspace(p))`
		882	`p++;`
		883	`if(!*p)`
		884	`return -1;`
		885	`if(*p == '"'){`
		886	`p++;`
		887	`e = strchr(p, '"');`
		888	`if(!e)`
		889	`return -1;`
		890	`}else`
		891	`for(e = p; e < 127 && e > ' ' ; e++)`
		892	`;`
		893	`i = e-p;`
		894	`if(i < 1)`
		895	`return -1;`
		896	`snprint(b, l, "%.*s", i, p);`
		897	`return 0;`
		898	`}`
		899
		900	`static`
		901	`int`
		902	`finddocctype(char b, int l, char s)`
		903	`{`
		904	`char p, e;`
		905
		906	`p = cistrstr(s, "<meta");`
		907	`if(!p)`
		908	`return -1;`
		909	`p += 5;`
		910	`e = strchr(s, '>');`
		911	`if(!e)`
		912	`return -1;`
		913	`snprint(b, l, "%.*s", (int)(e-p), p);`
		914	`return 0;`
		915	`}`
		916
		917	`static`
		918	`int`
		919	`findxmltype(char b, int l, char s)`
		920	`{`
		921	`char p, e;`
		922
		923	`p = cistrstr(s, "<?xml ");`
		924	`if(!p)`
		925	`return -1;`
		926
		927	`p += 6;`
		928	`e = strstr(p, "?>");`
		929	`if(!e)`
		930	`return -1;`
		931	`snprint(b, l, "%.*s", (int)(e-p), p);`
		932
		933	`return 0;`
		934	`}`
		935
		936	`/*`
		937	`* servers can lie about lie about the charset,`
		938	`* so we use the charset based on the priority.`
		939	`*/`
		940	`char *`
		941	`convert(Runestr ctype, char s, long np)`
		942	`{`
		943	`char t[25], buf[256];`
		944
		945	`*t = '\0';`
		946	`if(ctype.nr){`
		947	`snprint(buf, sizeof(buf), "%.*S", ctype.nr, ctype.r);`
		948	`findctype(t, sizeof(t), "charset", buf);`
		949	`}`
		950	`if(findxmltype(buf, sizeof(buf), s)==0)`
		951	`findctype(t, sizeof(t), "encoding", buf);`
		952	`if(finddocctype(buf, sizeof(buf), s) == 0)`
		953	`findctype(t, sizeof(t), "charset", buf);`
		954
		955	`if(*t == '\0')`
		956	`strcpy(t, charset);`
		957	`return tcs(t, s, np);`
		958	`}`
		959
		960	`int`
		961	`xtofchar(Rune s, Font f, long p)`
		962	`{`
		963	`Rune *r;`
		964	`int q;`
		965
		966	`if(p == 0)`
		967	`return 0;`
		968
		969	`q = 0;`
		970	`for(r=s; *r!=L'\0'; r++){`
		971	`p -= runestringnwidth(f, r, 1);`
		972	`if(p < 0)`
		973	`break;`
		974	`q++;`
		975	`}`
		976	`return q;`
		977	`}`
		978
		979	`int`
		980	`istextsel(Page p, Rectangle r, int q0, int q1, Rune s, Font *f)`
		981	`{`
		982	`int topinr, botinr;`
		983
		984	`q0 = q1 = 0;`
		985	`topinr= ptinrect(p->top, r);`
		986	`if(topinr \|\| (r.min.y>p->top.y && r.max.y<p->bot.y))`
		987	`p->selecting = TRUE;`
		988	`botinr = ptinrect(p->bot, r);`
		989	`if(botinr \|\| r.min.y>p->bot.y)`
		990	`p->selecting = FALSE;`
		991
		992	`if(topinr \|\| botinr){`
		993	`if(topinr)`
		994	`*q0 = xtofchar(s, f, p->top.x-r.min.x);`
		995	`if(botinr)`
		996	`*q1 = xtofchar(s, f, p->bot.x-r.min.x);`
		997	`if(q0!=0 \|\| q1!=0)`
		998	`return TRUE;`
		999	`}`
		1000	`return p->selecting;`
		1001	`}`
		1002
		1003	`Point`
		1004	`getpt(Page *p, Point xy)`
		1005	`{`
		1006	`xy.x = xy.x-p->r.min.x+p->pos.x;`
		1007	`xy.y = xy.y-p->r.min.y+p->pos.y;`
		1008
		1009	`return xy;`
		1010	`}`
		1011
		1012	`void`
		1013	`getimage(Cimage ci, Rune altr)`
		1014	`{`
		1015	`Rectangle r;`
		1016	`Memimage *mi;`
		1017	`Image i, i2;`
		1018	`char buf[128];`
		1019	`uchar *bits;`
		1020	`int nbits;`
		1021
		1022	`mi = ci->mi;`
		1023	`if(mi == nil){`
		1024	`snprint(buf, sizeof(buf), "[%S]", altr ? altr : L"IMG");`
		1025	`r.min = Pt(0, 0);`
		1026	`r.max.x = 2*Space + stringwidth(font, buf);`
		1027	`r.max.y = 2*Space + font->height;`
		1028	`ci->i = eallocimage(display, r, GREY1, 1, DBlack);`
		1029	`r.min.x += Space;`
		1030	`r.min.y += Space;`
		1031	`string(ci->i, r.min, display->white, ZP, font, buf);`
		1032	`return;`
		1033	`}`
		1034	`nbits = bytesperline(mi->r, mi->depth)*Dy(mi->r);`
		1035	`bits = emalloc(nbits);`
		1036	`unloadmemimage(mi, mi->r, bits, nbits);`
		1037	`/*`
		1038	`/* get rid of alpha channel from transparent gif * /`
		1039
		1040	`if(mi->depth == 16){`
		1041	`for(y=1; y<nbits; y+=2)`
		1042	`bits[y>>1] = bits[y];`
		1043	`}`
		1044	`*/`
		1045	`i = eallocimage(display, mi->r, mi->chan, 0, DNofill);`
		1046	`loadimage(i, i->r, bits, nbits);`
		1047	`i2 = eallocimage(display, i->r, RGB24, 1, DNofill);`
		1048	`draw(i2, i2->r, display->black, nil, ZP);`
		1049	`draw(i2, i2->r, i, nil, i->r.min);`
		1050	`free(bits);`
		1051	`freememimage(mi);`
		1052	`freeimage(i);`
		1053	`ci->i = i2;`
		1054	`ci->mi = nil;`
		1055	`}`
		1056
		1057	`static`
		1058	`void`
		1059	`fixtext1(Item **list)`
		1060	`{`
		1061	`Itext text, ntext;`
		1062	`Item it, prev;`
		1063	`Rune s, s1, *s2;`
		1064	`int n;`
		1065
		1066	`if(*list == nil)`
		1067	`return;`
		1068
		1069	`prev = nil;`
		1070	`for(it=*list; it!=nil; it=prev->next){`
		1071	`if(it->tag!=Itexttag \|\| forceitem(it))`
		1072	`goto Continue;`
		1073
		1074	`text = (Itext *)it;`
		1075	`s = text->s;`
		1076	`while(s && isspacerune(s))`
		1077	`s++;`
		1078	`if(!*s){`
		1079	`if(prev == nil)`
		1080	`prev = *list = it->next;`
		1081	`else`
		1082	`prev->next = it->next;`
		1083
		1084	`it->next = nil;`
		1085	`freeitems(it);`
		1086	`if(prev == nil)`
		1087	`return;`
		1088	`continue;`
		1089	`}`
		1090	`n = 0;`
		1091	`while(s[n] && !isspacerune(s[n]))`
		1092	`n++;`
		1093
		1094	`if(!s[n])`
		1095	`goto Continue;`
		1096
		1097	`s1 = runemalloc(n+1);`
		1098	`s1 = runemove(s1, s, n);`
		1099	`s1[n] = L'\0';`
		1100	`s += n;`
		1101
		1102	`while(s && isspacerune(s))`
		1103	`s++;`
		1104
		1105	`if(*s){`
		1106	`n = runestrlen(s);`
		1107	`s2 = runemalloc(n+1);`
		1108	`runemove(s2, s, n);`
		1109	`s2[n] = L'\0';`
		1110	`ntext = emalloc(sizeof(Itext));`
		1111	`ntext->s = s2;`
		1112	`ntext->ascent = text->ascent;`
		1113	`ntext->anchorid = text->anchorid;`
		1114	`ntext->state = text->state&~(IFbrk\|IFbrksp\|IFnobrk\|IFcleft\|IFcright);`
		1115	`ntext->tag = text->tag;`
		1116	`ntext->fnt = text->fnt;`
		1117	`ntext->fg = text->fg;`
		1118	`ntext->ul = text->ul;`
		1119	`ntext->next = (Item *)text->next;`
		1120	`text->next = (Item *)ntext;`
		1121	`}`
		1122	`free(text->s);`
		1123	`text->s = s1;`
		1124	`Continue:`
		1125	`prev = it;`
		1126	`}`
		1127	`}`
		1128
		1129	`void`
		1130	`fixtext(Page *p)`
		1131	`{`
		1132	`Tablecell *c;`
		1133	`Table *t;`
		1134
		1135	`fixtext1(&p->items);`
		1136	`for(t=p->doc->tables; t!=nil; t=t->next)`
		1137	`for(c=t->cells; c!=nil; c=c->next)`
		1138	`fixtext1(&c->content);`
		1139	`}`
		1140
		1141	`typedef struct Refresh Refresh;`
		1142
		1143	`struct Refresh`
		1144	`{`
		1145	`Page *p;`
		1146	`Refresh *next;`
		1147	`};`
		1148
		1149	`static Refresh *refreshs = nil;`
		1150	`static QLock refreshlock;`
		1151
		1152	`void`
		1153	`addrefresh(Page p, char fmt, ...)`
		1154	`{`
		1155	`Refresh *r;`
		1156	`Rune *s;`
		1157	`va_list arg;`
		1158
		1159	`if(p->aborting)`
		1160	`return;`
		1161
		1162	`va_start(arg, fmt);`
		1163	`s = runevsmprint(fmt, arg);`
		1164	`va_end(arg);`
		1165	`if(s == nil)`
		1166	`error("runevsmprint failed");`
		1167
		1168	`if(p->status){`
		1169	`free(p->status);`
		1170	`p->status = nil;`
		1171	`}`
		1172	`p->status = s;`
		1173	`qlock(&refreshlock);`
		1174	`for(r=refreshs; r!=nil; r=r->next)`
		1175	`if(r->p == p)`
		1176	`goto Return;`
		1177
		1178	`incref(p->w); /* flushrefresh will decref */`
		1179	`r = emalloc(sizeof(Refresh));`
		1180	`r->p = p;`
		1181	`r->next = refreshs;`
		1182	`refreshs = r;`
		1183
		1184	`Return:`
		1185	`nbsendp(crefresh, nil);`
		1186	`qunlock(&refreshlock);`
		1187	`}`
		1188
		1189	`/* called while row is locked */`
		1190	`void`
		1191	`flushrefresh(void)`
		1192	`{`
		1193	`Refresh r, next;`
		1194	`Page *p;`
		1195
		1196	`qlock(&refreshlock);`
		1197	`for(r=refreshs; r!=nil; r=next){`
		1198	`p = r->p;`
		1199	`if(p->changed==TRUE && p->aborting==FALSE){`
		1200	`p->changed = FALSE;`
		1201	`if(p->parent==nil \|\| p->loading==FALSE)`
		1202	`pagerender(p);`
		1203	`if(!p->refresh.t)`
		1204	`pagesetrefresh(p);`
		1205	`}`
		1206	`if(p->status){`
		1207	`winsetstatus(p->w, p->status);`
		1208	`free(p->status);`
		1209	`p->status = nil;`
		1210	`}`
		1211	`winseturl(p->w);`
		1212	`winsettag(p->w);`
		1213	`decref(p->w);`
		1214	`next = r->next;`
		1215	`free(r);`
		1216	`}`
		1217	`refreshs = nil;`
		1218	`qunlock(&refreshlock);`
		1219	`}`
		1220
		1221	`void`
		1222	`savemouse(Window *w)`
		1223	`{`
		1224	`prevmouse = mouse->xy;`
		1225	`mousew = w;`
		1226	`}`
		1227
		1228	`void`
		1229	`restoremouse(Window *w)`
		1230	`{`
		1231	`if(mousew!=nil && mousew==w)`
		1232	`moveto(mousectl, prevmouse);`
		1233	`mousew = nil;`
		1234	`}`
		1235
		1236	`void`
		1237	`clearmouse()`
		1238	`{`
		1239	`mousew = nil;`
		1240	`}`
		1241
		1242	`/*`
		1243	`* Heuristic city.`
		1244	`*/`
		1245	`Window*`
		1246	`makenewwindow(Page *p)`
		1247	`{`
		1248	`Column *c;`
		1249	`Window w, bigw, *emptyw;`
		1250	`Page *emptyp;`
		1251	`int i, y, el;`
		1252
		1253	`if(activecol)`
		1254	`c = activecol;`
		1255	`else if(selpage && selpage->col)`
		1256	`c = selpage->col;`
		1257	`else if(p && p->col)`
		1258	`c = p->col;`
		1259	`else{`
		1260	`if(row.ncol==0 && rowadd(&row, nil, -1)==nil)`
		1261	`error("can't make column");`
		1262	`c = row.col[row.ncol-1];`
		1263	`}`
		1264	`activecol = c;`
		1265	`if(p==nil \|\| p->w==nil \|\| c->nw==0)`
		1266	`return coladd(c, nil, nil, -1);`
		1267
		1268	`/* find biggest window and biggest blank spot */`
		1269	`emptyw = c->w[0];`
		1270	`bigw = emptyw;`
		1271	`for(i=1; i<c->nw; i++){`
		1272	`w = c->w[i];`
		1273	`/* use >= to choose one near bottom of screen */`
		1274	`if(Dy(w->page.all) >= Dy(bigw->page.all))`
		1275	`bigw = w;`
		1276	`if(w->page.lay==nil && Dy(w->page.all) >= Dy(emptyw->page.all))`
		1277	`emptyw = w;`
		1278	`}`
		1279	`emptyp = &emptyw->page;`
		1280	`el = Dy(emptyp->all);`
		1281	`/* if empty space is big, use it */`
		1282	`if(el>15 \|\| (el>3 && el>(Dy(bigw->page.all)-1)/2))`
		1283	`y = emptyp->all.max.y;`
		1284	`else{`
		1285	`/* if this window is in column and isn't much smaller, split it */`
		1286	`if(p->col==c && Dy(p->w->r)>2*Dy(bigw->r)/3)`
		1287	`bigw = p->w;`
		1288	`y = (bigw->r.min.y + bigw->r.max.y)/2;`
		1289	`}`
		1290	`w = coladd(c, nil, nil, y);`
		1291	`colgrow(w->col, w, 1);`
		1292	`return w;`
		1293	`}`

Subversion Repositories planix.SVN

(root)/os/trunk/sys/src/cmd/abaco/util.c – Rev 2