Annotation of researchv10no/cmd/style/pscan.c, revision 1.1

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

unix.superglobalmegacorp.com

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