Return to npunct.l CVS log

Up to [Research Unix] / researchv10no / cmd / punct

Annotation of researchv10no/cmd/punct/npunct.l, revision 1.1

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

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.