Return to punct.l CVS log

Up to [Research Unix] / researchv8dc / cmd / wwb

Annotation of researchv8dc/cmd/wwb/punct.l, revision 1.1

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.