Return to pscan.c CVS log

Up to [CSRG BSD Unix] / 40BSD / cmd / diction

Annotation of 40BSD/cmd/diction/pscan.c, revision 1.1

1.1     ! root        1: #include "names.h"
        !             2: #include "conp.h"
        !             3: char lastc,nextc;
        !             4: int savsub;
        !             5: scan(si,ce,command)    /*scan a phrase */
        !             6: int si; 
        !             7: char ce;
        !             8: {
        !             9:        char c;
        !            10:        i=si;
        !            11:        if(command == 1)subty = PLURAL;
        !            12:        else subty = 0;
        !            13:        if(sent[i].cc==ADJ_ADV && sent[i+1].cc != NOUN && sent[i+1].cc != UNK && sent[i+1].cc != ADJ)
        !            14:                sent[i++].cc = ADV;
        !            15:        done=0;
        !            16:        verb = 0;
        !            17:        verb=getv(i,ce);        /*get verb if obvious*/
        !            18:        if(command == 0)j=getnoun(i,ce);                /*get subject*/
        !            19:        else j = si;
        !            20:        if(i != j || ((i==j) && sent[i].cc == NOUN)){
        !            21:                i = j+1;
        !            22:        }
        !            23:        for(;((c=sent[i].cc) != ce) && (c != END)  && (c != '\0');i++){
        !            24:                nextc=sent[i+1].cc;
        !            25:                if(i>0){
        !            26:                        lastc=sent[i-1].cc;
        !            27:                        if(lastc==BE)be=1;
        !            28:                        else{
        !            29:                                if(lastc != ADV)be=0;
        !            30:                        }
        !            31:                }
        !            32:                else lastc=0;
        !            33:                if(verb==1)question=0;
        !            34:                switch(c){
        !            35:                case '"':
        !            36:                        if(nextc==ED){
        !            37:                                verb=1;
        !            38:                                sent[++i].cc=VERB;
        !            39:                                subty=SING;
        !            40:                                continue;
        !            41:                        }
        !            42:                        subty=0;
        !            43:                        verb=getv(++i,ce);
        !            44:                        i=getnoun(i,ce);
        !            45:                        continue;
        !            46:                case ART:
        !            47:                case ADJ:
        !            48:                case POS:       
        !            49:                case ING:
        !            50:                        aflg=1;
        !            51:                        i=getnoun(i,ce);
        !            52:                        aflg=0;
        !            53:                        continue;
        !            54:                case PREP:      
        !            55:                        if(nextc == ce){
        !            56:                                sent[i].cc=ADV;
        !            57:                                goto sdone;
        !            58:                        }
        !            59:                        prep=1;
        !            60:                        i=getnoun(++i,ce);
        !            61:                        prep=0;
        !            62:                        continue;
        !            63:                case VERB_ADJ:
        !            64:                        if(verb==0){
        !            65:                                sent[i].cc=VERB;
        !            66:                                verb=1;
        !            67:                                continue;
        !            68:                        }
        !            69:                case NOUN_ADJ:
        !            70:                        if(be==1){
        !            71:                                sent[i].cc=ADJ;
        !            72:                                continue;
        !            73:                        }
        !            74:                case PRONP_ADJ:
        !            75:                case PRONS_ADJ:
        !            76:                        i=getnoun(i,ce);
        !            77:                        continue;
        !            78:                case NOUN_ADV:
        !            79:                        if(verb == 1 && iverb == i+1){
        !            80:                                sent[i].cc = NOUN;
        !            81:                        }
        !            82:                        else {
        !            83:                                sent[i].cc = ADV;
        !            84:                        }
        !            85:                        continue;
        !            86:                case ADJ_ADV:
        !            87:                        if(be == 1){
        !            88:                                if(nextc == ADJ || nextc == NOUN_ADJ || nextc == ADJ_ADV || nextc == UNK){
        !            89:                                        sent[i].cc = ADV;
        !            90:                                        continue;
        !            91:                                }
        !            92:                                if(nextc == ',' && (sent[i+2].cc == ADJ_ADV || sent[i+2].cc == ADV)){
        !            93:                                        sent[i++].cc = ADV;
        !            94:                                        sent[++i].cc = ADV;
        !            95:                                        comma--;
        !            96:                                        continue;
        !            97:                                }
        !            98:                                sent[i].cc = ADJ;
        !            99:                                continue;
        !           100:                        }
        !           101:                        if(lastc == NOUN && (nextc == ',' || nextc == END)){
        !           102:                                sent[i].cc=ADJ;
        !           103:                                continue;
        !           104:                        }
        !           105:                        if(nextc!= UNK && nextc != NOUN_VERB && nextc != NOUN && nextc != NV_PL){
        !           106:                                sent[i].cc=ADV;
        !           107:                                continue;
        !           108:                        }
        !           109:                        sent[i].cc=ADJ;
        !           110:                        continue;
        !           111:                case WHO:
        !           112:                        i=who(i,ce);
        !           113:                        continue;
        !           114:                case PRONP:
        !           115:                        subty=PLURAL;
        !           116:                        continue;
        !           117:                case NOUN:
        !           118:                        if(nextc==NOUN){
        !           119:                                sent[i].cc=ADJ;
        !           120:                                continue;
        !           121:                        }
        !           122:                case PRONS:
        !           123:                        subty=SING;
        !           124:                        continue;
        !           125:                case CONJ:
        !           126:                        if(nextc==UNK || nextc == NOUN_VERB || nextc == NV_PL){
        !           127:                                if(lastc == ADJ)sent[++i].cc = ADJ;
        !           128:                                else sent[++i].cc = VERB;
        !           129:                        }
        !           130:                        if(nextc == ED){
        !           131:                                sent[++i].cc = VERB;
        !           132:                        }
        !           133:                        continue;
        !           134:                case AUXP:
        !           135:                case AUXS:
        !           136:                case BES:
        !           137:                case BEP:
        !           138:                case AUXV:
        !           139:                case AUX:
        !           140:                case HAS:
        !           141:                case HAVE:
        !           142:                case HAD:
        !           143:                        verb=getv(i,ce);
        !           144:                        continue;
        !           145:                case ADV:
        !           146:                case AUXX:
        !           147:                case VERB:
        !           148:                case BE:
        !           149:                case INTER:
        !           150:                        continue;
        !           151:                case THAT:
        !           152:                        if(nextc==SUBCONJ){
        !           153:                                sent[i].cc=PRONP;
        !           154:                                goto subc;
        !           155:                        }
        !           156:                        verb=getv(i+1,ce);
        !           157:                        j = i+1;
        !           158:                        while(sent[j].cc == ADV || sent[j].cc == ADJ_ADV){
        !           159:                                j++;
        !           160:                        }
        !           161:                        if((verb==1 && iverb== j) || sent[j].cc==ED || sent[j].cc == VERB_ADJ){
        !           162:                                sent[i].cc=PRONP;
        !           163:                                while(i+1 < j)sent[++i].cc = ADV;
        !           164:                        }
        !           165:                        else if(verb==0 && nextc==NV_PL && ((lastc==NOUN
        !           166:                                && (sent[i-1].ic==UNK || sent[i-1].ic==NOUN_VERB|| sent[i-1].ic==NOUN))|| lastc == ',')){
        !           167:                                sent[i].cc=PRONP;
        !           168:                                subty=SING;
        !           169:                        }
        !           170:                        else if(verb==0 && (nextc==UNK || nextc==NOUN_VERB) && (lastc==NOUN
        !           171:                                && sent[i-1].ic==NV_PL)){
        !           172:                                subty=PLURAL;
        !           173:                                sent[i].cc=PRONP;
        !           174:                        }
        !           175:                        else {
        !           176:                                if(i == 0)sent[i].cc=ADJ;
        !           177:                                else sent[i].cc=SUBCONJ;
        !           178:                                j=i;
        !           179:                                subty=0;
        !           180:                                i=getnoun(i+1,ce);
        !           181:                                if(done)sent[j].cc=ADJ;
        !           182:                        }
        !           183:                        continue;
        !           184:                case ',':
        !           185:                        if(nextc != CONJ){      /*parenthetical*/
        !           186:                                continue;
        !           187:                        }
        !           188:                        i++;
        !           189:                        comma--;
        !           190:                        if(sent[i+1].cc == ED){
        !           191:                                sent[++i].cc = VERB;
        !           192:                                continue;
        !           193:                        }
        !           194:                        if(command == 1){
        !           195:                                verb = getv(++i,ce);
        !           196:                                continue;
        !           197:                        }
        !           198:                case SUBCONJ:   
        !           199: subc:
        !           200:                        if(nextc==END||(lastc==',' && nextc==',')){
        !           201:                                sent[i].cc=ADV;
        !           202:                                continue;
        !           203:                        }
        !           204:                        subty=0;
        !           205:                        ce=',';
        !           206:                        verb=getv(++i,ce);
        !           207:                        i=getnoun(i,ce);
        !           208:                        continue;
        !           209:                case PREP_ADV:
        !           210:                        if(sent[i+2].cc==PREP_ADV &&(sent[i+1].cc != NOUN && sent[i+1].cc != NOUN_VERB
        !           211:                                && sent[i+1].cc != NV_PL)){
        !           212:                                sent[i].cc=ADV;
        !           213:                                sent[i+2].cc=CONJ;
        !           214:                                continue;
        !           215:                        }
        !           216:                        sav=i++;
        !           217:                        savsub = subty;
        !           218:                        pverb=getv(i,ce);
        !           219:                        if((pverb==1 && iverb == i) || sent[i].cc== ED){
        !           220:                                sent[sav].cc=PRONP;
        !           221:                                sent[i].cc=VERB;
        !           222:                                continue;
        !           223:                        }
        !           224:                        i=getnoun(i,ce);
        !           225:                        if(done==1){
        !           226:                                sent[sav].cc=ADV;
        !           227:                                goto sdone;
        !           228:                        }
        !           229:                        if(pverb==1 && iverb == i+1){
        !           230:                                sent[sav].cc=SUBCONJ;
        !           231:                                ce=',';
        !           232:                                continue;
        !           233:                        }
        !           234:                        switch(sent[i+1].cc){
        !           235:                        case UNK:
        !           236:                        case NV_PL:
        !           237:                        case NOUN_VERB:
        !           238:                        case ED:
        !           239:                                sent[sav].cc=SUBCONJ;
        !           240:                                verb=0;
        !           241:                                ce=',';
        !           242:                                continue;
        !           243:                        default:
        !           244:                                sent[sav].cc=PREP;
        !           245:                                subty = savsub;
        !           246:                                continue;
        !           247:                        }
        !           248:                case TO:        
        !           249:                        sent[i++].cc=VERB;
        !           250:                        switch(nextc){
        !           251:                        case UNK:
        !           252:                        case AUXS:
        !           253:                        case VERB_ADJ:
        !           254:                        case NOUN_VERB: 
        !           255:                        case ED:
        !           256:                        case VERB:
        !           257:                                sent[i].cc=VERB;
        !           258:                                continue;
        !           259:                        case HAVE:
        !           260:                                sent[i].cc = VERB;
        !           261:                                if(sent[i+1].cc == ED){
        !           262:                                        sent[++i].cc = VERB;
        !           263:                                        continue;
        !           264:                                }
        !           265:                                if(sent[i+1].cc != BE)continue;
        !           266:                                i++;
        !           267:                        case BE:        
        !           268:                                sent[i].cc=VERB;
        !           269:                                if(sent[i+1].cc == ED || sent[i+1].cc == ING){
        !           270:                                        sent[++i].cc = VERB;
        !           271:                                }
        !           272:                                else if(sent[i+1].cc == UNK){
        !           273:                                        sent[++i].cc = ADJ;
        !           274:                                }
        !           275:                                continue;
        !           276:                        default:        
        !           277:                                sent[i-1].cc = PREP;
        !           278:                                prep=1;
        !           279:                                i=getnoun(i,ce);
        !           280:                                prep=0;
        !           281:                                continue;
        !           282:                        }
        !           283:                case NV_PL: 
        !           284:                        if(subty==0){
        !           285:                                i=getnoun(i,ce);
        !           286:                                subty=PLURAL;
        !           287:                        }
        !           288:                        else if(verb== 0){      /*need verb*/
        !           289:                                sent[i].cc=VERB;
        !           290:                                verb=1;
        !           291:                        }
        !           292:                        else{
        !           293:                                i=getnoun(i,ce);
        !           294:                        }
        !           295:                        continue;
        !           296:                case UNK:       
        !           297:                case NOUN_VERB:
        !           298:                        if(verb==1){
        !           299:                                if(be==1 && nextc != WHO){
        !           300:                                        sent[i].cc=ADJ;
        !           301:                                        continue;
        !           302:                                }
        !           303:                                i=getnoun(i,ce);
        !           304:                        }
        !           305:                        else if(nextc==NV_PL &&( sent[i+2].cc==NOUN_VERB || sent[i+2].cc==NOUN||
        !           306:                                sent[i+2].cc==UNK || sent[i+2].cc==NV_PL)){
        !           307:                                sent[i].cc=NOUN;
        !           308:                                if(sent[i-1].cc == NOUN){
        !           309:                                        sent[i-1].cc = ADJ;
        !           310:                                }
        !           311:                                subty=SING;
        !           312:                                continue;
        !           313:                        }
        !           314:                        else if(subty==0){
        !           315:                                i=getnoun(i,ce);
        !           316:                                continue;
        !           317:                        }
        !           318:                        else {          /* desparation */
        !           319:                                sent[i].cc=VERB;
        !           320:                                verb=1;
        !           321:                        }
        !           322:                        continue;
        !           323:                case ED:
        !           324:                        if(verb == 0){
        !           325:                                sent[i].cc=VERB;
        !           326:                                verb=1;
        !           327:                        }
        !           328:                        else if(sent[i-1].cc == BE){
        !           329:                                sent[i].cc = VERB;
        !           330:                        }
        !           331:                        else{
        !           332:                                i=getnoun(i,ce);
        !           333:                        }
        !           334:                        continue;
        !           335:                default:        printf("got a %c on %s\n",sent[i].cc,sent[i].sp);
        !           336:                }
        !           337:        }
        !           338: sdone:
        !           339:        if(sent[i].cc==END && sent[i].ic != ';')return(-1);
        !           340:        else {
        !           341:                if(sent[i].ic == ';')sent[i].cc=';';
        !           342:                else comma--;
        !           343:                return(i);
        !           344:        }
        !           345: }
        !           346: getv(si,ce)
        !           347: int si; 
        !           348: char ce;
        !           349: {
        !           350:        int conj;
        !           351:        char c;
        !           352:        int ik;
        !           353:        must=0;
        !           354:        bflg=0;
        !           355:        hflg=0;
        !           356:        verbty=0;
        !           357:        for(j=si;((c=sent[j].cc) != ce) && (c != END); j++){
        !           358:                iverb=j;
        !           359:                switch(c){
        !           360:                case ED:
        !           361:                        continue;
        !           362:                case HAS:
        !           363:                        hflg=1;
        !           364:                        verbty=SING;
        !           365:                        sent[j].cc=AUXX;
        !           366:                        goto next;
        !           367:                case HAVE:
        !           368:                        if(sent[j-1].cc==TO){
        !           369:                                continue;
        !           370:                        }
        !           371:                case HAD:
        !           372:                        hflg=1;
        !           373:                        verbty=PLURAL;
        !           374:                        sent[j].cc=AUXX;
        !           375:                        goto next;
        !           376:                case BE:
        !           377:                        if(sent[j].ic != BE){
        !           378:                                return(1);
        !           379:                        }
        !           380:                        continue;
        !           381:                case VERB:      
        !           382:                        if(sent[j-1].cc==TO){
        !           383:                                continue;
        !           384:                        }
        !           385:                        return(1);
        !           386:                case AUXX:
        !           387:                        return(1);
        !           388:                case AUXP:      
        !           389:                        must=1;
        !           390:                        verbty=PLURAL;
        !           391:                        sent[j].cc=AUXX;
        !           392:                        goto next;
        !           393:                case AUXS:      
        !           394:                        if(sent[j-1].cc==TO){
        !           395:                                continue;
        !           396:                        }
        !           397:                        verbty=SING;
        !           398:                        sent[j].cc=AUXX;
        !           399:                        goto next;
        !           400:                case AUX:
        !           401:                case AUXV:
        !           402:                        must=1;
        !           403:                        sent[j].cc=AUXX;
        !           404: next:  
        !           405:                        if(sent[j-1].cc == CONJ && verb == 0)conj = 0;
        !           406:                        else conj = 1;
        !           407:                        if(question==1){
        !           408:                                j=getnoun(j+1,ce);
        !           409:                                question=0;
        !           410:                        }
        !           411:                        getv2(ce);
        !           412:                        if(sent[j].cc == AUXX){
        !           413:                                sent[j].cc = VERB;
        !           414:                        }
        !           415:                        if((sent[j].cc!=VERB && sent[j].cc!=BE) && sent[iverb].cc==AUXX){
        !           416:                                sent[iverb].cc=VERB;
        !           417:                                for(ik=iverb+1;ik<=j;ik++)sent[ik].cc=sent[ik].ic;
        !           418:                        }
        !           419:                        return(conj);
        !           420:                case BES:       
        !           421:                        verbty=SING;
        !           422:                        bflg=1;
        !           423:                        sent[j].cc=BE;
        !           424:                        goto next;
        !           425:                case BEP:       
        !           426:                        verbty=PLURAL;
        !           427:                        bflg=1;
        !           428:                        sent[j].cc=BE;
        !           429:                        goto next;
        !           430:                case SUBCONJ:
        !           431:                        if(sent[j-1].cc== ',' && sent[j+1].cc == ','){
        !           432:                                continue;
        !           433:                        }
        !           434:                case THAT:
        !           435:                case WHO:
        !           436:                        goto vdone;
        !           437:                case ',':       if(comma==1 && sent[j+1].cc==CONJ){
        !           438:                                        goto vdone;
        !           439:                                }
        !           440:                }
        !           441:        }
        !           442: vdone:
        !           443:        return(0);
        !           444: }
        !           445: getv2(ce)
        !           446: char ce;
        !           447: {
        !           448:        int vflg;
        !           449:        char c;
        !           450:        vflg=0;
        !           451:        while(((c=sent[++j].cc) != ce) && (c != END)){
        !           452:                switch(c){
        !           453:                case NOUN_ADV:
        !           454:                case ADJ_ADV:   
        !           455:                        if(bflg == 0 || sent[j+1].cc == ED || sent[j+1].cc == ING){
        !           456:                                sent[j].cc = ADV;
        !           457:                        }
        !           458:                        else{
        !           459:                                j -= 1;
        !           460:                                return;
        !           461:                        }
        !           462:                case ADV:       
        !           463:                        continue;
        !           464:                case SUBCONJ:
        !           465:                        if(sent[j+1].cc == ED || sent[j+1].cc == ING || sent[j+1].cc == ADV ||
        !           466:                                sent[j+1].cc == ADJ_ADV)sent[j].cc = ADV;
        !           467:                        else return;
        !           468:                        continue;
        !           469:                case VERB:      
        !           470:                        return;
        !           471:                case VERB_ADJ:
        !           472:                case ED:        
        !           473:                        sent[j].cc=VERB;
        !           474:                        return;
        !           475:                case BE:        
        !           476:                        must=0;
        !           477:                        bflg=1;
        !           478:                        continue;
        !           479:                case ING:       
        !           480:                        if(bflg == 1){
        !           481:                                sent[j].cc = VERB;
        !           482:                        }
        !           483:                        else {
        !           484:                                j -= 1;
        !           485:                        }
        !           486:                        return;
        !           487:                case NOUN_VERB:
        !           488:                case UNK:       
        !           489:                        if(bflg==1 || vflg==1 || hflg==1){
        !           490:                                j -= 1;
        !           491:                                return;
        !           492:                        }
        !           493:                        sent[j].cc=VERB;
        !           494:                        return;
        !           495:                case PRONP_ADJ:
        !           496:                case PRONS_ADJ: 
        !           497:                        c=sent[j+1].cc;
        !           498:                        if(c==ED||c==ING||c==BE||must==1){
        !           499:                                sent[j].cc = ADV;
        !           500:                        }
        !           501:                        else{
        !           502:                                j -= 1;
        !           503:                                return;
        !           504:                        }
        !           505:                        continue;
        !           506:                case AUXV:
        !           507:                case AUX:
        !           508:                case AUXP:
        !           509:                case AUXS:
        !           510:                case HAD:
        !           511:                case HAVE:
        !           512:                case HAS:
        !           513:                        must=0;
        !           514:                        vflg=1;
        !           515:                        sent[j].cc=AUXX;
        !           516:                        continue;
        !           517:                default:
        !           518:                        j -= 1;
        !           519:                        return;
        !           520:                }
        !           521:        }
        !           522:        j -= 1;
        !           523: }
        !           524: getnoun(k,ce)
        !           525: int k,ce;
        !           526: {
        !           527:        char c;
        !           528:        int st,t,nextst;
        !           529:        int rep;
        !           530:        int t1,tt;
        !           531:        st=k;
        !           532:        rep=0;
        !           533: b:     
        !           534:        nextst=sent[st+1].cc;
        !           535:        switch(sent[st].cc){
        !           536:        case END:
        !           537:                done=1;
        !           538:                break;
        !           539:        case ',':
        !           540:                if(ce==','){
        !           541:                        done=1;
        !           542:                        break;
        !           543:                }
        !           544:                else {
        !           545:                        goto getdef;
        !           546:                }
        !           547:        case '"':
        !           548:                if(aflg == 1){
        !           549:                        st++;
        !           550:                        goto b;
        !           551:                }
        !           552:                break;
        !           553:        case NOUN:      
        !           554:                switch(nextst){
        !           555:                case UNK:
        !           556:                case NOUN_VERB:
        !           557:                        if(verb==1){
        !           558:                                goto nn;
        !           559:                        }
        !           560:                        if(subty != PLURAL){
        !           561:                                goto nn;
        !           562:                        }
        !           563:                        break;
        !           564:                case NV_PL:
        !           565:                        if(verb==1){
        !           566:                                goto nn;
        !           567:                        }
        !           568:                        if(subty == PLURAL){
        !           569:                                goto nn;
        !           570:                        }
        !           571:                        break;
        !           572:                case NOUN_ADJ:
        !           573:                case POS:
        !           574:                case NOUN:
        !           575: nn:
        !           576:                        sent[st].cc=ADJ;
        !           577:                        goto b;
        !           578:                }
        !           579:                if(prep==0)subty=SING;
        !           580:                break;
        !           581:        case ADV:
        !           582:                st++;
        !           583:                goto b;
        !           584:        case WHO:
        !           585:                st=who(st,ce);
        !           586:                st++;
        !           587:                goto b;
        !           588:        case ADJ_ADV:
        !           589:        case VERB_ADJ:
        !           590:        case ED:
        !           591:                sent[st++].cc=ADJ;
        !           592:                goto b;
        !           593:        case ING:
        !           594:                if(nextst==UNK || nextst==NOUN_VERB || nextst==NOUN || nextst==NV_PL){
        !           595:                        sent[st++].cc=ADJ;
        !           596:                        goto b;
        !           597:                }
        !           598:                sent[st].cc=NOUN;
        !           599:                if(prep==0)subty=SING;
        !           600:                break;
        !           601:        case ART:
        !           602:        case POS:
        !           603:                if(st != k){
        !           604:                        goto getdef;
        !           605:                }
        !           606:        case ADJ:
        !           607:                st++;
        !           608:                goto b;
        !           609:        case PRONP:     
        !           610:                if(prep==0)subty=PLURAL;
        !           611: 
        !           612:                break;
        !           613:        case PRONS:     
        !           614:                if(prep==0)subty=SING;
        !           615:                break;
        !           616:        case NOUN_VERB: 
        !           617:                if(nextst==NOUN||(verb==1 && (nextst== NV_PL|| nextst==NOUN_VERB) )){
        !           618:                        sent[st].cc=ADJ;
        !           619:                        goto b;
        !           620:                }
        !           621:        case NV_PL:
        !           622:                sent[st].cc=NOUN;
        !           623:                if(prep==0){
        !           624:                        if(sent[st].ic==NV_PL)subty=PLURAL;
        !           625:                        else subty=SING;
        !           626:                }
        !           627:                if(sent[st-1].cc == NOUN && sent[st-1].ic == NOUN){
        !           628:                        sent[st-1].cc = ADJ;
        !           629:                }
        !           630:                break;
        !           631:        case PRONP_ADJ: 
        !           632:                switch(nextst){
        !           633:                case NOUN_ADJ:
        !           634:                case NV_PL:     
        !           635:                case ADJ_ADV:
        !           636:                case PRONS_ADJ: 
        !           637:                case ADJ:
        !           638:                case ING:
        !           639:                        sent[st++].cc=ADJ;
        !           640:                        goto b;
        !           641:                case NOUN_VERB:
        !           642:                case UNK:       
        !           643:                case ED:
        !           644:                        if(verb == 0){
        !           645:                                goto def;
        !           646:                        }
        !           647:                        else{
        !           648:                                sent[st++].cc=ADJ;
        !           649:                                goto b;
        !           650:                        }
        !           651:                case NOUN:      
        !           652:                        sent[st++].cc=ADJ;
        !           653:                        if(prep==0)subty=SING;
        !           654:                        break;
        !           655:                case SUBCONJ:   sent[st++].cc=PRONP;    /* more than .. */
        !           656:                        sent[st++].cc=CONJ;
        !           657:                        if(verb==0)verb=getv(st,ce);
        !           658:                        goto b;
        !           659:                case '"':
        !           660:                        sent[st++].cc = ADJ;
        !           661:                        st++;
        !           662:                        goto b;
        !           663:                default:        
        !           664: def:
        !           665:                        sent[st].cc=PRONP;
        !           666:                        if(prep==0)subty=PLURAL;
        !           667: 
        !           668:                        break;
        !           669:                }
        !           670:                break;
        !           671:        case PRONS_ADJ: 
        !           672:                if(aflg == 1 && nextst != END && nextst != ART){
        !           673:                        sent[st++].cc=ADJ;
        !           674:                        goto b;
        !           675:                }
        !           676:                switch(nextst){
        !           677:                case '"':
        !           678:                        sent[st++].cc = ADJ;
        !           679:                        st++;
        !           680:                        goto b;
        !           681:                case ING:
        !           682:                case UNK:       
        !           683:                case NOUN_VERB:
        !           684:                case NOUN_ADJ:
        !           685:                case ADJ_ADV:
        !           686:                case ADJ:
        !           687:                        sent[st++].cc=ADJ;
        !           688:                        goto b;
        !           689:                case NOUN:      
        !           690:                        sent[st++].cc=ADJ;
        !           691:                        if(prep==0)subty=SING;
        !           692:                        break;
        !           693:                case PRONS_ADJ: 
        !           694:                        sent[st++].cc=ADJ;
        !           695:                        sent[st].cc=PRONP;
        !           696:                        if(prep==0)subty=SING;
        !           697:                        break;
        !           698:                case NV_PL:     
        !           699:                        if(verb==1){
        !           700:                                sent[st++].cc=ADJ;
        !           701:                                sent[st].cc=NOUN;
        !           702:                                if(prep==0)subty=PLURAL;
        !           703: 
        !           704:                                break;
        !           705:                        }
        !           706:                        sent[st].cc=PRONP;
        !           707:                        if(prep==0)subty=SING;
        !           708:                        break;
        !           709:                default:        
        !           710:                        sent[st].cc=PRONP;
        !           711:                        if(prep==0)subty=SING;
        !           712: 
        !           713:                        break;
        !           714:                }
        !           715:                break;
        !           716:        case NOUN_ADJ:
        !           717:                if(nextst==NOUN||nextst==ADJ||nextst == NOUN_ADJ||nextst==PRONS_ADJ||nextst==PRONP_ADJ){
        !           718:                        sent[st++].cc=ADJ;
        !           719:                        goto b;
        !           720:                }
        !           721:                if(nextst!=UNK && nextst != NOUN_VERB && nextst != NV_PL){
        !           722:                        sent[st].cc=NOUN;
        !           723:                        if(prep==0)subty=SING;
        !           724:                        break;
        !           725:                }
        !           726:                if(verb==1 || sent[st+2].cc==ED){
        !           727:                        sent[st++].cc=ADJ;
        !           728:                        goto b;
        !           729:                }
        !           730:                sent[st].cc=NOUN;
        !           731:                if(prep==0)subty=SING;
        !           732:                break;
        !           733:        case UNK:       
        !           734:                if(nextst != UNK){
        !           735:                        if(nextst == ',' && rep==0){
        !           736:                                c=sent[st+2].cc;
        !           737:                                if((c==UNK||c==ADJ||c==NOUN_ADJ||c==ING) && (sent[st+3].cc==UNK||sent[st+3].cc==NOUN_VERB
        !           738:                                        || sent[st+3].cc==NV_PL)){
        !           739:                                        comma--;
        !           740:                                        sent[st].cc=ADJ;
        !           741:                                        sent[st+2].cc=ADJ;
        !           742:                                        sent[st+3].cc=NOUN;
        !           743:                                        if(prep==0){
        !           744:                                                if(sent[st+3].ic==NV_PL)subty=PLURAL;
        !           745:                                                else subty=SING;
        !           746:                                        }
        !           747:                                        return(st+3);
        !           748:                                }
        !           749:                                else {
        !           750:                                        sent[st].cc=NOUN;
        !           751:                                        if(prep==0)subty=SING;
        !           752:                                        break;
        !           753:                                }
        !           754:                        }
        !           755:                        if(nextst==NOUN||nextst==ING ||nextst==NOUN_ADJ|| sent[st-1].cc==ADV
        !           756:                                || nextst==ADJ){
        !           757:                                sent[st++].cc=ADJ;
        !           758:                                goto b;
        !           759:                        }
        !           760:                        if((nextst==NV_PL || nextst==NOUN_VERB) &&(verb==1 ||(verb==0 && (sent[st+2].cc==UNK
        !           761:                                || sent[st+2].cc==NOUN_VERB || sent[st+2].cc==ED||sent[st+2].cc==VERB_ADJ)))){
        !           762:                                        sent[st++].cc=ADJ;
        !           763:                                        sent[st].cc=NOUN;
        !           764:                                        if(prep == 0)subty=PLURAL;
        !           765:                                        break;
        !           766:                                }
        !           767:                        if(nextst==CONJ &&(sent[st+2].cc==ADJ||sent[st+2].cc==ADJ_ADV)){
        !           768:                                sent[st].cc=ADJ;
        !           769:                                goto b;
        !           770:                        }
        !           771:                        sent[st].cc=NOUN;
        !           772:                        if(prep==0)subty=SING;
        !           773: 
        !           774:                        break;
        !           775:                }
        !           776:                for(t=st+1;sent[t].cc== UNK;t++);
        !           777:                if(verb==0 && prep == 0){               /* UUU. */
        !           778:                        if(prep==0)subty=SING;
        !           779:                        if(sent[t].cc==NV_PL){  /* UUZ.*/
        !           780:                                if(sent[t+1].cc==UNK || sent[t+1].cc==NOUN_VERB){       /* UUZU */
        !           781:                                        sent[t+1].cc=VERB;
        !           782:                                        verb=1;
        !           783:                                        sent[t].cc=NOUN;
        !           784:                                        t1=t;
        !           785:                                }
        !           786:                                else{           /* UUZ. */
        !           787:                                        sent[t].cc=VERB;
        !           788:                                        verb=1;
        !           789:                                        sent[t-1].cc=NOUN;
        !           790:                                        t1=t-1;
        !           791:                                }
        !           792:                        }
        !           793:                        else{           /* UU. */
        !           794:                                if(sent[t].cc!= ED){
        !           795:                                        sent[t-1].cc=VERB;
        !           796:                                        verb=1;
        !           797:                                        sent[t-2].cc=NOUN;
        !           798:                                        t1=t-2;
        !           799:                                        t--;
        !           800:                                }
        !           801:                                else {
        !           802:                                        sent[--t].cc=NOUN;
        !           803:                                        t1=t;
        !           804:                                }
        !           805:                        }
        !           806:                }
        !           807:                else{
        !           808:                        if(sent[t].cc==NOUN_VERB|| sent[t].cc==NOUN|| sent[t].cc==NV_PL){
        !           809:                                sent[t].cc=NOUN;
        !           810:                                if(prep==0)subty=PLURAL;
        !           811:                                t1=t;
        !           812:                        }
        !           813:                        else{
        !           814:                                sent[--t].cc=NOUN;
        !           815:                                if(prep==0)subty=SING;
        !           816:                                t1=t;
        !           817:                        }
        !           818:                }
        !           819:                for(tt=st;tt<t1;tt++)sent[tt].cc=ADJ;
        !           820:                st=t;
        !           821:                break;
        !           822:        }
        !           823: getdef:
        !           824:        if(sent[st].cc == CONJ && sent[st-1].cc == ADJ){
        !           825:                st++;
        !           826:                goto b;
        !           827:        }
        !           828:        if(sent[st-1].cc==PREP && ( sent[st].cc == THAT || sent[st].cc == SUBCONJ)){
        !           829:                prep=0;
        !           830:                return(--st);
        !           831:        }
        !           832:        if(sent[st].cc != NOUN && sent[st].cc != PRONP && sent[st].cc != PRONS){
        !           833:                st--;
        !           834:                if(sent[st].cc==ADJ && sent[st].ic==ING){
        !           835:                        sent[st].cc=NOUN;
        !           836:                        if(prep==0)subty=SING;
        !           837:                }
        !           838:                else if(sent[st].cc == PREP){
        !           839:                        sent[st].cc = ADV;
        !           840:                }
        !           841:                prep=0;
        !           842:                return(st);
        !           843:        }
        !           844:        if(done==1){
        !           845:                prep=0;
        !           846:                return(st);
        !           847:        }
        !           848:        if(sent[st+1].cc== ','){
        !           849:                if(sent[st+2].cc==CONJ){
        !           850:                        if(rep==0){
        !           851:                                prep=0;
        !           852:                                return(st);
        !           853:                        }
        !           854:                        else{
        !           855:                                st+=3;
        !           856:                                comma--;
        !           857:                                if(prep==0)subty=PLURAL;
        !           858:                                prep=1;
        !           859:                                goto b;
        !           860:                        }
        !           861:                }
        !           862:                if(comma==1){
        !           863:                        prep=0;
        !           864:                        return(st);
        !           865:                }
        !           866: 
        !           867:                switch(sent[st+2].cc){
        !           868:                case PREP:
        !           869:                case SUBCONJ:
        !           870:                        prep=0;
        !           871:                        return(st);
        !           872:                default:        rep++;
        !           873:                        comma--;
        !           874:                        st+=2;
        !           875:                        if(prep==0)subty=PLURAL;
        !           876:                        prep=1;
        !           877:                        goto b;
        !           878:                }
        !           879:        }
        !           880:        if(sent[st+1].cc==CONJ && sent[st+2].cc != ED){
        !           881:                st+=2;
        !           882:                if(prep==0)subty=PLURAL;
        !           883:                prep=1;
        !           884:                goto b;
        !           885:        }
        !           886:        prep=0;
        !           887:        return(st);
        !           888: }
        !           889: who(kk,ce)
        !           890: int kk,ce;
        !           891: {
        !           892:        char c;
        !           893:        sent[kk].cc=PRONP;
        !           894:        c=sent[kk+1].cc;
        !           895:        while(c==ADV||c==ADJ_ADV){
        !           896:                sent[++kk].cc = ADV;
        !           897:                c = sent[kk+1].cc;
        !           898:        }
        !           899:        if(c==UNK||c==NOUN_VERB||c==VERB_ADJ||c==ED|| c==NV_PL){
        !           900:                sent[++kk].cc=VERB;
        !           901:                if(verb == 0)verb = getv(kk+1,ce);
        !           902:                return(kk);
        !           903:        }
        !           904: w:     switch(sent[++kk].cc){
        !           905:        case AUXX:
        !           906:        case ADV:
        !           907:        case BE:
        !           908:        case VERB:
        !           909:                goto w;
        !           910:        default:
        !           911:                verb=getv(kk,ce);
        !           912:                return(--kk);
        !           913:        }
        !           914: }

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