# 2.11BSD#431 - /usr/src/ucb/ex/ex_cmds.c

##### Functions

    commands          X

##### Variables

    nflag             X
    pflag             X
    poffset           X

##### Macros

    nochng            X

       1: /*
       2:  * Copyright (c) 1980 Regents of the University of California.
       3:  * All rights reserved.  The Berkeley software License Agreement
       4:  * specifies the terms and conditions for redistribution.
       5:  */
       6:
       7: #if !defined(lint) && defined(DOSCCS)
       8: static char *sccsid = "@(#)ex_cmds.c	7.10.1 (2.11BSD) 1996/11/19";
       9: #endif
      10:
      11: #include "ex.h"
      12: #include "ex_argv.h"
      13: #include "ex_temp.h"
      14: #include "ex_tty.h"
      15: #include "ex_vis.h"
      16:
      17: bool    pflag, nflag;
      18: int poffset;
      19:
      20: #define nochng()    lchng = chng
      21:
      22: /*
      23:  * Main loop for command mode command decoding.
      24:  * A few commands are executed here, but main function
      25:  * is to strip command addresses, do a little address oriented
      26:  * processing and call command routines to do the real work.
      27:  */
      28: commands(noprompt, exitoneof)
      29:     bool noprompt, exitoneof;
      30: {
      31:     register line *addr;
      32:     register int c;
      33:     register int lchng;
      34:     int given;
      35:     int seensemi;
      36:     int cnt;
      37:     bool hadpr;
      38:
      39:     resetflav();
      40:     nochng();
      41:     for (;;) {
      42:         /*
      43: 		 * If dot at last command
      44: 		 * ended up at zero, advance to one if there is a such.
      45: 		 */
      46:         if (dot <= zero) {
      47:             dot = zero;
      48:             if (dol > zero)
      49:                 dot = one;
      50:         }
      51:         shudclob = 0;
      52:
      53:         /*
      54: 		 * If autoprint or trailing print flags,
      55: 		 * print the line at the specified offset
      56: 		 * before the next command.
      57: 		 */
      58:         if (pflag ||
      59:             lchng != chng && value(AUTOPRINT) && !inglobal && !inopen && endline) {
      60:             pflag = 0;
      61:             nochng();
      62:             if (dol != zero) {
      63:                 addr1 = addr2 = dot + poffset;
      64:                 if (addr1 < one || addr1 > dol)
      65: error("Offset out-of-bounds|Offset after command too large");
      66:                 setdot1();
      67:                 goto print;
      68:             }
      69:         }
      70:         nochng();
      71:
      72:         /*
      73: 		 * Print prompt if appropriate.
      74: 		 * If not in global flush output first to prevent
      75: 		 * going into pfast mode unreasonably.
      76: 		 */
      77:         if (inglobal == 0) {
      78:             flush();
      79:             if (!hush && value(PROMPT) && !globp && !noprompt && endline) {
      80:                 putchar(':');
      81:                 hadpr = 1;
      82:             }
      83:             TSYNC();
      84:         }
      85:
      86:         /*
      87: 		 * Gobble up the address.
      88: 		 * Degenerate addresses yield ".".
      89: 		 */
      90:         addr2 = 0;
      91:         given = seensemi = 0;
      92:         do {
      93:             addr1 = addr2;
      94:             addr = address(0);
      95:             c = getcd();
      96:             if (addr == 0)
      97:                 if (c == ',')
      98:                     addr = dot;
      99:                 else if (addr1 != 0) {
     100:                     addr2 = dot;
     101:                     break;
     102:                 } else
     103:                     break;
     104:             addr2 = addr;
     105:             given++;
     106:             if (c == ';') {
     107:                 c = ',';
     108:                 dot = addr;
     109:                 seensemi = 1;
     110:             }
     111:         } while (c == ',');
     112:         if (c == '%') {
     113:             /* %: same as 1,$ */
     114:             addr1 = one;
     115:             addr2 = dol;
     116:             given = 2;
     117:             c = getchar();
     118:         }
     119:         if (addr1 == 0)
     120:             addr1 = addr2;
     121:         if (c == ':')
     122:             c = getchar();
     123:
     124:         /*
     125: 		 * Set command name for special character commands.
     126: 		 */
     127:         tailspec(c);
     128:
     129:         /*
     130: 		 * If called via : escape from open or visual, limit
     131: 		 * the set of available commands here to save work below.
     132: 		 */
     133:         if (inopen) {
     134:             if (c=='\n' || c=='\r' || c==CTRL(d) || c==EOF) {
     135:                 if (addr2)
     136:                     dot = addr2;
     137:                 if (c == EOF)
     138:                     return;
     139:                 continue;
     140:             }
     141:             if (any(c, "o"))
     142: notinvis:
     143:                 tailprim(Command, 1, 1);
     144:         }
     145: choice:
     146:         switch (c) {
     147:
     148:         case 'a':
     149:
     150:             switch(peekchar()) {
     151:             case 'b':
     152: /* abbreviate */
     153:                 tail("abbreviate");
     154:                 setnoaddr();
     155:                 mapcmd(0, 1);
     156:                 anyabbrs = 1;
     157:                 continue;
     158:             case 'r':
     159: /* args */
     160:                 tail("args");
     161:                 setnoaddr();
     162:                 eol();
     163:                 pargs();
     164:                 continue;
     165:             }
     166:
     167: /* append */
     168:             if (inopen)
     169:                 goto notinvis;
     170:             tail("append");
     171:             setdot();
     172:             aiflag = exclam();
     173:             newline();
     174:             vmacchng(0);
     175:             deletenone();
     176:             setin(addr2);
     177:             inappend = 1;
     178:             ignore(append(gettty, addr2));
     179:             inappend = 0;
     180:             nochng();
     181:             continue;
     182:
     183:         case 'c':
     184:             switch (peekchar()) {
     185:
     186: /* copy */
     187:             case 'o':
     188:                 tail("copy");
     189:                 vmacchng(0);
     190:                 move();
     191:                 continue;
     192:
     193: #ifdef CHDIR
     194: /* cd */
     195:             case 'd':
     196:                 tail("cd");
     197:                 goto changdir;
     198:
     199: /* chdir */
     200:             case 'h':
     201:                 ignchar();
     202:                 if (peekchar() == 'd') {
     203:                     register char *p;
     204:                     tail2of("chdir");
     205: changdir:
     206:                     if (savedfile[0] == '/' || !value(WARN))
     207:                         ignore(exclam());
     208:                     else
     209:                         ignore(quickly());
     210:                     if (skipend()) {
     211:                         p = getenv("HOME");
     212:                         if (p == NULL)
     213:                             error("Home directory unknown");
     214:                     } else
     215:                         getone(), p = file;
     216:                     eol();
     217:                     if (chdir(p) < 0)
     218:                         filioerr(p);
     219:                     if (savedfile[0] != '/')
     220:                         edited = 0;
     221:                     continue;
     222:                 }
     223:                 if (inopen)
     224:                     tailprim("change", 2, 1);
     225:                 tail2of("change");
     226:                 break;
     227:
     228: #endif
     229:             default:
     230:                 if (inopen)
     231:                     goto notinvis;
     232:                 tail("change");
     233:                 break;
     234:             }
     235: /* change */
     236:             aiflag = exclam();
     237:             setCNL();
     238:             vmacchng(0);
     239:             setin(addr1);
     240:             delete(0);
     241:             inappend = 1;
     242:             ignore(append(gettty, addr1 - 1));
     243:             inappend = 0;
     244:             nochng();
     245:             continue;
     246:
     247: /* delete */
     248:         case 'd':
     249:             /*
     250: 			 * Caution: dp and dl have special meaning already.
     251: 			 */
     252:             tail("delete");
     253:             c = cmdreg();
     254:             setCNL();
     255:             vmacchng(0);
     256:             if (c)
     257:                 YANKreg(c);
     258:             delete(0);
     259:             appendnone();
     260:             continue;
     261:
     262: /* edit */
     263: /* ex */
     264:         case 'e':
     265:             tail(peekchar() == 'x' ? "ex" : "edit");
     266: editcmd:
     267:             if (!exclam() && chng)
     268:                 c = 'E';
     269:             filename(c);
     270:             if (c == 'E') {
     271:                 ungetchar(lastchar());
     272:                 ignore(quickly());
     273:             }
     274:             setnoaddr();
     275: doecmd:
     276:             init();
     277:             addr2 = zero;
     278:             laste++;
     279:             sync();
     280:             rop(c);
     281: #ifdef VMUNIX
     282:             tlaste();
     283: #endif
     284:             laste = 0;
     285:             sync();
     286:             nochng();
     287:             continue;
     288:
     289: /* file */
     290:         case 'f':
     291:             tail("file");
     292:             setnoaddr();
     293:             filename(c);
     294:             noonl();
     295: /*
     296: 			synctmp();
     297: */
     298:             continue;
     299:
     300: /* global */
     301:         case 'g':
     302:             tail("global");
     303:             global(!exclam());
     304:             nochng();
     305:             continue;
     306:
     307: /* insert */
     308:         case 'i':
     309:             if (inopen)
     310:                 goto notinvis;
     311:             tail("insert");
     312:             setdot();
     313:             nonzero();
     314:             aiflag = exclam();
     315:             newline();
     316:             vmacchng(0);
     317:             deletenone();
     318:             setin(addr2);
     319:             inappend = 1;
     320:             ignore(append(gettty, addr2 - 1));
     321:             inappend = 0;
     322:             if (dot == zero && dol > zero)
     323:                 dot = one;
     324:             nochng();
     325:             continue;
     326:
     327: /* join */
     328:         case 'j':
     329:             tail("join");
     330:             c = exclam();
     331:             setcount();
     332:             nonzero();
     333:             newline();
     334:             vmacchng(0);
     335:             if (given < 2 && addr2 != dol)
     336:                 addr2++;
     337:             join(c);
     338:             continue;
     339:
     340: /* k */
     341:         case 'k':
     342: casek:
     343:             pastwh();
     344:             c = getchar();
     345:             if (endcmd(c))
     346:                 serror("Mark what?|%s requires following letter", Command);
     347:             newline();
     348:             if (!islower(c))
     349:                 error("Bad mark|Mark must specify a letter");
     350:             setdot();
     351:             nonzero();
     352:             names[c - 'a'] = *addr2 &~ 01;
     353:             anymarks = 1;
     354:             continue;
     355:
     356: /* list */
     357:         case 'l':
     358:             tail("list");
     359:             setCNL();
     360:             ignorf(setlist(1));
     361:             pflag = 0;
     362:             goto print;
     363:
     364:         case 'm':
     365:             if (peekchar() == 'a') {
     366:                 ignchar();
     367:                 if (peekchar() == 'p') {
     368: /* map */
     369:                     tail2of("map");
     370:                     setnoaddr();
     371:                     mapcmd(0, 0);
     372:                     continue;
     373:                 }
     374: /* mark */
     375:                 tail2of("mark");
     376:                 goto casek;
     377:             }
     378: /* move */
     379:             tail("move");
     380:             vmacchng(0);
     381:             move();
     382:             continue;
     383:
     384:         case 'n':
     385:             if (peekchar() == 'u') {
     386:                 tail("number");
     387:                 goto numberit;
     388:             }
     389: /* next */
     390:             tail("next");
     391:             setnoaddr();
     392:             ckaw();
     393:             ignore(quickly());
     394:             if (getargs())
     395:                 makargs();
     396:             next();
     397:             c = 'e';
     398:             filename(c);
     399:             goto doecmd;
     400:
     401: /* open */
     402:         case 'o':
     403:             tail("open");
     404:             oop();
     405:             pflag = 0;
     406:             nochng();
     407:             continue;
     408:
     409:         case 'p':
     410:         case 'P':
     411:             switch (peekchar()) {
     412:
     413: /* put */
     414:             case 'u':
     415:                 tail("put");
     416:                 setdot();
     417:                 c = cmdreg();
     418:                 eol();
     419:                 vmacchng(0);
     420:                 if (c)
     421:                     putreg(c);
     422:                 else
     423:                     put();
     424:                 continue;
     425:
     426:             case 'r':
     427:                 ignchar();
     428:                 if (peekchar() == 'e') {
     429: /* preserve */
     430:                     tail2of("preserve");
     431:                     eol();
     432:                     if (preserve() == 0)
     433:                         error("Preserve failed!");
     434:                     else
     435:                         error("File preserved.");
     436:                 }
     437:                 tail2of("print");
     438:                 break;
     439:
     440:             default:
     441:                 tail("print");
     442:                 break;
     443:             }
     444: /* print */
     445:             setCNL();
     446:             pflag = 0;
     447: print:
     448:             nonzero();
     449:             if (CL && span() > LINES) {
     450:                 flush1();
     451:                 vclear();
     452:             }
     453:             plines(addr1, addr2, 1);
     454:             continue;
     455:
     456: /* quit */
     457:         case 'q':
     458:             tail("quit");
     459:             setnoaddr();
     460:             c = quickly();
     461:             eol();
     462:             if (!c)
     463: quit:
     464:                 nomore();
     465:             if (inopen) {
     466:                 vgoto(WECHO, 0);
     467:                 if (!ateopr())
     468:                     vnfl();
     469:                 else {
     470:                     tostop();
     471:                 }
     472:                 flush();
     473:                 setty(normf);
     474:             }
     475:             cleanup(1);
     476:             exit(0);
     477:
     478:         case 'r':
     479:             if (peekchar() == 'e') {
     480:                 ignchar();
     481:                 switch (peekchar()) {
     482:
     483: /* rewind */
     484:                 case 'w':
     485:                     tail2of("rewind");
     486:                     setnoaddr();
     487:                     if (!exclam()) {
     488:                         ckaw();
     489:                         if (chng && dol > zero)
     490:                             error("No write@since last change (:rewind! overrides)");
     491:                     }
     492:                     eol();
     493:                     erewind();
     494:                     next();
     495:                     c = 'e';
     496:                     ungetchar(lastchar());
     497:                     filename(c);
     498:                     goto doecmd;
     499:
     500: /* recover */
     501:                 case 'c':
     502:                     tail2of("recover");
     503:                     setnoaddr();
     504:                     c = 'e';
     505:                     if (!exclam() && chng)
     506:                         c = 'E';
     507:                     filename(c);
     508:                     if (c == 'E') {
     509:                         ungetchar(lastchar());
     510:                         ignore(quickly());
     511:                     }
     512:                     init();
     513:                     addr2 = zero;
     514:                     laste++;
     515:                     sync();
     516:                     recover();
     517:                     rop2();
     518:                     revocer();
     519:                     if (status == 0)
     520:                         rop3(c);
     521:                     if (dol != zero)
     522:                         change();
     523: #ifdef VMUNIX
     524:                     tlaste();
     525: #endif
     526:                     laste = 0;
     527:                     nochng();
     528:                     continue;
     529:                 }
     530:                 tail2of("read");
     531:             } else
     532:                 tail("read");
     533: /* read */
     534:             if (savedfile[0] == 0 && dol == zero)
     535:                 c = 'e';
     536:             pastwh();
     537:             vmacchng(0);
     538:             if (peekchar() == '!') {
     539:                 setdot();
     540:                 ignchar();
     541:                 unix0(0);
     542:                 filter(0);
     543:                 continue;
     544:             }
     545:             filename(c);
     546:             rop(c);
     547:             nochng();
     548:             if (inopen && endline && addr1 > zero && addr1 < dol)
     549:                 dot = addr1 + 1;
     550:             continue;
     551:
     552:         case 's':
     553:             switch (peekchar()) {
     554:             /*
     555: 			 * Caution: 2nd char cannot be c, g, or r
     556: 			 * because these have meaning to substitute.
     557: 			 */
     558:
     559: /* set */
     560:             case 'e':
     561:                 tail("set");
     562:                 setnoaddr();
     563:                 set();
     564:                 continue;
     565:
     566: /* shell */
     567:             case 'h':
     568:                 tail("shell");
     569:                 setNAEOL();
     570:                 vnfl();
     571:                 putpad(TE);
     572:                 flush();
     573:                 unixwt(1, unixex("-i", (char *) 0, 0, 0));
     574:                 vcontin(0);
     575:                 continue;
     576:
     577: /* source */
     578:             case 'o':
     579: #ifdef notdef
     580:                 if (inopen)
     581:                     goto notinvis;
     582: #endif
     583:                 tail("source");
     584:                 setnoaddr();
     585:                 getone();
     586:                 eol();
     587:                 source(file, 0);
     588:                 continue;
     589: #ifdef SIGTSTP
     590: /* stop, suspend */
     591:             case 't':
     592:                 tail("stop");
     593:                 goto suspend;
     594:             case 'u':
     595:                 tail("suspend");
     596: suspend:
     597:                 if (!ldisc)
     598:                     error("Old tty driver|Not using new tty driver/shell");
     599:                 c = exclam();
     600:                 eol();
     601:                 if (!c)
     602:                     ckaw();
     603:                 onsusp();
     604:                 continue;
     605: #endif
     606:
     607:             }
     608:             /* fall into ... */
     609:
     610: /* & */
     611: /* ~ */
     612: /* substitute */
     613:         case '&':
     614:         case '~':
     615:             Command = "substitute";
     616:             if (c == 's')
     617:                 tail(Command);
     618:             vmacchng(0);
     619:             if (!substitute(c))
     620:                 pflag = 0;
     621:             continue;
     622:
     623: /* t */
     624:         case 't':
     625:             if (peekchar() == 'a') {
     626:                 tail("tag");
     627:                 tagfind(exclam());
     628:                 if (!inopen)
     629:                     lchng = chng - 1;
     630:                 else
     631:                     nochng();
     632:                 continue;
     633:             }
     634:             tail("t");
     635:             vmacchng(0);
     636:             move();
     637:             continue;
     638:
     639:         case 'u':
     640:             if (peekchar() == 'n') {
     641:                 ignchar();
     642:                 switch(peekchar()) {
     643: /* unmap */
     644:                 case 'm':
     645:                     tail2of("unmap");
     646:                     setnoaddr();
     647:                     mapcmd(1, 0);
     648:                     continue;
     649: /* unabbreviate */
     650:                 case 'a':
     651:                     tail2of("unabbreviate");
     652:                     setnoaddr();
     653:                     mapcmd(1, 1);
     654:                     anyabbrs = 1;
     655:                     continue;
     656:                 }
     657: /* undo */
     658:                 tail2of("undo");
     659:             } else
     660:                 tail("undo");
     661:             setnoaddr();
     662:             markDOT();
     663:             c = exclam();
     664:             newline();
     665:             undo(c);
     666:             continue;
     667:
     668:         case 'v':
     669:             switch (peekchar()) {
     670:
     671:             case 'e':
     672: /* version */
     673:                 tail("version");
     674:                 setNAEOL();
     675:                 printf("@(#) Version 3.7, 6/7/85."+5);
     676:                 noonl();
     677:                 continue;
     678:
     679: /* visual */
     680:             case 'i':
     681:                 tail("visual");
     682:                 if (inopen) {
     683:                     c = 'e';
     684:                     goto editcmd;
     685:                 }
     686:                 vop();
     687:                 pflag = 0;
     688:                 nochng();
     689:                 continue;
     690:             }
     691: /* v */
     692:             tail("v");
     693:             global(0);
     694:             nochng();
     695:             continue;
     696:
     697: /* write */
     698:         case 'w':
     699:             c = peekchar();
     700:             tail(c == 'q' ? "wq" : "write");
     701: wq:
     702:             if (skipwh() && peekchar() == '!') {
     703:                 pofix();
     704:                 ignchar();
     705:                 setall();
     706:                 unix0(0);
     707:                 filter(1);
     708:             } else {
     709:                 setall();
     710:                 wop(1);
     711:                 nochng();
     712:             }
     713:             if (c == 'q')
     714:                 goto quit;
     715:             continue;
     716:
     717: /* xit */
     718:         case 'x':
     719:             tail("xit");
     720:             if (!chng)
     721:                 goto quit;
     722:             c = 'q';
     723:             goto wq;
     724:
     725: /* yank */
     726:         case 'y':
     727:             tail("yank");
     728:             c = cmdreg();
     729:             setcount();
     730:             eol();
     731:             vmacchng(0);
     732:             if (c)
     733:                 YANKreg(c);
     734:             else
     735:                 yank();
     736:             continue;
     737:
     738: /* z */
     739:         case 'z':
     740:             zop(0);
     741:             pflag = 0;
     742:             continue;
     743:
     744: /* * */
     745: /* @ */
     746:         case '*':
     747:         case '@':
     748:             c = getchar();
     749:             if (c=='\n' || c=='\r')
     750:                 ungetchar(c);
     751:             if (any(c, "@*\n\r"))
     752:                 c = lastmac;
     753:             if (isupper(c))
     754:                 c = tolower(c);
     755:             if (!islower(c))
     756:                 error("Bad register");
     757:             newline();
     758:             setdot();
     759:             cmdmac(c);
     760:             continue;
     761:
     762: /* | */
     763:         case '|':
     764:             endline = 0;
     765:             goto caseline;
     766:
     767: /* \n */
     768:         case '\n':
     769:             endline = 1;
     770: caseline:
     771:             notempty();
     772:             if (addr2 == 0) {
     773:                 if (UP != NOSTR && c == '\n' && !inglobal)
     774:                     c = CTRL(k);
     775:                 if (inglobal)
     776:                     addr1 = addr2 = dot;
     777:                 else {
     778:                     if (dot == dol)
     779:                         error("At EOF|At end-of-file");
     780:                     addr1 = addr2 = dot + 1;
     781:                 }
     782:             }
     783:             setdot();
     784:             nonzero();
     785:             if (seensemi)
     786:                 addr1 = addr2;
     787:             getline(*addr1);
     788:             if (c == CTRL(k)) {
     789:                 flush1();
     790:                 destline--;
     791:                 if (hadpr)
     792:                     shudclob = 1;
     793:             }
     794:             plines(addr1, addr2, 1);
     795:             continue;
     796:
     797: /* " */
     798:         case '"':
     799:             comment();
     800:             continue;
     801:
     802: /* # */
     803:         case '#':
     804: numberit:
     805:             setCNL();
     806:             ignorf(setnumb(1));
     807:             pflag = 0;
     808:             goto print;
     809:
     810: /* = */
     811:         case '=':
     812:             newline();
     813:             setall();
     814:             if (inglobal == 2)
     815:                 pofix();
     816:             printf("%d", lineno(addr2));
     817:             noonl();
     818:             continue;
     819:
     820: /* ! */
     821:         case '!':
     822:             if (addr2 != 0) {
     823:                 vmacchng(0);
     824:                 unix0(0);
     825:                 setdot();
     826:                 filter(2);
     827:             } else {
     828:                 unix0(1);
     829:                 pofix();
     830:                 putpad(TE);
     831:                 flush();
     832:                 unixwt(1, unixex("-c", uxb, 0, 0));
     833:                 vclrech(1); /* vcontin(0); */
     834:                 nochng();
     835:             }
     836:             continue;
     837:
     838: /* < */
     839: /* > */
     840:         case '<':
     841:         case '>':
     842:             for (cnt = 1; peekchar() == c; cnt++)
     843:                 ignchar();
     844:             setCNL();
     845:             vmacchng(0);
     846:             shift(c, cnt);
     847:             continue;
     848:
     849: /* ^D */
     850: /* EOF */
     851:         case CTRL(d):
     852:         case EOF:
     853:             if (exitoneof) {
     854:                 if (addr2 != 0)
     855:                     dot = addr2;
     856:                 return;
     857:             }
     858:             if (!isatty(0)) {
     859:                 if (intty)
     860:                     /*
     861: 					 * Chtty sys call at UCB may cause a
     862: 					 * input which was a tty to suddenly be
     863: 					 * turned into /dev/null.
     864: 					 */
     865:                     onhup();
     866:                 return;
     867:             }
     868:             if (addr2 != 0) {
     869:                 setlastchar('\n');
     870:                 putnl();
     871:             }
     872:             if (dol == zero) {
     873:                 if (addr2 == 0)
     874:                     putnl();
     875:                 notempty();
     876:             }
     877:             ungetchar(EOF);
     878:             zop(hadpr);
     879:             continue;
     880:
     881:         default:
     882:             if (!isalpha(c))
     883:                 break;
     884:             ungetchar(c);
     885:             tailprim("", 0, 0);
     886:         }
     887:         error("What?|Unknown command character '%c'", c);
     888:     }
     889: }

#### Defined functions

commands defined in line 28; used 12 times

- in /usr/src/ucb/ex/ex.c line 307, 344, 363, 378
- in /usr/src/ucb/ex/ex_cmdsub.c line 640, 660, 1287
- in /usr/src/ucb/ex/ex_io.c line 463, 788, 883
- in /usr/src/ucb/ex/ex_re.c line 122
- in /usr/src/ucb/ex/ex_vmain.c line 943

#### Defined variables

nflag defined in line 17; used 3 times

- in /usr/src/ucb/ex/ex_cmds2.c line 283, 353, 388

pflag defined in line 17; used 11 times

- in line 58-60(2), 361, 405, 446, 620, 687, 741, 807
- in /usr/src/ucb/ex/ex_cmds2.c line 307, 354

poffset defined in line 18; used 4 times

- in line 63
- in /usr/src/ucb/ex/ex_cmds2.c line 271-275(2), 355

sccsid defined in line 8; never used

#### Defined macros

nochng defined in line 20; used 16 times

- in line 40, 61, 70, 180, 244, 286, 304, 324, 406, 527, 547, 631, 688, 694, 711, 834

Last modified: 1996-11-20 Generated: 2016-12-26 | Generated by src2html V0.67 page hit count: 2581 |