![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to punct.l CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10dc / cmd / wwb|
Return to punct.l CVS log | Up to [Research Unix] / researchv10dc / cmd / wwb |
1.1 root 1: %{
2:
3: #include <ctype.h>
4: #undef YYLMAX
5: #define YYLMAX 500
6: #undef input
7: #undef unput
8: #define OFF 0
9: int ineqn = 0;
10: int low = 0;
11: %}
12: int flag,c,n,i,bracket,slash,save;
13: flag=0;
14: bracket=0;
15: slash=0;
16: save=0;
17: %e 1500
18: %p 4000
19: %a 3000
20: %START ENDM
21: U [A-Z]
22: A [A-Za-z]
23: O [^A-Za-z]
24: L [a-z]
25: N [0-9i]
26: B [\ \n\t]
27: S [\ \t]
28: D [0-9.]
29: %%
30: (et{B}+al|a"."d|A"."M|a"."m|p"."m|b"."c|Ch|{B}ch|{B}ckts|Corp|dB|Dept|dept|Depts|depts)"." |
31: etc"..." |
32: (Dr|Drs|e"."g|Eq|eq|etc|Fig|Figs|fig|figs)"." |
33: ({B}ft|i"."e|{B}in|Inc|Jr|jr|lb|lbs|{B}mi|Mr|Mrs|Ms|No|{B}no|Nos|nos)"." |
34: (P"."{B}*M|Ph"."D|Ph"."d|PhD|Ref|ref|Refs|refs|sec|Sec|St|vs|v|yr)"." |
35: (Proc|Trans|Conf|Symp)"." |
36: (I|II|III|IV|V|VI|VII|VIII|IX|X)"." |
37: (mm|\(pp|pp|cf|Cf|hrs|{B}+pl|{B}+al|conj|fem|masc)"." ECHO;
38:
39:
40: \"\./{B} {
41: /*---------------PERIODS------------------------*/
42: /* ONE: periods go inside quotes before a blank */
43: printf(".\"");
44: BEGIN ENDM;
45: }
46: "''."/{B} {printf(".''"); BEGIN ENDM;}
47:
48: \".\"\. { /*leave examples as is "a". */
49: ECHO;
50: BEGIN ENDM;
51: }
52: "``"."''." {
53: ECHO;
54: BEGIN ENDM;
55: }
56: {D}+\" { /* leave 3". for 3 inches */
57: ECHO;
58: }
59: \""..."\"\. ECHO;
60: "``...''." ECHO;
61: \"{D}+\"\. { /* but fix "3.0". */
62: yytext[yyleng-2] = '\0';
63: printf("%s.\"",yytext);
64: BEGIN ENDM;
65: }
66: "``"{D}+"''." {
67: yytext[yyleng-3] = '\0';
68: printf("%s.''",yytext);
69: BEGIN ENDM;
70: }
71:
72:
73: \.\. {
74: /* TWO: two periods changed to one. */
75: printf(".");
76: BEGIN ENDM;
77: /* exceptions */
78: }
79: \.\.[.]+ ECHO;
80: ". . ." ECHO;
81: "..."\"\. ECHO;
82: "...''." ECHO;
83:
84: ^\..*\n {
85: /* THREE: to handle troff & preprocessors */
86: if(yytext[1] == 'T' && yytext[2] == 'S'){
87: ECHO;
88: skip('T','E',0);
89: }
90: else if(yytext[1] == 'P' && yytext[2] == 'S'){
91: ECHO;
92: skip('P','E',0);
93: }
94: else if(yytext[1] == 'D' && yytext[2] == 'S'){
95: ECHO;
96: skip('D', 'E', 0);
97: }
98: else if(yytext[1] == 'E' && yytext[2] == 'Q'){
99: ECHO;
100: skip('E','N',1);
101: }
102: else {
103: for (i=0;i<yyleng-1;i++) output(yytext[i]);
104: yyless(yyleng-1);
105: }
106: BEGIN 0;
107: }
108:
109:
110: {L}\.{B}+{L}[^).] { /* FOUR: Capitalize first word of sentence,
111: but not a. or a). **/
112: yytext[yyleng-2]=toupper(yytext[yyleng-2]);
113: ECHO;
114: }
115:
116:
117: {L}\.{B}*\n\.P.*\n{L}[^).] {/* Cap after .P */
118: yytext[yyleng-2]=toupper(yytext[yyleng-2]);
119: ECHO;
120: }
121:
122: <ENDM>{B}+\"{L} |
123: <ENDM>{B}+"``"{L} |
124: <ENDM>{B}+{L} { /* other sent caps */
125: yytext[yyleng-1] = toupper(yytext[yyleng-1]);
126: ECHO;
127: BEGIN 0;
128: }
129: <ENDM>. {
130: unput(yytext[0]);
131: BEGIN 0;
132: }
133:
134:
135: {B}+{L}\.{B}+ { /* Exceptions:
136: abbreviations at top not counted as sentences
137: (deleted periods in references code)
138: don't understand this rule */
139: ECHO; /* a. many is the time...*/
140: }
141:
142:
143: {L}\./{U}{L} { /* FIVE: Put space after sentence end if omitted */
144: ECHO; putchar(' ');}
145:
146: \.{A}\.{B}+ { /* Exception: the first 2 rules handle i.d. & i.i.d. */
147: ECHO;
148: }
149: \.{A}\. {
150: yyless(yyleng-1);
151: ECHO;
152: }
153: {L}\.{U}{U} ECHO; /*comm.SYS */
154:
155:
156:
157: \.{S}*\)/{B}+{U} { /* SIX: incomplete sentences in parens have . outside*/
158: if(--flag < 0)flag = 0;
159: if(flag == 0 && low == 1){
160: printf("\)\.");
161: }
162: else ECHO;
163: low = 0;
164: }
165: \){S}*\./{B}+{U} {
166: if(--flag < 0)flag = 0;
167: if(flag == 0 && low == 2)
168: printf(".) ");
169: else ECHO;
170: low = 0;
171: }
172: \.{S}*\) {
173: if(--flag < 0)flag = 0;
174: if(flag == 0 && low != 2)
175: printf("). ");
176: else ECHO;
177: low = 0;
178: }
179:
180: et\.{B}*al { /* SEVEN: other */
181: printf("et al.");
182: if((c=input()) != '.')unput(c);
183: }
184: \?\"\. { /* ... transimission?". */
185: ECHO;
186: BEGIN ENDM;
187: }
188: \?"''." {
189: ECHO;
190: BEGIN ENDM;
191: }
192:
193:
194:
195: \"\, { /*------------------------------COMMAS----------------------*/
196: /* ONE: commas go inside double quotes */
197: /* leave alone if inside (), may be code */
198: if(flag == 0)printf(",\"");
199: else ECHO;
200: }
201: "''," {
202: if(flag == 0)printf(",''");
203: else ECHO;
204: }
205:
206:
207: \".\""," { /* Exception */
208: ECHO; /*leave examples as is "a", */
209: }
210: "``"."''," ECHO;
211:
212:
213: \,{B}*\( {/* TWO: no commas before ( */
214: if(flag == 0){
215: printf(" ");
216: yyless(1);
217: save = 1;
218: }
219: else {
220: yyless(1);
221: ECHO;
222: }
223: }
224:
225:
226: \,{B}*\({N}+{A}*\) { /* Exceptions */
227: ECHO; /* , (2) or , (34b) */
228: }
229: \,{B}*\({A}\) ECHO; /* , (b) */
230: \)\,{B}*\( ECHO; /* (1), (2),..*/
231: i\.e\.\, |
232: e\.g\.\, ECHO;
233:
234:
235:
236: \,\, { /* THREE: No ,, except inside (), [], // */
237: if (flag!=0|bracket==1|slash==1) ECHO;
238: else printf(",");
239: }
240:
241:
242:
243: {L}\,/{L} { /* FOUR: put blank after comma */
244: /* except in (), [], // (x,y,,a,3) */
245: if(flag!=0|slash==1|bracket==1) ECHO;
246: else {putchar(yytext[0]); printf(", ");}
247: }
248: {L}\,/{U}{L} {if(flag!=0|slash==1|bracket==1) ECHO;
249: else {putchar(yytext[0]); printf(", ");}
250: }
251:
252: \,\.\.\.\, { /* Exception: math */
253: ECHO;
254: }
255: i\,j |
256: x\,y |
257: p\,q ECHO;
258:
259:
260:
261: ;\" { /*-----------------COLONS & SEMI-COLONS--------------------*/
262: /* ONE: : and ; go outside of quotes */
263: printf("\";");
264: }
265: ;"''" printf("'';");
266: :\" {
267: if(flag == 0)printf("\":");
268: else ECHO;
269: }
270: :"''" printf("'':");
271:
272:
273: \"[;:]\" { /* Exception: when : or ; is quoted, i.e. ";" */
274: ECHO;
275: }
276: "``"[;:]"''" ECHO;
277:
278:
279: ;; { /* TWO: no double ;; */
280: yyless(1);
281: }
282: :: { /* no double :: */
283: yyless(1);
284: }
285:
286: \(;;\) { /* Exception: C-code for(;;) */
287: ECHO;
288: }
289:
290: ;{B}*\( { /* THREE: no semicolons before ( */
291: if(flag == 0){
292: printf(" ");
293: yyless(1);
294: save = 2;
295: }
296: else {
297: yyless(1);
298: ECHO;
299: }
300: }
301:
302:
303: ;{B}*\({N}+\) { /* Exceptions */
304: ECHO; /* ; (2) */
305: }
306: ;{B}*\({A}\) ECHO; /* ; (b) */
307: \);{B}*\( ECHO; /* (1); (2);..*/
308:
309:
310: [;:]/{A} { /* FOUR: put space after ; & : */
311: if(flag == 0){
312: putchar(yytext[0]); putchar(' ');
313: }
314: else ECHO;
315: }
316:
317:
318:
319: \?\, { /*----------------------QUESTION MARKS-----------------------*/
320: /* ONE: ?, becomes ? */
321: printf("?");
322: }
323: \?\"\, printf("?\"");
324: \?"''," printf("?''");
325:
326:
327: \?\? { /* TWO: ?? becomes ? */
328: yyless(1);
329: }
330:
331:
332: {L}\?{B}+{L} { /* THREE: capitalize new sentence after ? */
333: yytext[yyleng-1]=toupper(yytext[yyleng-1]);
334: ECHO;
335: }
336:
337:
338: {L}\?/{U}{L} { /* FOUR: put space after ? between sentences */
339: ECHO; putchar(' ');}
340:
341:
342:
343: \({B}*/{L} { /*----------------------PARENTHESES-----------------------*/
344: /* NOTE: The value of flag tells if you are inside a pair
345: of parentheses, low is set if first word started in lower case
346: at the first level of parens
347: flag=1 and low = 1 if ([a-z]
348: flag = 1 and low = 0 if ([^a-z]
349: flag = 0 if )
350: bracket & slash toggle between 0 & 1 on \[\] \& \/
351: ONE: for left parens */
352: if(flag == 0) low = 1;
353: flag++;
354: ECHO;
355: }
356: \({B}*/{U} {
357: if(flag == 0)low = 2;
358: flag++;
359: ECHO;
360: }
361: \( {
362: if(flag == 0)low = 0;
363: flag++;
364: ECHO;
365: }
366: \\\(.. ECHO; /* troff characters */
367: \[ {bracket=1; ECHO;}
368: \\ {if(slash==0) slash=1;
369: else slash=0;
370: ECHO;
371: /* TWO: next for right parens */
372: }
373:
374:
375: \?{B}*\) |
376: {B}+{A}\.\) | /* ...Jones, A.) */
377: \.{A}\.\) | /* (i.i.d.) */
378: \) {
379: if(--flag < 0)flag = 0;
380: ECHO;
381: if(save == 1)putchar(',');
382: if(save==2) putchar(';');
383: save=0;
384: }
385:
386: \)+[,;] {
387: if(--flag < 0)flag = 0;
388: ECHO;
389: save = 0;
390: }
391:
392: \] {bracket=0; ECHO;}
393:
394: \. { /* all other .'s */
395: ECHO;
396: BEGIN ENDM;
397: }
398:
399: %%
400: int rdelim = 0;
401: int ldelim = 0;
402: char del[] = "elim";
403: skip(c1,c2,eqn)
404: char c1,c2;
405: {
406: int c,first;
407: char *s;
408: first = 1;
409: cont:
410: while((c=input()) != '.'){
411: ck:
412: if(c == 0)return;
413: if(c == '\n')first = 1;
414: else first = 0;
415: putchar(c);
416: if(eqn && c == 'd'){
417: for(s=del;*s != '\0';s++){
418: if((c=input()) != *s)goto ck;
419: putchar(c);
420: }
421: while((c=input()) == ' ')putchar(c);
422: if(c == '\n' || c == 'o'){
423: ldelim = rdelim = OFF;
424: first = 1;
425: putchar(c);
426: if(c != '\n')
427: while((c=input()) != '\n')putchar(c);
428: continue;
429: }
430: putchar(c);
431: ldelim = c;
432: rdelim = getchar();
433: putchar(c);
434: continue;
435: }
436: }
437: if(first != 1){
438: putchar('.');
439: goto cont;
440: }
441: if((c=input()) != c1){
442: if(c == 0)return;
443: putchar('.'); putchar(c);
444: if(c == '\n')first = 1;
445: else first = 0;
446: goto cont;
447: }
448: if((c=input()) != c2){
449: if(c == 0)return;
450: if(c == '\n')first = 1;
451: else first = 0;
452: printf(".%c%c",c1,c);
453: goto cont;
454: }
455: printf(".%c%c",c1,c2);
456: while((c=input()) != '\n'){
457: if(c == 0)return;
458: putchar(c);
459: }
460: unput('\n');
461: }
462: char buf[YYLMAX];
463: char *ptr = buf;
464: input(){
465: int cc;
466: if(ptr != buf){
467: cc = *ptr--;
468: if(ldelim == 0)return(cc);
469: if(cc != ldelim && ineqn == 0)return(cc);
470: if(ineqn == 0){
471: ineqn = 1;
472: return(ldelim);
473: }
474: putchar(cc);
475: if(cc == rdelim)goto gotit;
476: while(ptr != buf){
477: cc = *ptr--;
478: putchar(cc);
479: if(cc == rdelim){
480: gotit:
481: ineqn = 0;
482: if(ptr != buf)return(*ptr--);
483: else {
484: cc=getchar();
485: return(cc==EOF?0:cc);
486: }
487: }
488: }
489: goto more2;
490: }
491: if(ldelim == 0){
492: cc=getchar();
493: return(cc==EOF?0:cc);
494: }
495: more:
496: if((cc=getchar()) != ldelim && ineqn == 0){
497: return(cc==EOF?0:cc);
498: }
499: if(ineqn == 0){
500: ineqn = 1;
501: return(ldelim);
502: }
503: putchar(cc);
504: if(cc == rdelim){
505: ineqn = 0;
506: goto more;
507: }
508: more2:
509: while((cc=getchar()) != rdelim)
510: if(cc == EOF){ineqn = 0; return(0);}
511: else putchar(cc);
512: putchar(cc);
513: ineqn = 0;
514: goto more;
515: }
516: unput(cc)
517: char cc;
518: {
519: *(++ptr) = cc;
520: if(ineqn && cc == ldelim)ineqn = 0;
521: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.