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

Rev	Author	Line No.	Line
2	-	1	`#include <u.h>`
		2	`#include <libc.h>`
		3	`#include <bio.h>`
		4
		5	`/*`
		6	`* Deroff command -- strip troff, eqn, and tbl sequences from`
		7	`* a file. Has three flags argument, -w, to cause output one word per line`
		8	`* rather than in the original format.`
		9	`* -mm (or -ms) causes the corresponding macro's to be interpreted`
		10	`* so that just sentences are output`
		11	`* -ml also gets rid of lists.`
		12	`* -i causes deroff to ignore .so and .nx commands.`
		13	`* Deroff follows .so and .nx commands, removes contents of macro`
		14	`* definitions, equations (both .EQ ... .EN and $...$),`
		15	`* Tbl command sequences, and Troff backslash vconstructions.`
		16	`*`
		17	`* All input is through the C macro; the most recently read character is in c.`
		18	`*/`
		19
		20	`/*`
		21	`#define C ((c = Bgetrune(infile)) < 0?\`
		22	`eof():\`
		23	`((c == ldelim) && (filesp == files)?\`
		24	`skeqn():\`
		25	`(c == '\n'?\`
		26	`(linect++,c):\`
		27	`c)))`
		28
		29	`#define C1 ((c = Bgetrune(infile)) == Beof?\`
		30	`eof():\`
		31	`(c == '\n'?\`
		32	`(linect++,c):\`
		33	`c))`
		34	`*/`
		35
		36	`/* lose those macros! */`
		37	`#define C fC()`
		38	`#define C1 fC1()`
		39
		40	`#define SKIP while(C != '\n')`
		41	`#define SKIP1 while(C1 != '\n')`
		42	`#define SKIP_TO_COM SKIP;\`
		43	`SKIP;\`
		44	`pc=c;\`
		45	`while(C != '.' \|\| pc != '\n' \|\| C > 'Z')\`
		46	`pc=c`
		47
		48	`#define YES 1`
		49	`#define NO 0`
		50	`#define MS 0`
		51	`#define MM 1`
		52	`#define ONE 1`
		53	`#define TWO 2`
		54
		55	`#define NOCHAR -2`
		56	`#define EXTENDED -1 /* All runes above 0x7F */`
		57	`#define SPECIAL 0`
		58	`#define APOS 1`
		59	`#define PUNCT 2`
		60	`#define DIGIT 3`
		61	`#define LETTER 4`
		62
		63
		64	`int linect = 0;`
		65	`int wordflag= NO;`
		66	`int underscoreflag = NO;`
		67	`int msflag = NO;`
		68	`int iflag = NO;`
		69	`int mac = MM;`
		70	`int disp = 0;`
		71	`int inmacro = NO;`
		72	`int intable = NO;`
		73	`int eqnflag = 0;`
		74
		75	`#define MAX_ASCII 0X80`
		76
		77	`char chars[MAX_ASCII]; /* SPECIAL, PUNCT, APOS, DIGIT, or LETTER */`
		78
		79	`Rune line[30000];`
		80	`Rune* lp;`
		81
		82	`long c;`
		83	`long pc;`
		84	`int ldelim = NOCHAR;`
		85	`int rdelim = NOCHAR;`
		86
		87
		88	`char** argv;`
		89
		90	`char fname[50];`
		91	`Biobuf* files[15];`
		92	`Biobuf**filesp;`
		93	`Biobuf* infile;`
		94	`char* devnull = "/dev/null";`
		95	`Biobuf *infile;`
		96	`Biobuf bout;`
		97
		98	`long skeqn(void);`
		99	`Biobuf* opn(char *p);`
		100	`int eof(void);`
		101	`int charclass(int);`
		102	`void getfname(void);`
		103	`void fatal(char s, char p);`
		104	`void usage(void);`
		105	`void work(void);`
		106	`void putmac(Rune *rp, int vconst);`
		107	`void regline(int macline, int vconst);`
		108	`void putwords(void);`
		109	`void comline(void);`
		110	`void macro(void);`
		111	`void eqn(void);`
		112	`void tbl(void);`
		113	`void stbl(void);`
		114	`void sdis(char a1, char a2);`
		115	`void sce(void);`
		116	`void backsl(void);`
		117	`char* copys(char *s);`
		118	`void refer(int c1);`
		119	`void inpic(void);`
		120
		121	`int`
		122	`fC(void)`
		123	`{`
		124	`c = Bgetrune(infile);`
		125	`if(c < 0)`
		126	`return eof();`
		127	`if(c == ldelim && filesp == files)`
		128	`return skeqn();`
		129	`if(c == '\n')`
		130	`linect++;`
		131	`return c;`
		132	`}`
		133
		134	`int`
		135	`fC1(void)`
		136	`{`
		137	`c = Bgetrune(infile);`
		138	`if(c == Beof)`
		139	`return eof();`
		140	`if(c == '\n')`
		141	`linect++;`
		142	`return c;`
		143	`}`
		144
		145	`void`
		146	`main(int argc, char *av[])`
		147	`{`
		148	`int i;`
		149	`char *f;`
		150
		151	`argv = av;`
		152	`Binit(&bout, 1, OWRITE);`
		153	`ARGBEGIN{`
		154	`case 'w':`
		155	`wordflag = YES;`
		156	`break;`
		157	`case '_':`
		158	`wordflag = YES;`
		159	`underscoreflag = YES;`
		160	`break;`
		161	`case 'm':`
		162	`msflag = YES;`
		163	`if(f = ARGF())`
		164	`switch(*f)`
		165	`{`
		166	`case 'm': mac = MM; break;`
		167	`case 's': mac = MS; break;`
		168	`case 'l': disp = 1; break;`
		169	`default: usage();`
		170	`}`
		171	`else`
		172	`usage();`
		173	`break;`
		174	`case 'i':`
		175	`iflag = YES;`
		176	`break;`
		177	`default:`
		178	`usage();`
		179	`}ARGEND`
		180	`if(*argv)`
		181	`infile = opn(*argv++);`
		182	`else{`
		183	`infile = malloc(sizeof(Biobuf));`
		184	`Binit(infile, 0, OREAD);`
		185	`}`
		186	`files[0] = infile;`
		187	`filesp = &files[0];`
		188
		189	`for(i='a'; i<='z' ; ++i)`
		190	`chars[i] = LETTER;`
		191	`for(i='A'; i<='Z'; ++i)`
		192	`chars[i] = LETTER;`
		193	`for(i='0'; i<='9'; ++i)`
		194	`chars[i] = DIGIT;`
		195	`chars['\''] = APOS;`
		196	`chars['&'] = APOS;`
		197	`chars['\b'] = APOS;`
		198	`chars['.'] = PUNCT;`
		199	`chars[','] = PUNCT;`
		200	`chars[';'] = PUNCT;`
		201	`chars['?'] = PUNCT;`
		202	`chars[':'] = PUNCT;`
		203	`work();`
		204	`}`
		205
		206	`long`
		207	`skeqn(void)`
		208	`{`
		209	`while(C1 != rdelim)`
		210	`if(c == '\\')`
		211	`c = C1;`
		212	`else if(c == '"')`
		213	`while(C1 != '"')`
		214	`if(c == '\\')`
		215	`C1;`
		216	`if (msflag)`
		217	`eqnflag = 1;`
		218	`return(c = ' ');`
		219	`}`
		220
		221	`Biobuf*`
		222	`opn(char *p)`
		223	`{`
		224	`Biobuf *fd;`
		225
		226	`while ((fd = Bopen(p, OREAD)) == 0) {`
		227	`if(msflag \|\| p == devnull)`
		228	`fatal("Cannot open file %s - quitting\n", p);`
		229	`else {`
		230	`fprint(2, "Deroff: Cannot open file %s - continuing\n", p);`
		231	`p = devnull;`
		232	`}`
		233	`}`
		234	`linect = 0;`
		235	`return(fd);`
		236	`}`
		237
		238	`int`
		239	`eof(void)`
		240	`{`
		241	`if(Bfildes(infile) != 0)`
		242	`Bterm(infile);`
		243	`if(filesp > files)`
		244	`infile = *--filesp;`
		245	`else`
		246	`if(*argv)`
		247	`infile = opn(*argv++);`
		248	`else`
		249	`exits(0);`
		250	`return(C);`
		251	`}`
		252
		253	`void`
		254	`getfname(void)`
		255	`{`
		256	`char *p;`
		257	`Rune r;`
		258	`Dir *dir;`
		259	`struct chain`
		260	`{`
		261	`struct chain* nextp;`
		262	`char* datap;`
		263	`} *q;`
		264
		265	`static struct chain *namechain= 0;`
		266
		267	`while(C == ' ')`
		268	`;`
		269	`for(p = fname; (r=c) != '\n' && r != ' ' && r != '\t' && r != '\\'; C)`
		270	`p += runetochar(p, &r);`
		271	`*p = '\0';`
		272	`while(c != '\n')`
		273	`C;`
		274	`if(!strcmp(fname, "/sys/lib/tmac/tmac.cs")`
		275	`\|\| !strcmp(fname, "/sys/lib/tmac/tmac.s")) {`
		276	`fname[0] = '\0';`
		277	`return;`
		278	`}`
		279	`dir = dirstat(fname);`
		280	`if(dir!=nil && ((dir->mode & DMDIR) \|\| dir->type != 'M')) {`
		281	`free(dir);`
		282	`fname[0] = '\0';`
		283	`return;`
		284	`}`
		285	`free(dir);`
		286	`/*`
		287	`* see if this name has already been used`
		288	`*/`
		289
		290	`for(q = namechain; q; q = q->nextp)`
		291	`if( !strcmp(fname, q->datap)) {`
		292	`fname[0] = '\0';`
		293	`return;`
		294	`}`
		295	`q = (struct chain*)malloc(sizeof(struct chain));`
		296	`q->nextp = namechain;`
		297	`q->datap = copys(fname);`
		298	`namechain = q;`
		299	`}`
		300
		301	`void`
		302	`usage(void)`
		303	`{`
		304	`fprint(2,"usage: deroff [-nw_pi] [-m (m s l)] [file ...] \n");`
		305	`exits("usage");`
		306	`}`
		307
		308	`void`
		309	`fatal(char s, char p)`
		310	`{`
		311	`fprint(2, "deroff: ");`
		312	`fprint(2, s, p);`
		313	`exits(s);`
		314	`}`
		315
		316	`void`
		317	`work(void)`
		318	`{`
		319
		320	`for(;;) {`
		321	`eqnflag = 0;`
		322	`if(C == '.' \|\| c == '\'')`
		323	`comline();`
		324	`else`
		325	`regline(NO, TWO);`
		326	`}`
		327	`}`
		328
		329	`void`
		330	`regline(int macline, int vconst)`
		331	`{`
		332	`line[0] = c;`
		333	`lp = line;`
		334	`for(;;) {`
		335	`if(c == '\\') {`
		336	`*lp = ' ';`
		337	`backsl();`
		338	`if(c == '%') /* no blank for hyphenation char */`
		339	`lp--;`
		340	`}`
		341	`if(c == '\n')`
		342	`break;`
		343	`if(intable && c=='T') {`
		344	`*++lp = C;`
		345	`if(c=='{' \|\| c=='}') {`
		346	`lp[-1] = ' ';`
		347	`*lp = C;`
		348	`}`
		349	`} else {`
		350	`if(msflag == 1 && eqnflag == 1) {`
		351	`eqnflag = 0;`
		352	`*++lp = 'x';`
		353	`}`
		354	`*++lp = C;`
		355	`}`
		356	`}`
		357	`*lp = '\0';`
		358	`if(lp != line) {`
		359	`if(wordflag)`
		360	`putwords();`
		361	`else`
		362	`if(macline)`
		363	`putmac(line,vconst);`
		364	`else`
		365	`Bprint(&bout, "%S\n", line);`
		366	`}`
		367	`}`
		368
		369	`void`
		370	`putmac(Rune *rp, int vconst)`
		371	`{`
		372	`Rune *t;`
		373	`int found;`
		374	`Rune last;`
		375
		376	`found = 0;`
		377	`last = 0;`
		378	`while(*rp) {`
		379	`while(rp == ' ' \|\| rp == '\t')`
		380	`Bputrune(&bout, *rp++);`
		381	`for(t = rp; t != ' ' && t != '\t' && *t != '\0'; t++)`
		382	`;`
		383	`if(*rp == '\"')`
		384	`rp++;`
		385	`if(t > rp+vconst && charclass(*rp) == LETTER`
		386	`&& charclass(rp[1]) == LETTER) {`
		387	`while(rp < t)`
		388	`if(*rp == '\"')`
		389	`rp++;`
		390	`else`
		391	`Bputrune(&bout, *rp++);`
		392	`last = t[-1];`
		393	`found++;`
		394	`} else`
		395	`if(found && charclass(*rp) == PUNCT && rp[1] == '\0')`
		396	`Bputrune(&bout, *rp++);`
		397	`else {`
		398	`last = t[-1];`
		399	`rp = t;`
		400	`}`
		401	`}`
		402	`Bputc(&bout, '\n');`
		403	`if(msflag && charclass(last) == PUNCT)`
		404	`Bprint(&bout, " %C\n", last);`
		405	`}`
		406
		407	`/*`
		408	`* break into words for -w option`
		409	`*/`
		410	`void`
		411	`putwords(void)`
		412	`{`
		413	`Rune p, p1;`
		414	`int i, nlet;`
		415
		416
		417	`for(p1 = line;;) {`
		418	`/*`
		419	`* skip initial specials ampersands and apostrophes`
		420	`*/`
		421	`while((i = charclass(*p1)) != EXTENDED && i < DIGIT)`
		422	`if(*p1++ == '\0')`
		423	`return;`
		424	`nlet = 0;`
		425	`for(p = p1; (i = charclass(p)) != SPECIAL \|\| (underscoreflag && p=='_'); p++)`
		426	`if(i == LETTER \|\| (underscoreflag && *p == '_'))`
		427	`nlet++;`
		428	`/*`
		429	`* MDM definition of word`
		430	`*/`
		431	`if(nlet > 1) {`
		432	`/*`
		433	`* delete trailing ampersands and apostrophes`
		434	`*/`
		435	`while(--p == '\'' \|\| p == '&'`
		436	`\|\| charclass(*p) == PUNCT)`
		437	`;`
		438	`while(p1 <= p)`
		439	`Bputrune(&bout, *p1++);`
		440	`Bputc(&bout, '\n');`
		441	`} else`
		442	`p1 = p;`
		443	`}`
		444	`}`
		445
		446	`void`
		447	`comline(void)`
		448	`{`
		449	`long c1, c2;`
		450
		451	`while(C==' ' \|\| c=='\t')`
		452	`;`
		453	`comx:`
		454	`if((c1=c) == '\n')`
		455	`return;`
		456	`c2 = C;`
		457	`if(c1=='.' && c2!='.')`
		458	`inmacro = NO;`
		459	`if(msflag && c1 == '['){`
		460	`refer(c2);`
		461	`return;`
		462	`}`
		463	`if(c2 == '\n')`
		464	`return;`
		465	`if(c1 == '\\' && c2 == '\"')`
		466	`SKIP;`
		467	`else`
		468	`if (filesp==files && c1=='E' && c2=='Q')`
		469	`eqn();`
		470	`else`
		471	`if(filesp==files && c1=='T' && (c2=='S' \|\| c2=='C' \|\| c2=='&')) {`
		472	`if(msflag)`
		473	`stbl();`
		474	`else`
		475	`tbl();`
		476	`}`
		477	`else`
		478	`if(c1=='T' && c2=='E')`
		479	`intable = NO;`
		480	`else if (!inmacro &&`
		481	`((c1 == 'd' && c2 == 'e') \|\|`
		482	`(c1 == 'i' && c2 == 'g') \|\|`
		483	`(c1 == 'a' && c2 == 'm')))`
		484	`macro();`
		485	`else`
		486	`if(c1=='s' && c2=='o') {`
		487	`if(iflag)`
		488	`SKIP;`
		489	`else {`
		490	`getfname();`
		491	`if(fname[0]) {`
		492	`if(infile = opn(fname))`
		493	`*++filesp = infile;`
		494	`else infile = *filesp;`
		495	`}`
		496	`}`
		497	`}`
		498	`else`
		499	`if(c1=='n' && c2=='x')`
		500	`if(iflag)`
		501	`SKIP;`
		502	`else {`
		503	`getfname();`
		504	`if(fname[0] == '\0')`
		505	`exits(0);`
		506	`if(Bfildes(infile) != 0)`
		507	`Bterm(infile);`
		508	`infile = *filesp = opn(fname);`
		509	`}`
		510	`else`
		511	`if(c1 == 't' && c2 == 'm')`
		512	`SKIP;`
		513	`else`
		514	`if(c1=='h' && c2=='w')`
		515	`SKIP;`
		516	`else`
		517	`if(msflag && c1 == 'T' && c2 == 'L') {`
		518	`SKIP_TO_COM;`
		519	`goto comx;`
		520	`}`
		521	`else`
		522	`if(msflag && c1=='N' && c2 == 'R')`
		523	`SKIP;`
		524	`else`
		525	`if(msflag && c1 == 'A' && (c2 == 'U' \|\| c2 == 'I')){`
		526	`if(mac==MM)SKIP;`
		527	`else {`
		528	`SKIP_TO_COM;`
		529	`goto comx;`
		530	`}`
		531	`} else`
		532	`if(msflag && c1=='F' && c2=='S') {`
		533	`SKIP_TO_COM;`
		534	`goto comx;`
		535	`}`
		536	`else`
		537	`if(msflag && (c1=='S' \|\| c1=='N') && c2=='H') {`
		538	`SKIP_TO_COM;`
		539	`goto comx;`
		540	`} else`
		541	`if(c1 == 'U' && c2 == 'X') {`
		542	`if(wordflag)`
		543	`Bprint(&bout, "UNIX\n");`
		544	`else`
		545	`Bprint(&bout, "UNIX ");`
		546	`} else`
		547	`if(msflag && c1=='O' && c2=='K') {`
		548	`SKIP_TO_COM;`
		549	`goto comx;`
		550	`} else`
		551	`if(msflag && c1=='N' && c2=='D')`
		552	`SKIP;`
		553	`else`
		554	`if(msflag && mac==MM && c1=='H' && (c2==' '\|\|c2=='U'))`
		555	`SKIP;`
		556	`else`
		557	`if(msflag && mac==MM && c2=='L') {`
		558	`if(disp \|\| c1=='R')`
		559	`sdis('L', 'E');`
		560	`else {`
		561	`SKIP;`
		562	`Bprint(&bout, " .");`
		563	`}`
		564	`} else`
		565	`if(!msflag && c1=='P' && c2=='S') {`
		566	`inpic();`
		567	`} else`
		568	`if(msflag && (c1=='D' \|\| c1=='N' \|\| c1=='K'\|\| c1=='P') && c2=='S') {`
		569	`sdis(c1, 'E');`
		570	`} else`
		571	`if(msflag && (c1 == 'K' && c2 == 'F')) {`
		572	`sdis(c1,'E');`
		573	`} else`
		574	`if(msflag && c1=='n' && c2=='f')`
		575	`sdis('f','i');`
		576	`else`
		577	`if(msflag && c1=='c' && c2=='e')`
		578	`sce();`
		579	`else {`
		580	`if(c1=='.' && c2=='.') {`
		581	`if(msflag) {`
		582	`SKIP;`
		583	`return;`
		584	`}`
		585	`while(C == '.')`
		586	`;`
		587	`}`
		588	`inmacro++;`
		589	`if(c1 <= 'Z' && msflag)`
		590	`regline(YES,ONE);`
		591	`else {`
		592	`if(wordflag)`
		593	`C;`
		594	`regline(YES,TWO);`
		595	`}`
		596	`inmacro--;`
		597	`}`
		598	`}`
		599
		600	`void`
		601	`macro(void)`
		602	`{`
		603	`if(msflag) {`
		604	`do {`
		605	`SKIP1;`
		606	`} while(C1 != '.' \|\| C1 != '.' \|\| C1 == '.');`
		607	`if(c != '\n')`
		608	`SKIP;`
		609	`return;`
		610	`}`
		611	`SKIP;`
		612	`inmacro = YES;`
		613	`}`
		614
		615	`void`
		616	`sdis(char a1, char a2)`
		617	`{`
		618	`int c1, c2;`
		619	`int eqnf;`
		620	`int lct;`
		621
		622	`if(a1 == 'P'){`
		623	`while(C1 == ' ')`
		624	`;`
		625	`if(c == '<') {`
		626	`SKIP1;`
		627	`return;`
		628	`}`
		629	`}`
		630	`lct = 0;`
		631	`eqnf = 1;`
		632	`if(c != '\n')`
		633	`SKIP1;`
		634	`for(;;) {`
		635	`while(C1 != '.')`
		636	`if(c == '\n')`
		637	`continue;`
		638	`else`
		639	`SKIP1;`
		640	`if((c1=C1) == '\n')`
		641	`continue;`
		642	`if((c2=C1) == '\n') {`
		643	`if(a1 == 'f' && (c1 == 'P' \|\| c1 == 'H'))`
		644	`return;`
		645	`continue;`
		646	`}`
		647	`if(c1==a1 && c2 == a2) {`
		648	`SKIP1;`
		649	`if(lct != 0){`
		650	`lct--;`
		651	`continue;`
		652	`}`
		653	`if(eqnf)`
		654	`Bprint(&bout, " .");`
		655	`Bputc(&bout, '\n');`
		656	`return;`
		657	`} else`
		658	`if(a1 == 'L' && c2 == 'L') {`
		659	`lct++;`
		660	`SKIP1;`
		661	`} else`
		662	`if(a1 == 'D' && c1 == 'E' && c2 == 'Q') {`
		663	`eqn();`
		664	`eqnf = 0;`
		665	`} else`
		666	`if(a1 == 'f') {`
		667	`if((mac == MS && c2 == 'P') \|\|`
		668	`(mac == MM && c1 == 'H' && c2 == 'U')){`
		669	`SKIP1;`
		670	`return;`
		671	`}`
		672	`SKIP1;`
		673	`}`
		674	`else`
		675	`SKIP1;`
		676	`}`
		677	`}`
		678
		679	`void`
		680	`tbl(void)`
		681	`{`
		682	`while(C != '.')`
		683	`;`
		684	`SKIP;`
		685	`intable = YES;`
		686	`}`
		687
		688	`void`
		689	`stbl(void)`
		690	`{`
		691	`while(C != '.')`
		692	`;`
		693	`SKIP_TO_COM;`
		694	`if(c != 'T' \|\| C != 'E') {`
		695	`SKIP;`
		696	`pc = c;`
		697	`while(C != '.' \|\| pc != '\n' \|\| C != 'T' \|\| C != 'E')`
		698	`pc = c;`
		699	`}`
		700	`}`
		701
		702	`void`
		703	`eqn(void)`
		704	`{`
		705	`long c1, c2;`
		706	`int dflg;`
		707	`char last;`
		708
		709	`last = 0;`
		710	`dflg = 1;`
		711	`SKIP;`
		712
		713	`for(;;) {`
		714	`if(C1 == '.' \|\| c == '\'') {`
		715	`while(C1==' ' \|\| c=='\t')`
		716	`;`
		717	`if(c=='E' && C1=='N') {`
		718	`SKIP;`
		719	`if(msflag && dflg) {`
		720	`Bputc(&bout, 'x');`
		721	`Bputc(&bout, ' ');`
		722	`if(last) {`
		723	`Bputc(&bout, last);`
		724	`Bputc(&bout, '\n');`
		725	`}`
		726	`}`
		727	`return;`
		728	`}`
		729	`} else`
		730	`if(c == 'd') {`
		731	`if(C1=='e' && C1=='l')`
		732	`if(C1=='i' && C1=='m') {`
		733	`while(C1 == ' ')`
		734	`;`
		735	`if((c1=c)=='\n' \|\| (c2=C1)=='\n' \|\|`
		736	`(c1=='o' && c2=='f' && C1=='f')) {`
		737	`ldelim = NOCHAR;`
		738	`rdelim = NOCHAR;`
		739	`} else {`
		740	`ldelim = c1;`
		741	`rdelim = c2;`
		742	`}`
		743	`}`
		744	`dflg = 0;`
		745	`}`
		746	`if(c != '\n')`
		747	`while(C1 != '\n') {`
		748	`if(chars[c] == PUNCT)`
		749	`last = c;`
		750	`else`
		751	`if(c != ' ')`
		752	`last = 0;`
		753	`}`
		754	`}`
		755	`}`
		756
		757	`/*`
		758	`* skip over a complete backslash vconstruction`
		759	`*/`
		760	`void`
		761	`backsl(void)`
		762	`{`
		763	`int bdelim;`
		764
		765	`sw:`
		766	`switch(C1)`
		767	`{`
		768	`case '"':`
		769	`SKIP1;`
		770	`return;`
		771
		772	`case 's':`
		773	`if(C1 == '\\')`
		774	`backsl();`
		775	`else {`
		776	`while(C1>='0' && c<='9')`
		777	`;`
		778	`Bungetrune(infile);`
		779	`c = '0';`
		780	`}`
		781	`lp--;`
		782	`return;`
		783
		784	`case 'f':`
		785	`case 'n':`
		786	`case '*':`
		787	`if(C1 != '(')`
		788	`return;`
		789
		790	`case '(':`
		791	`if(msflag) {`
		792	`if(C == 'e') {`
		793	`if(C1 == 'm') {`
		794	`*lp = '-';`
		795	`return;`
		796	`}`
		797	`} else`
		798	`if(c != '\n')`
		799	`C1;`
		800	`return;`
		801	`}`
		802	`if(C1 != '\n')`
		803	`C1;`
		804	`return;`
		805
		806	`case '$':`
		807	`C1; /* discard argument number */`
		808	`return;`
		809
		810	`case 'b':`
		811	`case 'x':`
		812	`case 'v':`
		813	`case 'h':`
		814	`case 'w':`
		815	`case 'o':`
		816	`case 'l':`
		817	`case 'L':`
		818	`if((bdelim=C1) == '\n')`
		819	`return;`
		820	`while(C1!='\n' && c!=bdelim)`
		821	`if(c == '\\')`
		822	`backsl();`
		823	`return;`
		824
		825	`case '\\':`
		826	`if(inmacro)`
		827	`goto sw;`
		828	`default:`
		829	`return;`
		830	`}`
		831	`}`
		832
		833	`char*`
		834	`copys(char *s)`
		835	`{`
		836	`char t, t0;`
		837
		838	`if((t0 = t = malloc((strlen(s)+1))) == 0)`
		839	`fatal("Cannot allocate memory", (char*)0);`
		840	`while(t++ = s++)`
		841	`;`
		842	`return(t0);`
		843	`}`
		844
		845	`void`
		846	`sce(void)`
		847	`{`
		848	`int n = 1;`
		849
		850	`while (C != L'\n' && !(L'0' <= c && c <= L'9'))`
		851	`;`
		852	`if (c != L'\n') {`
		853	`for (n = c-L'0';'0' <= C && c <= L'9';)`
		854	`n = n*10 + c-L'0';`
		855	`}`
		856	`while(n) {`
		857	`if(C == '.') {`
		858	`if(C == 'c') {`
		859	`if(C == 'e') {`
		860	`while(C == ' ')`
		861	`;`
		862	`if(c == '0') {`
		863	`SKIP;`
		864	`break;`
		865	`} else`
		866	`SKIP;`
		867	`} else`
		868	`SKIP;`
		869	`} else`
		870	`if(c == 'P' \|\| C == 'P') {`
		871	`if(c != '\n')`
		872	`SKIP;`
		873	`break;`
		874	`} else`
		875	`if(c != '\n')`
		876	`SKIP;`
		877	`} else {`
		878	`SKIP;`
		879	`n--;`
		880	`}`
		881	`}`
		882	`}`
		883
		884	`void`
		885	`refer(int c1)`
		886	`{`
		887	`int c2;`
		888
		889	`if(c1 != '\n')`
		890	`SKIP;`
		891	`c2 = 0;`
		892	`for(;;) {`
		893	`if(C != '.')`
		894	`SKIP;`
		895	`else {`
		896	`if(C != ']')`
		897	`SKIP;`
		898	`else {`
		899	`while(C != '\n')`
		900	`c2 = c;`
		901	`if(charclass(c2) == PUNCT)`
		902	`Bprint(&bout, " %C",c2);`
		903	`return;`
		904	`}`
		905	`}`
		906	`}`
		907	`}`
		908
		909	`void`
		910	`inpic(void)`
		911	`{`
		912	`int c1;`
		913	`Rune *p1;`
		914
		915	`/* SKIP1;*/`
		916	`while(C1 != '\n')`
		917	`if(c == '<'){`
		918	`SKIP1;`
		919	`return;`
		920	`}`
		921	`p1 = line;`
		922	`c = '\n';`
		923	`for(;;) {`
		924	`c1 = c;`
		925	`if(C1 == '.' && c1 == '\n') {`
		926	`if(C1 != 'P' \|\| C1 != 'E') {`
		927	`if(c != '\n'){`
		928	`SKIP1;`
		929	`c = '\n';`
		930	`}`
		931	`continue;`
		932	`}`
		933	`SKIP1;`
		934	`return;`
		935	`} else`
		936	`if(c == '\"') {`
		937	`while(C1 != '\"') {`
		938	`if(c == '\\') {`
		939	`if(C1 == '\"')`
		940	`continue;`
		941	`Bungetrune(infile);`
		942	`backsl();`
		943	`} else`
		944	`*p1++ = c;`
		945	`}`
		946	`*p1++ = ' ';`
		947	`} else`
		948	`if(c == '\n' && p1 != line) {`
		949	`*p1 = '\0';`
		950	`if(wordflag)`
		951	`putwords();`
		952	`else`
		953	`Bprint(&bout, "%S\n\n", line);`
		954	`p1 = line;`
		955	`}`
		956	`}`
		957	`}`
		958
		959	`int`
		960	`charclass(int c)`
		961	`{`
		962	`if(c < MAX_ASCII)`
		963	`return chars[c];`
		964	`switch(c){`
		965	`case 0x2013: case 0x2014: /* en dash, em dash */`
		966	`return SPECIAL;`
		967	`}`
		968	`return EXTENDED;`
		969	`}`

Subversion Repositories planix.SVN

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