# 2.11BSD#431 - /usr/src/usr.bin/diction/pscan.c

##### Functions

    getnoun           X
    getv              X
    getv2             X
    scan              X
    who               X

##### Variables

    lastc             X
    nextc             X
    savsub            X

##### Macros

    isadj             X
    isadv             X
    isnoun            X
    issing            X
    notnoun           X
    nounnom           X

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

#### Defined functions

getnoun defined in line 562; used 16 times

- in line 29, 55, 61, 70, 79, 95, 206, 236, 253, 315, 321, 329, 339, 350, 367, 443

getv defined in line 381; used 11 times

- in line 28, 54, 60, 166, 179, 221, 233, 247, 701, 951, 961

getv2 defined in line 483; used 1 times

- in line 446

scan defined in line 15; never used
who defined in line 939; used 2 times

- in line 131, 628

#### Defined variables

lastc defined in line 13; used 10 times

- in line 37-43(4), 120, 150, 189-195(3), 227

nextc defined in line 13; used 28 times

- in line 35, 47(2), 74, 107-111(2), 120-124(3), 137, 149-153(4), 175, 184-189(4), 195(2), 211, 227(2), 281, 310, 335, 341

savsub defined in line 14; used 2 times

- in line 246, 274

sccsid defined in line 2; never used

#### Defined macros

isadj defined in line 8; used 1 times

- in line 107

isadv defined in line 7; used 4 times

- in line 111, 181, 811, 945

isnoun defined in line 11; used 3 times

- in line 341, 637, 782

issing defined in line 10; used 1 times

- in line 190

notnoun defined in line 9; used 1 times

- in line 124

nounnom defined in line 12; used 1 times

- in line 670

Last modified: 1987-02-17 Generated: 2016-12-26 | Generated by src2html V0.67 page hit count: 3012 |