Return to cmd1.c CVS log

Up to [MW Coherent from dump] / coherent / g / usr / bin / vi

Annotation of coherent/g/usr/bin/vi/cmd1.c, revision 1.1

1.1     ! root        1: /* cmd1.c */
        !             2: 
        !             3: /* Author:
        !             4:  *     Steve Kirkendall
        !             5:  *     14407 SW Teal Blvd. #C
        !             6:  *     Beaverton, OR 97005
        !             7:  *     [email protected]
        !             8:  */
        !             9: 
        !            10: 
        !            11: /* This file contains some of the EX commands - mostly ones that deal with
        !            12:  * files, options, etc. -- anything except text.
        !            13:  */
        !            14: 
        !            15: #include "config.h"
        !            16: #include "ctype.h"
        !            17: #include "vi.h"
        !            18: #include "regexp.h"
        !            19: 
        !            20: #ifdef DEBUG
        !            21: /* print the selected lines with info on the blocks */
        !            22: /*ARGSUSED*/
        !            23: void cmd_debug(frommark, tomark, cmd, bang, extra)
        !            24:        MARK    frommark;
        !            25:        MARK    tomark;
        !            26:        CMD     cmd;
        !            27:        int     bang;
        !            28:        char    *extra;
        !            29: {
        !            30:        REG char        *scan;
        !            31:        REG long        l;
        !            32:        REG int         i;
        !            33:        int             len;
        !            34: 
        !            35:        /* scan lnum[] to determine which block its in */
        !            36:        l = markline(frommark);
        !            37:        for (i = 1; l > lnum[i]; i++)
        !            38:        {
        !            39:        }
        !            40: 
        !            41:        do
        !            42:        {
        !            43:                /* fetch text of the block containing that line */
        !            44:                scan = blkget(i)->c;
        !            45: 
        !            46:                /* calculate its length */
        !            47:                if (scan[BLKSIZE - 1])
        !            48:                {
        !            49:                        len = BLKSIZE;
        !            50:                }
        !            51:                else
        !            52:                {
        !            53:                        len = strlen(scan);
        !            54:                }
        !            55: 
        !            56:                /* print block stats */
        !            57:                msg("##### hdr[%d]=%d, lnum[%d-1]=%ld, lnum[%d]=%ld (%ld lines)",
        !            58:                        i, hdr.n[i], i, lnum[i-1], i, lnum[i], lnum[i] - lnum[i - 1]);
        !            59:                msg("##### len=%d, buf=0x%lx, %sdirty",
        !            60:                        len, scan, ((int *)scan)[MAXBLKS + 1] ? "" : "not ");
        !            61:                if (bang)
        !            62:                {
        !            63:                        while (--len >= 0)
        !            64:                        {
        !            65:                                addch(*scan);
        !            66:                                scan++;
        !            67:                        }
        !            68:                }
        !            69:                exrefresh();
        !            70: 
        !            71:                /* next block */
        !            72:                i++;
        !            73:        } while (i < MAXBLKS && lnum[i] && lnum[i - 1] < markline(tomark));
        !            74: }
        !            75: 
        !            76: 
        !            77: /* This function checks a lot of conditions to make sure they aren't screwy */
        !            78: /*ARGSUSED*/
        !            79: void cmd_validate(frommark, tomark, cmd, bang, extra)
        !            80:        MARK    frommark;
        !            81:        MARK    tomark;
        !            82:        CMD     cmd;
        !            83:        int     bang;
        !            84:        char    *extra;
        !            85: {
        !            86:        char    *scan;
        !            87:        int     i;
        !            88:        int     nlcnt;  /* used to count newlines */
        !            89:        int     len;    /* counts non-NUL characters */
        !            90: 
        !            91:        /* check lnum[0] */
        !            92:        if (lnum[0] != 0L)
        !            93:        {
        !            94:                msg("lnum[0] = %ld", lnum[0]);
        !            95:        }
        !            96: 
        !            97:        /* check each block */
        !            98:        for (i = 1; lnum[i] <= nlines; i++)
        !            99:        {
        !           100:                scan = blkget(i)->c;
        !           101:                if (scan[BLKSIZE - 1])
        !           102:                {
        !           103:                        msg("block %d has no NUL at the end", i);
        !           104:                }
        !           105:                else
        !           106:                {
        !           107:                        for (nlcnt = len = 0; *scan; scan++, len++)
        !           108:                        {
        !           109:                                if (*scan == '\n')
        !           110:                                {
        !           111:                                        nlcnt++;
        !           112:                                }
        !           113:                        }
        !           114:                        if (scan[-1] != '\n')
        !           115:                        {
        !           116:                                msg("block %d doesn't end with '\\n' (length %d)", i, len);
        !           117:                        }
        !           118:                        if (bang || nlcnt != lnum[i] - lnum[i - 1])
        !           119:                        {
        !           120:                                msg("block %d (line %ld?) has %d lines, but should have %ld",
        !           121:                                        i, lnum[i - 1] + 1L, nlcnt, lnum[i] - lnum[i - 1]);
        !           122:                        }
        !           123:                }
        !           124:                exrefresh();
        !           125:        }
        !           126: 
        !           127:        /* check lnum again */
        !           128:        if (lnum[i] != INFINITY)
        !           129:        {
        !           130:                msg("hdr.n[%d] = %d, but lnum[%d] = %ld",
        !           131:                        i, hdr.n[i], i, lnum[i]);
        !           132:        }
        !           133: 
        !           134:        msg("# = \"%s\", %% = \"%s\"", prevorig, origname);
        !           135:        msg("V_from=%ld.%d, cursor=%ld.%d", markline(V_from), markidx(V_from), markline(cursor), markidx(cursor));
        !           136: }
        !           137: #endif /* DEBUG */
        !           138: 
        !           139: 
        !           140: /*ARGSUSED*/
        !           141: void cmd_mark(frommark, tomark, cmd, bang, extra)
        !           142:        MARK    frommark;
        !           143:        MARK    tomark;
        !           144:        CMD     cmd;
        !           145:        int     bang;
        !           146:        char    *extra;
        !           147: {
        !           148:        /* validate the name of the mark */
        !           149:        if (*extra == '"')
        !           150:        {
        !           151:                extra++;
        !           152:        }
        !           153:        /* valid mark names are lowercase ascii characters */
        !           154:        if (!isascii(*extra) || !islower(*extra) || extra[1])
        !           155:        {
        !           156:                msg("Invalid mark name");
        !           157:                return;
        !           158:        }
        !           159: 
        !           160:        mark[*extra - 'a'] = tomark;
        !           161: }
        !           162: 
        !           163: /*ARGSUSED*/
        !           164: void cmd_write(frommark, tomark, cmd, bang, extra)
        !           165:        MARK    frommark;
        !           166:        MARK    tomark;
        !           167:        CMD     cmd;
        !           168:        int     bang;
        !           169:        char    *extra;
        !           170: {
        !           171:        int             fd;
        !           172:        int             append; /* boolean: write in "append" mode? */
        !           173:        REG long        l;
        !           174:        REG char        *scan;
        !           175:        REG int         i;
        !           176: 
        !           177:        /* if writing to a filter, then let filter() handle it */
        !           178:        if (*extra == '!')
        !           179:        {
        !           180:                filter(frommark, tomark, extra + 1, FALSE);
        !           181:                return;
        !           182:        }
        !           183: 
        !           184:        /* if all lines are to be written, use tmpsave() */
        !           185:        if (frommark == MARK_FIRST && tomark == MARK_LAST && cmd == CMD_WRITE)
        !           186:        {
        !           187:                tmpsave(extra, bang);
        !           188:                return;
        !           189:        }
        !           190: 
        !           191:        /* see if we're going to do this in append mode or not */
        !           192:        append = FALSE;
        !           193:        if (extra[0] == '>' && extra[1] == '>')
        !           194:        {
        !           195:                extra += 2;
        !           196:                append = TRUE;
        !           197:        }
        !           198: 
        !           199:        /* either the file must not exist, or we must have a ! or be appending */
        !           200:        if (access(extra, 0) == 0 && !bang && !append)
        !           201:        {
        !           202:                msg("File already exists - Use :w! to overwrite");
        !           203:                return;
        !           204:        }
        !           205: 
        !           206:        /* else do it line-by-line, like cmd_print() */
        !           207:        if (append)
        !           208:        {
        !           209: #ifdef O_APPEND
        !           210:                fd = open(extra, O_WRONLY|O_APPEND);
        !           211: #else
        !           212:                fd = open(extra, O_WRONLY);
        !           213:                if (fd >= 0)
        !           214:                {
        !           215:                        lseek(fd, 0L, 2);
        !           216:                }
        !           217: #endif
        !           218:        }
        !           219:        else
        !           220:        {
        !           221:                fd = -1; /* so we know the file isn't open yet */
        !           222:        }
        !           223: 
        !           224:        if (fd < 0)
        !           225:        {
        !           226:                fd = creat(extra, FILEPERMS);
        !           227:                if (fd < 0)
        !           228:                {
        !           229:                        msg("Can't write to \"%s\"", extra);
        !           230:                        return;
        !           231:                }
        !           232:        }
        !           233:        for (l = markline(frommark); l <= markline(tomark); l++)
        !           234:        {
        !           235:                /* get the next line */
        !           236:                scan = fetchline(l);
        !           237:                i = strlen(scan);
        !           238:                scan[i++] = '\n';
        !           239: 
        !           240:                /* print the line */
        !           241:                if (twrite(fd, scan, i) < i)
        !           242:                {
        !           243:                        msg("Write failed");
        !           244:                        break;
        !           245:                }
        !           246:        }
        !           247:        rptlines = markline(tomark) - markline(frommark) + 1;
        !           248:        rptlabel = "written";
        !           249:        close(fd);
        !           250: }      
        !           251: 
        !           252: 
        !           253: /*ARGSUSED*/
        !           254: void cmd_shell(frommark, tomark, cmd, bang, extra)
        !           255:        MARK    frommark, tomark;
        !           256:        CMD     cmd;
        !           257:        int     bang;
        !           258:        char    *extra;
        !           259: {
        !           260:        static char     prevextra[80];
        !           261: 
        !           262:        /* special case: ":sh" means ":!sh" */
        !           263:        if (cmd == CMD_SHELL)
        !           264:        {
        !           265:                extra = o_shell;
        !           266:                frommark = tomark = 0L;
        !           267:        }
        !           268: 
        !           269:        /* if extra is "!", substitute previous command */
        !           270:        if (*extra == '!')
        !           271:        {
        !           272:                if (!*prevextra)
        !           273:                {
        !           274:                        msg("No previous shell command to substitute for '!'");
        !           275:                        return;
        !           276:                }
        !           277:                extra = prevextra;
        !           278:        }
        !           279:        else if (cmd == CMD_BANG && strlen(extra) < sizeof(prevextra) - 1)
        !           280:        {
        !           281:                strcpy(prevextra, extra);
        !           282:        }
        !           283: 
        !           284:        /* warn the user if the file hasn't been saved yet */
        !           285:        if (*o_warn && tstflag(file, MODIFIED))
        !           286:        {
        !           287:                if (mode == MODE_VI)
        !           288:                {
        !           289:                        mode = MODE_COLON;
        !           290:                }
        !           291:                msg("Warning: \"%s\" has been modified but not yet saved", origname);
        !           292:        }
        !           293: 
        !           294:        /* if no lines were specified, just run the command */
        !           295:        suspend_curses();
        !           296:        if (frommark == 0L)
        !           297:        {
        !           298:                system(extra);
        !           299:        }
        !           300:        else /* pipe lines from the file through the command */
        !           301:        {
        !           302:                filter(frommark, tomark, extra, TRUE);
        !           303:        }
        !           304: 
        !           305:        /* resume curses quietly for MODE_EX, but noisily otherwise */
        !           306:        resume_curses(mode == MODE_EX);
        !           307: }
        !           308: 
        !           309: 
        !           310: /*ARGSUSED*/
        !           311: void cmd_global(frommark, tomark, cmd, bang, extra)
        !           312:        MARK    frommark, tomark;
        !           313:        CMD     cmd;
        !           314:        int     bang;
        !           315:        char    *extra; /* rest of the command line */
        !           316: {
        !           317:        char    *cmdptr;        /* the command from the command line */
        !           318:        char    cmdln[100];     /* copy of the command from the command line */
        !           319:        char    *line;          /* a line from the file */
        !           320:        long    l;              /* used as a counter to move through lines */
        !           321:        long    lqty;           /* quantity of lines to be scanned */
        !           322:        long    nchanged;       /* number of lines changed */
        !           323:        regexp  *re;            /* the compiled search expression */
        !           324: 
        !           325:        /* can't nest global commands */
        !           326:        if (doingglobal)
        !           327:        {
        !           328:                msg("Can't nest global commands.");
        !           329:                rptlines = -1L;
        !           330:                return;
        !           331:        }
        !           332: 
        !           333:        /* ":g! ..." is the same as ":v ..." */
        !           334:        if (bang)
        !           335:        {
        !           336:                cmd = CMD_VGLOBAL;
        !           337:        }
        !           338: 
        !           339:        /* make sure we got a search pattern */
        !           340:        if (*extra != '/' && *extra != '?')
        !           341:        {
        !           342:                msg("Usage: %c /regular expression/ command", cmd == CMD_GLOBAL ? 'g' : 'v');
        !           343:                return;
        !           344:        }
        !           345: 
        !           346:        /* parse & compile the search pattern */
        !           347:        cmdptr = parseptrn(extra);
        !           348:        if (!extra[1])
        !           349:        {
        !           350:                msg("Can't use empty regular expression with '%c' command", cmd == CMD_GLOBAL ? 'g' : 'v');
        !           351:                return;
        !           352:        }
        !           353:        re = regcomp(extra + 1);
        !           354:        if (!re)
        !           355:        {
        !           356:                /* regcomp found & described an error */
        !           357:                return;
        !           358:        }
        !           359: 
        !           360:        /* for each line in the range */
        !           361:        doingglobal = TRUE;
        !           362:        ChangeText
        !           363:        {
        !           364:                /* NOTE: we have to go through the lines in a forward order,
        !           365:                 * otherwise "g/re/p" would look funny.  *BUT* for "g/re/d"
        !           366:                 * to work, simply adding 1 to the line# on each loop won't
        !           367:                 * work.  The solution: count lines relative to the end of
        !           368:                 * the file.  Think about it.
        !           369:                 */
        !           370:                for (l = nlines - markline(frommark),
        !           371:                        lqty = markline(tomark) - markline(frommark) + 1L,
        !           372:                        nchanged = 0L;
        !           373:                     lqty > 0 && nlines - l >= 0 && nchanged >= 0L;
        !           374:                     l--, lqty--)
        !           375:                {
        !           376:                        /* fetch the line */
        !           377:                        line = fetchline(nlines - l);
        !           378: 
        !           379:                        /* if it contains the search pattern... */
        !           380:                        if ((!regexec(re, line, 1)) == (cmd != CMD_GLOBAL))
        !           381:                        {
        !           382:                                /* move the cursor to that line */
        !           383:                                cursor = MARK_AT_LINE(nlines - l);
        !           384: 
        !           385:                                /* do the ex command (without mucking up
        !           386:                                 * the original copy of the command line)
        !           387:                                 */
        !           388:                                strcpy(cmdln, cmdptr);
        !           389:                                rptlines = 0L;
        !           390:                                doexcmd(cmdln);
        !           391:                                nchanged += rptlines;
        !           392:                        }
        !           393:                }
        !           394:        }
        !           395:        doingglobal = FALSE;
        !           396: 
        !           397:        /* free the regexp */
        !           398:        _free_(re);
        !           399: 
        !           400:        /* Reporting...*/
        !           401:        rptlines = nchanged;
        !           402: }
        !           403: 
        !           404: 
        !           405: /*ARGSUSED*/
        !           406: void cmd_file(frommark, tomark, cmd, bang, extra)
        !           407:        MARK    frommark, tomark;
        !           408:        CMD     cmd;
        !           409:        int     bang;
        !           410:        char    *extra;
        !           411: {
        !           412: #ifndef CRUNCH
        !           413:        /* if we're given a new filename, use it as this file's name */
        !           414:        if (extra && *extra)
        !           415:        {
        !           416:                strcpy(origname, extra);
        !           417:                storename(origname);
        !           418:                setflag(file, NOTEDITED);
        !           419:        }
        !           420: #endif
        !           421:        if (cmd == CMD_FILE)
        !           422:        {
        !           423: #ifndef CRUNCH
        !           424:                msg("\"%s\" %s%s%s %ld lines,  line %ld [%ld%%]",
        !           425: #else
        !           426:                msg("\"%s\" %s%s %ld lines,  line %ld [%ld%%]",
        !           427: #endif
        !           428:                        *origname ? origname : "[NO FILE]",
        !           429:                        tstflag(file, MODIFIED) ? "[MODIFIED]" : "",
        !           430: #ifndef CRUNCH
        !           431:                        tstflag(file, NOTEDITED) ?"[NOT EDITED]":"",
        !           432: #endif
        !           433:                        tstflag(file, READONLY) ? "[READONLY]" : "",
        !           434:                        nlines,
        !           435:                        markline(frommark),
        !           436:                        markline(frommark) * 100 / nlines);
        !           437:        }
        !           438: #ifndef CRUNCH
        !           439:        else if (markline(frommark) != markline(tomark))
        !           440:        {
        !           441:                msg("range \"%ld,%ld\" contains %ld lines",
        !           442:                        markline(frommark),
        !           443:                        markline(tomark),
        !           444:                        markline(tomark) - markline(frommark) + 1L);
        !           445:        }
        !           446: #endif
        !           447:        else
        !           448:        {
        !           449:                msg("%ld", markline(frommark));
        !           450:        }
        !           451: }
        !           452: 
        !           453: 
        !           454: /*ARGSUSED*/
        !           455: void cmd_edit(frommark, tomark, cmd, bang, extra)
        !           456:        MARK    frommark, tomark;
        !           457:        CMD     cmd;
        !           458:        int     bang;
        !           459:        char    *extra;
        !           460: {
        !           461:        long    line = 1L;      /* might be set to prevline */
        !           462: #ifndef CRUNCH
        !           463:        char    *init = (char *)0;
        !           464: #endif
        !           465: 
        !           466: 
        !           467:        /* if ":vi", then switch to visual mode, and if no file is named
        !           468:         * then don't switch files.
        !           469:         */
        !           470:        if (cmd == CMD_VISUAL)
        !           471:        {
        !           472:                mode = MODE_VI;
        !           473:                msg("");
        !           474:                if (!*extra)
        !           475:                {
        !           476:                        return;
        !           477:                }
        !           478:        }
        !           479: 
        !           480:        /* Editing previous file?  Then start at previous line */
        !           481:        if (!strcmp(extra, prevorig))
        !           482:        {
        !           483:                line = prevline;
        !           484:        }
        !           485: 
        !           486: #ifndef CRUNCH
        !           487:        /* if we were given an explicit starting line, then start there */
        !           488:        if (*extra == '+')
        !           489:        {
        !           490:                for (init = ++extra; !isspace(*extra); extra++)
        !           491:                {
        !           492:                }
        !           493:                while (isspace(*extra))
        !           494:                {
        !           495:                        *extra++ = '\0';
        !           496:                }
        !           497:                if (!*init)
        !           498:                {
        !           499:                        init = "$";
        !           500:                }
        !           501:                if (!extra)
        !           502:                {
        !           503:                        extra = origname;
        !           504:                }
        !           505:        }
        !           506: #endif /* not CRUNCH */
        !           507: 
        !           508:        /* switch files */
        !           509:        if (tmpabort(bang))
        !           510:        {
        !           511:                tmpstart(extra);
        !           512:                if (line <= nlines && line >= 1L)
        !           513:                {
        !           514:                        cursor = MARK_AT_LINE(line);
        !           515:                }
        !           516: #ifndef CRUNCH
        !           517:                if (init)
        !           518:                {
        !           519:                        doexcmd(init);
        !           520:                }
        !           521: #endif
        !           522:        }
        !           523:        else
        !           524:        {
        !           525:                msg("Use edit! to abort changes, or w to save changes");
        !           526: 
        !           527:                /* so we can say ":e!#" next time... */
        !           528:                strcpy(prevorig, extra);
        !           529:                prevline = 1L;
        !           530:        }
        !           531: }
        !           532: 
        !           533: /* This code is also used for rewind -- GB */
        !           534: 
        !           535: /*ARGSUSED*/
        !           536: void cmd_next(frommark, tomark, cmd, bang, extra)
        !           537:        MARK    frommark, tomark;
        !           538:        CMD     cmd;
        !           539:        int     bang;
        !           540:        char    *extra;
        !           541: {
        !           542:        int     i, j;
        !           543:        char    *scan;
        !           544: 
        !           545:        /* if extra stuff given, use ":args" to define a new args list */
        !           546:        if (cmd == CMD_NEXT && extra && *extra)
        !           547:        {
        !           548:                cmd_args(frommark, tomark, cmd, bang, extra);
        !           549:        }
        !           550: 
        !           551:        /* move to the next arg */
        !           552:        if (cmd == CMD_NEXT)
        !           553:        {
        !           554:                i = argno + 1;
        !           555:        }
        !           556:        else if (cmd == CMD_PREVIOUS)
        !           557:        {
        !           558:                i = argno - 1;
        !           559:        }
        !           560:        else /* cmd == CMD_REWIND */
        !           561:        {
        !           562:                i = 0;
        !           563:        }       
        !           564:        if (i < 0 || i >= nargs)
        !           565:        {
        !           566:                msg("No %sfiles to edit", cmd == CMD_REWIND ? "" : "more ");
        !           567:                return;
        !           568:        }
        !           569: 
        !           570:        /* find & isolate the name of the file to edit */
        !           571:        for (j = i, scan = args; j > 0; j--)
        !           572:        {
        !           573:                while(*scan++)
        !           574:                {
        !           575:                }
        !           576:        }
        !           577: 
        !           578:        /* switch to the next file */
        !           579:        if (tmpabort(bang))
        !           580:        {
        !           581:                tmpstart(scan);
        !           582:                argno = i;
        !           583:        }
        !           584:        else
        !           585:        {
        !           586:                msg("Use :%s! to abort changes, or w to save changes",
        !           587:                        cmd == CMD_NEXT ? "next" :
        !           588:                        cmd == CMD_PREVIOUS ? "previous" :
        !           589:                                        "rewind");
        !           590:        }
        !           591: }
        !           592: 
        !           593: /* also called from :wq -- always writes back in this case */
        !           594: 
        !           595: /*ARGSUSED*/
        !           596: void cmd_xit(frommark, tomark, cmd, bang, extra)
        !           597:        MARK    frommark, tomark;
        !           598:        CMD     cmd;
        !           599:        int     bang;
        !           600:        char    *extra;
        !           601: {
        !           602:        static long     whenwarned;     /* when the user was last warned of extra files */
        !           603:        int             oldflag;
        !           604: 
        !           605:        /* if there are more files to edit, then warn user */
        !           606:        if (argno >= 0 && argno + 1 < nargs && whenwarned != changes && (!bang || cmd != CMD_QUIT))
        !           607:        {
        !           608:                msg("More files to edit -- Use \":n\" to go to next file");
        !           609:                whenwarned = changes;
        !           610:                return;
        !           611:        }
        !           612: 
        !           613:        if (cmd == CMD_QUIT)
        !           614:        {
        !           615:                oldflag = *o_autowrite;
        !           616:                *o_autowrite = FALSE;
        !           617:                if (tmpabort(bang))
        !           618:                {
        !           619:                        mode = MODE_QUIT;
        !           620:                }
        !           621:                else
        !           622:                {
        !           623:                        msg("Use q! to abort changes, or wq to save changes");
        !           624:                }
        !           625:                *o_autowrite = oldflag;
        !           626:        }
        !           627:        else
        !           628:        {
        !           629:                /* else try to save this file */
        !           630:                oldflag = tstflag(file, MODIFIED);
        !           631:                if (cmd == CMD_WQUIT)
        !           632:                        setflag(file, MODIFIED);
        !           633:                if (tmpend(bang))
        !           634:                {
        !           635:                        mode = MODE_QUIT;
        !           636:                }
        !           637:                else
        !           638:                {
        !           639:                        msg("Could not save file -- use quit! to abort changes, or w filename");
        !           640:                }
        !           641:                if (!oldflag)
        !           642:                        clrflag(file, MODIFIED);
        !           643:        }
        !           644: }
        !           645: 
        !           646: 
        !           647: /*ARGSUSED*/
        !           648: void cmd_args(frommark, tomark, cmd, bang, extra)
        !           649:        MARK    frommark, tomark;
        !           650:        CMD     cmd;
        !           651:        int     bang;
        !           652:        char    *extra;
        !           653: {
        !           654:        char    *scan;
        !           655:        int     col;
        !           656:        int     arg;
        !           657:        int     scrolled = FALSE;
        !           658:        int     width;
        !           659: 
        !           660:        /* if no extra names given, or just current name, then report the args
        !           661:         * we have now.
        !           662:         */
        !           663:        if (!extra || !*extra)
        !           664:        {
        !           665:                /* empty args list? */
        !           666:                if (nargs == 1 && !*args)
        !           667:                {
        !           668:                        return;
        !           669:                }
        !           670: 
        !           671:                /* list the arguments */
        !           672:                for (scan = args, col = arg = 0;
        !           673:                     arg < nargs;
        !           674:                     scan += width + 1, col += width, arg++)
        !           675:                {
        !           676:                        width = strlen(scan);
        !           677:                        if (col + width >= COLS - 4)
        !           678:                        {
        !           679:                                addch('\n');
        !           680:                                col = 0;
        !           681:                                scrolled = TRUE;
        !           682:                        }
        !           683:                        else if (col > 0)
        !           684:                        {
        !           685:                                addch(' ');
        !           686:                                col++;
        !           687:                        }
        !           688:                        if (arg == argno)
        !           689:                        {
        !           690:                                addch('[');
        !           691:                                addstr(scan);
        !           692:                                addch(']');
        !           693:                                col += 2;
        !           694:                        }
        !           695:                        else
        !           696:                        {
        !           697:                                addstr(scan);
        !           698:                        }
        !           699:                }
        !           700: 
        !           701:                /* write a trailing newline */
        !           702:                if ((mode == MODE_EX || mode == MODE_COLON || scrolled) && col)
        !           703:                {
        !           704:                        addch('\n');
        !           705:                }
        !           706:                exrefresh();    
        !           707:        }
        !           708:        else /* new args list given */
        !           709:        {
        !           710:                for (scan = args, nargs = 1; *extra; )
        !           711:                {
        !           712:                        if (isspace(*extra))
        !           713:                        {
        !           714:                                *scan++ = '\0';
        !           715:                                while (isspace(*extra))
        !           716:                                {
        !           717:                                        extra++;
        !           718:                                }
        !           719:                                if (*extra)
        !           720:                                {
        !           721:                                        nargs++;
        !           722:                                }
        !           723:                        }
        !           724:                        else
        !           725:                        {
        !           726:                                *scan++ = *extra++;
        !           727:                        }
        !           728:                }
        !           729:                *scan = '\0';
        !           730: 
        !           731:                /* reset argno to before the first, so :next will go to first */
        !           732:                argno = -1;
        !           733: 
        !           734:                if (nargs != 1)
        !           735:                {
        !           736:                         msg("%d files to edit", nargs);
        !           737:                }
        !           738:        }
        !           739: }
        !           740: 
        !           741: 
        !           742: /*ARGSUSED*/
        !           743: void cmd_cd(frommark, tomark, cmd, bang, extra)
        !           744:        MARK    frommark, tomark;
        !           745:        CMD     cmd;
        !           746:        int     bang;
        !           747:        char    *extra;
        !           748: {
        !           749:        char    *getenv();
        !           750: 
        !           751: #ifndef CRUNCH
        !           752:        /* if current file is modified, and no '!' was given, then error */
        !           753:        if (tstflag(file, MODIFIED) && !bang)
        !           754:        {
        !           755:                msg("File modified; use \"cd! %s\" to switch anyway", extra);
        !           756:        }
        !           757: #endif
        !           758: 
        !           759:        /* default directory name is $HOME */
        !           760:        if (!*extra)
        !           761:        {
        !           762:                extra = getenv("HOME");
        !           763:                if (!extra)
        !           764:                {
        !           765:                        msg("environment variable $HOME not set");
        !           766:                        return;
        !           767:                }
        !           768:        }
        !           769: 
        !           770:        /* go to the directory */
        !           771:        if (chdir(extra) < 0)
        !           772:        {
        !           773:                perror(extra);
        !           774:        }
        !           775: }
        !           776: 
        !           777: 
        !           778: /*ARGSUSED*/
        !           779: void cmd_map(frommark, tomark, cmd, bang, extra)
        !           780:        MARK    frommark, tomark;
        !           781:        CMD     cmd;
        !           782:        int     bang;
        !           783:        char    *extra;
        !           784: {
        !           785:        char    *mapto;
        !           786:        char    *build, *scan;
        !           787: #ifndef NO_FKEY
        !           788:        static char *fnames[NFKEYS] =
        !           789:        {
        !           790:                "#10", "#1", "#2", "#3", "#4",
        !           791:                "#5", "#6", "#7", "#8", "#9",
        !           792: # ifndef NO_SHIFT_FKEY
        !           793:                "#10s", "#1s", "#2s", "#3s", "#4s",
        !           794:                "#5s", "#6s", "#7s", "#8s", "#9s",
        !           795: #  ifndef NO_CTRL_FKEY
        !           796:                "#10c", "#1c", "#2c", "#3c", "#4c",
        !           797:                "#5c", "#6c", "#7c", "#8c", "#9c",
        !           798: #   ifndef NO_ALT_FKEY
        !           799:                "#10a", "#1a", "#2a", "#3a", "#4a",
        !           800:                "#5a", "#6a", "#7a", "#8a", "#9a",
        !           801: #   endif
        !           802: #  endif
        !           803: # endif
        !           804:        };
        !           805:        int     key;
        !           806: #endif
        !           807: 
        !           808:        /* "map" with no extra will dump the map table contents */
        !           809:        if (!*extra)
        !           810:        {
        !           811: #ifndef NO_ABBR
        !           812:                if (cmd == CMD_ABBR)
        !           813:                {
        !           814:                        dumpkey(bang ? WHEN_EX|WHEN_VIINP|WHEN_VIREP : WHEN_VIINP|WHEN_VIREP, TRUE);
        !           815:                }
        !           816:                else
        !           817: #endif
        !           818:                {
        !           819:                        dumpkey(bang ? WHEN_VIINP|WHEN_VIREP : WHEN_VICMD, FALSE);
        !           820:                }
        !           821:        }
        !           822:        else
        !           823:        {
        !           824:                /* "extra" is key to map, followed by what it maps to */
        !           825: 
        !           826:                /* handle quoting inside the "raw" string */
        !           827:                for (build = mapto = extra;
        !           828:                     *mapto && (*mapto != ' ' && *mapto != '\t');
        !           829:                     *build++ = *mapto++)
        !           830:                {
        !           831:                        if (*mapto == ctrl('V') && mapto[1])
        !           832:                        {
        !           833:                                mapto++;
        !           834:                        }
        !           835:                }
        !           836: 
        !           837:                /* skip whitespace, and mark the end of the "raw" string */
        !           838:                while ((*mapto == ' ' || *mapto == '\t'))
        !           839:                {
        !           840:                        *mapto++ = '\0';
        !           841:                }
        !           842:                *build = '\0';
        !           843: 
        !           844:                /* strip ^Vs from the "cooked" string */
        !           845:                for (scan = build = mapto; *scan; *build++ = *scan++)
        !           846:                {
        !           847:                        if (*scan == ctrl('V') && scan[1])
        !           848:                        {
        !           849:                                scan++;
        !           850:                        }
        !           851:                }
        !           852:                *build = '\0';
        !           853: 
        !           854: #ifndef NO_FKEY
        !           855:                /* if the mapped string is '#' and a number, then assume
        !           856:                 * the user wanted that function key
        !           857:                 */
        !           858:                if (extra[0] == '#' && isdigit(extra[1]))
        !           859:                {
        !           860:                        key = atoi(extra + 1) % 10;
        !           861: # ifndef NO_SHIFT_FKEY
        !           862:                        build = extra + strlen(extra) - 1;
        !           863:                        if (*build == 's')
        !           864:                                key += 10;
        !           865: #  ifndef NO_CTRL_FKEY
        !           866:                        else if (*build == 'c')
        !           867:                                key += 20;
        !           868: #   ifndef NO_ALT_FKEY
        !           869:                        else if (*build == 'a')
        !           870:                                key += 30;
        !           871: #   endif
        !           872: #  endif
        !           873: # endif
        !           874:                        if (FKEY[key])
        !           875:                                mapkey(FKEY[key], mapto, bang ? WHEN_VIINP|WHEN_VIREP : WHEN_VICMD, fnames[key]);
        !           876: #if !COHERENT
        !           877:                        else
        !           878:                                msg("This terminal has no %s key", fnames[key]);
        !           879: #endif
        !           880:                }
        !           881:                else
        !           882: #endif
        !           883: #ifndef NO_ABBR
        !           884:                if (cmd == CMD_ABBR || cmd == CMD_UNABBR)
        !           885:                {
        !           886:                        mapkey(extra, mapto, bang ? WHEN_EX|WHEN_VIINP|WHEN_VIREP : WHEN_VIINP|WHEN_VIREP, "abbr");
        !           887:                }
        !           888:                else
        !           889: #endif
        !           890:                {
        !           891:                        mapkey(extra, mapto, bang ? WHEN_VIINP|WHEN_VIREP : WHEN_VICMD, (char *)0);
        !           892:                }
        !           893:        }
        !           894: }
        !           895: 
        !           896: 
        !           897: /*ARGSUSED*/
        !           898: void cmd_set(frommark, tomark, cmd, bang, extra)
        !           899:        MARK    frommark, tomark;
        !           900:        CMD     cmd;
        !           901:        int     bang;
        !           902:        char    *extra;
        !           903: {
        !           904:        if (!*extra)
        !           905:        {
        !           906:                dumpopts(FALSE);/* "FALSE" means "don't dump all" - only set */
        !           907:        }
        !           908:        else if (!strcmp(extra, "all"))
        !           909:        {
        !           910:                dumpopts(TRUE); /* "TRUE" means "dump all" - even unset vars */
        !           911:        }
        !           912:        else
        !           913:        {
        !           914:                setopts(extra);
        !           915: 
        !           916:                /* That option may have affected the appearence of text */
        !           917:                changes++;
        !           918:        }
        !           919: }
        !           920: 
        !           921: /*ARGSUSED*/
        !           922: void cmd_tag(frommark, tomark, cmd, bang, extra)
        !           923:        MARK    frommark, tomark;
        !           924:        CMD     cmd;
        !           925:        int     bang;
        !           926:        char    *extra;
        !           927: {
        !           928:        int     fd;     /* file descriptor used to read the file */
        !           929:        char    *scan;  /* used to scan through the tmpblk.c */
        !           930: #ifdef INTERNAL_TAGS
        !           931:        char    *cmp;   /* char of tag name we're comparing, or NULL */
        !           932:        char    *end;   /* marks the end of chars in tmpblk.c */
        !           933: #else
        !           934:        int     i;
        !           935: #endif
        !           936: #ifndef NO_MAGIC
        !           937:        char    wasmagic; /* preserves the original state of o_magic */
        !           938: #endif
        !           939:        static char prevtag[30];
        !           940: 
        !           941:        /* if no tag is given, use the previous tag */
        !           942:        if (!extra || !*extra)
        !           943:        {
        !           944:                if (!*prevtag)
        !           945:                {
        !           946:                        msg("No previous tag");
        !           947:                        return;
        !           948:                }
        !           949:                extra = prevtag;
        !           950:        }
        !           951:        else
        !           952:        {
        !           953:                strncpy(prevtag, extra, sizeof prevtag);
        !           954:                prevtag[sizeof prevtag - 1] = '\0';
        !           955:        }
        !           956: 
        !           957: #ifndef INTERNAL_TAGS
        !           958:        /* use "ref" to look up the tag info for this tag */
        !           959:        sprintf(tmpblk.c, "ref -t %s%s %s", (*origname ? "-f" : ""),origname, prevtag);
        !           960:        fd = rpipe(tmpblk.c, 0);
        !           961:        if (fd < 0)
        !           962:        {
        !           963:                msg("Can't run \"%s\"", tmpblk.c);
        !           964:                return;
        !           965:        }
        !           966: 
        !           967:        /* try to read the tag info */
        !           968:        for (scan = tmpblk.c;
        !           969:             (i = tread(fd, scan, scan - tmpblk.c + BLKSIZE)) > 0;
        !           970:             scan += i)
        !           971:        {
        !           972:        }
        !           973:        *scan = '\0';
        !           974: 
        !           975:        /* close the pipe.  abort if error */
        !           976:        if (rpclose(fd) != 0 || scan < tmpblk.c + 3)
        !           977:        {
        !           978:                msg("tag \"%s\" not found", extra);
        !           979:                return;
        !           980:        }
        !           981: 
        !           982: #else /* use internal code to look up the tag */
        !           983:        /* open the tags file */
        !           984:        fd = open(TAGS, O_RDONLY);
        !           985:        if (fd < 0)
        !           986:        {
        !           987:                msg("No tags file");
        !           988:                return;
        !           989:        }
        !           990: 
        !           991:        /* Hmmm... this would have been a lot easier with <stdio.h> */
        !           992: 
        !           993:        /* find the line with our tag in it */
        !           994:        for(scan = end = tmpblk.c, cmp = extra; ; scan++)
        !           995:        {
        !           996:                /* read a block, if necessary */
        !           997:                if (scan >= end)
        !           998:                {
        !           999:                        end = tmpblk.c + tread(fd, tmpblk.c, BLKSIZE);
        !          1000:                        scan = tmpblk.c;
        !          1001:                        if (scan >= end)
        !          1002:                        {
        !          1003:                                msg("tag \"%s\" not found", extra);
        !          1004:                                close(fd);
        !          1005:                                return;
        !          1006:                        }
        !          1007:                }
        !          1008: 
        !          1009:                /* if we're comparing, compare... */
        !          1010:                if (cmp)
        !          1011:                {
        !          1012:                        /* matched??? wow! */
        !          1013:                        if (!*cmp && *scan == '\t')
        !          1014:                        {
        !          1015:                                break;
        !          1016:                        }
        !          1017:                        if (*cmp++ != *scan)
        !          1018:                        {
        !          1019:                                /* failed! skip to newline */
        !          1020:                                cmp = (char *)0;
        !          1021:                        }
        !          1022:                }
        !          1023: 
        !          1024:                /* if we're skipping to newline, do it fast! */
        !          1025:                if (!cmp)
        !          1026:                {
        !          1027:                        while (scan < end && *scan != '\n')
        !          1028:                        {
        !          1029:                                scan++;
        !          1030:                        }
        !          1031:                        if (scan < end)
        !          1032:                        {
        !          1033:                                cmp = extra;
        !          1034:                        }
        !          1035:                }
        !          1036:        }
        !          1037: 
        !          1038:        /* found it! get the rest of the line into memory */
        !          1039:        for (cmp = tmpblk.c, scan++; scan < end && *scan != '\n'; )
        !          1040:        {
        !          1041:                *cmp++ = *scan++;
        !          1042:        }
        !          1043:        if (scan == end)
        !          1044:        {
        !          1045:                tread(fd, cmp, BLKSIZE - (int)(cmp - tmpblk.c));
        !          1046:        }
        !          1047:        else
        !          1048:                *cmp = *scan;
        !          1049: 
        !          1050:        /* we can close the tags file now */
        !          1051:        close(fd);
        !          1052: #endif /* INTERNAL_TAGS */
        !          1053: 
        !          1054:        /* extract the filename from the line, and edit the file */
        !          1055:        for (scan = tmpblk.c; *scan != '\t'; scan++)
        !          1056:        {
        !          1057:        }
        !          1058:        *scan++ = '\0';
        !          1059:        if (strcmp(origname, tmpblk.c) != 0)
        !          1060:        {
        !          1061:                if (!tmpabort(bang))
        !          1062:                {
        !          1063:                        msg("Use :tag! to abort changes, or :w to save changes");
        !          1064:                        return;
        !          1065:                }
        !          1066:                tmpstart(tmpblk.c);
        !          1067:        }
        !          1068: 
        !          1069:        /* move to the desired line (or to line 1 if that fails) */
        !          1070: #ifndef NO_MAGIC
        !          1071:        wasmagic = *o_magic;
        !          1072:        *o_magic = FALSE;
        !          1073: #endif
        !          1074:        cursor = MARK_FIRST;
        !          1075:        linespec(scan, &cursor);
        !          1076:        if (cursor == MARK_UNSET)
        !          1077:        {
        !          1078:                cursor = MARK_FIRST;
        !          1079:                msg("Tag's address is out of date");
        !          1080:        }
        !          1081: #ifndef NO_MAGIC
        !          1082:        *o_magic = wasmagic;
        !          1083: #endif
        !          1084: }
        !          1085: 
        !          1086: 
        !          1087: 
        !          1088: 
        !          1089: 
        !          1090: /* describe this version of the program */
        !          1091: /*ARGSUSED*/
        !          1092: void cmd_version(frommark, tomark, cmd, bang, extra)
        !          1093:        MARK    frommark;
        !          1094:        MARK    tomark;
        !          1095:        CMD     cmd;
        !          1096:        int     bang;
        !          1097:        char    *extra;
        !          1098: {
        !          1099:        msg("%s", VERSION);
        !          1100: #ifdef CREDIT
        !          1101:        msg("%s", CREDIT);
        !          1102: #endif
        !          1103: #ifdef CREDIT2
        !          1104:        msg("%s", CREDIT2);
        !          1105: #endif
        !          1106: #ifdef COMPILED_BY
        !          1107:        msg("Compiled by %s", COMPILED_BY);
        !          1108: #endif
        !          1109: #ifdef COPYING
        !          1110:        msg("%s", COPYING);
        !          1111: #endif
        !          1112: }
        !          1113: 
        !          1114: 
        !          1115: #ifndef NO_MKEXRC
        !          1116: /* make a .exrc file which describes the current configuration */
        !          1117: /*ARGSUSED*/
        !          1118: void cmd_mkexrc(frommark, tomark, cmd, bang, extra)
        !          1119:        MARK    frommark;
        !          1120:        MARK    tomark;
        !          1121:        CMD     cmd;
        !          1122:        int     bang;
        !          1123:        char    *extra;
        !          1124: {
        !          1125:        int     fd;
        !          1126: 
        !          1127:        /* the default name for the .exrc file EXRC */
        !          1128:        if (!*extra)
        !          1129:        {
        !          1130:                extra = EXRC;
        !          1131:        }
        !          1132: 
        !          1133:        /* create the .exrc file */
        !          1134:        fd = creat(extra, FILEPERMS);
        !          1135:        if (fd < 0)
        !          1136:        {
        !          1137:                msg("Couldn't create a new \"%s\" file", extra);
        !          1138:                return;
        !          1139:        }
        !          1140: 
        !          1141:        /* save stuff */
        !          1142:        saveopts(fd);
        !          1143:        savemaps(fd, FALSE);
        !          1144: #ifndef NO_ABBR
        !          1145:        savemaps(fd, TRUE);
        !          1146: #endif
        !          1147: #ifndef NO_DIGRAPH
        !          1148:        savedigs(fd);
        !          1149: #endif
        !          1150: #ifndef NO_COLOR
        !          1151:        savecolor(fd);
        !          1152: #endif
        !          1153: 
        !          1154:        /* close the file */
        !          1155:        close(fd);
        !          1156:        msg("Configuration saved");
        !          1157: }
        !          1158: #endif
        !          1159: 
        !          1160: #ifndef NO_DIGRAPH
        !          1161: /*ARGSUSED*/
        !          1162: void cmd_digraph(frommark, tomark, cmd, bang, extra)
        !          1163:        MARK    frommark;
        !          1164:        MARK    tomark;
        !          1165:        CMD     cmd;
        !          1166:        int     bang;
        !          1167:        char    *extra;
        !          1168: {
        !          1169:        do_digraph(bang, extra);
        !          1170: }
        !          1171: #endif
        !          1172: 
        !          1173: 
        !          1174: #ifndef NO_ERRLIST 
        !          1175: static char    errfile[256];   /* the name of a file containing an error */
        !          1176: static long    errline;        /* the line number for an error */
        !          1177: static int     errfd = -2;     /* fd of the errlist file */
        !          1178: 
        !          1179: /* This static function tries to parse an error message.
        !          1180:  *
        !          1181:  * For most compilers, the first word is taken to be the name of the erroneous
        !          1182:  * file, and the first number after that is taken to be the line number where
        !          1183:  * the error was detected.  The description of the error follows, possibly
        !          1184:  * preceded by an "error ... :" or "warning ... :" label which is skipped.
        !          1185:  *
        !          1186:  * For Coherent, error messages look like "line#: filename: message".
        !          1187:  *
        !          1188:  * For non-error lines, or unparsable error lines, this function returns NULL.
        !          1189:  * Normally, though, it alters errfile and errline, and returns a pointer to
        !          1190:  * the description.
        !          1191:  */
        !          1192: static char *parse_errmsg(text)
        !          1193:        REG char        *text;
        !          1194: {
        !          1195:        REG char        *cpy;
        !          1196:        long            atol();
        !          1197: # if COHERENT || TOS /* any Mark Williams compiler */
        !          1198:        /* Get the line number.  If no line number, then ignore this line. */
        !          1199:        errline = atol(text);
        !          1200:        if (errline == 0L)
        !          1201:                return (char *)0;
        !          1202: 
        !          1203:        /* Skip to the start of the filename */
        !          1204:        while (*text && *text++ != ':')
        !          1205:        {
        !          1206:        }
        !          1207:        if (!*text++)
        !          1208:                return (char *)0;
        !          1209: 
        !          1210:        /* copy the filename to errfile */
        !          1211:        for (cpy = errfile; *text && (*cpy++ = *text++) != ':'; )
        !          1212:        {
        !          1213:        }
        !          1214:        if (!*text++)
        !          1215:                return (char *)0;
        !          1216:        cpy[-1] = '\0';
        !          1217: 
        !          1218:        return text;
        !          1219: # else /* not a Mark Williams compiler */
        !          1220:        char            *errmsg;
        !          1221: 
        !          1222:        /* the error message is the whole line, by default */
        !          1223:        errmsg = text;
        !          1224: 
        !          1225:        /* skip leading garbage */
        !          1226:        while (*text && !isalnum(*text))
        !          1227:        {
        !          1228:                text++;
        !          1229:        }
        !          1230: 
        !          1231:        /* copy over the filename */
        !          1232:        cpy = errfile;
        !          1233:        while(isalnum(*text) || *text == '.')
        !          1234:        {
        !          1235:                *cpy++ = *text++;
        !          1236:        }
        !          1237:        *cpy = '\0';
        !          1238: 
        !          1239:        /* ignore the name "Error" and filenames that contain a '/' */
        !          1240:        if (*text == '/' || !*errfile || !strcmp(errfile + 1, "rror") || access(errfile, 0) < 0)
        !          1241:        {
        !          1242:                return (char *)0;
        !          1243:        }
        !          1244: 
        !          1245:        /* skip garbage between filename and line number */
        !          1246:        while (*text && !isdigit(*text))
        !          1247:        {
        !          1248:                text++;
        !          1249:        }
        !          1250: 
        !          1251:        /* if the number is part of a larger word, then ignore this line */
        !          1252:        if (*text && isalpha(text[-1]))
        !          1253:        {
        !          1254:                return (char *)0;
        !          1255:        }
        !          1256: 
        !          1257:        /* get the error line */
        !          1258:        errline = 0L;
        !          1259:        while (isdigit(*text))
        !          1260:        {
        !          1261:                errline *= 10;
        !          1262:                errline += (*text - '0');
        !          1263:                text++;
        !          1264:        }
        !          1265: 
        !          1266:        /* any line which lacks a filename or line number should be ignored */
        !          1267:        if (!errfile[0] || !errline)
        !          1268:        {
        !          1269:                return (char *)0;
        !          1270:        }
        !          1271: 
        !          1272:        /* locate the beginning of the error description */
        !          1273:        while (*text && !isspace(*text))
        !          1274:        {
        !          1275:                text++;
        !          1276:        }
        !          1277:        while (*text)
        !          1278:        {
        !          1279: #  ifndef CRUNCH
        !          1280:                /* skip "error #:" and "warning #:" clauses */
        !          1281:                if (!strncmp(text + 1, "rror ", 5)
        !          1282:                 || !strncmp(text + 1, "arning ", 7)
        !          1283:                 || !strncmp(text + 1, "atal error", 10))
        !          1284:                {
        !          1285:                        do
        !          1286:                        {
        !          1287:                                text++;
        !          1288:                        } while (*text && *text != ':');
        !          1289:                        continue;
        !          1290:                }
        !          1291: #  endif
        !          1292: 
        !          1293:                /* anything other than whitespace or a colon is important */
        !          1294:                if (!isspace(*text) && *text != ':')
        !          1295:                {
        !          1296:                        errmsg = text;
        !          1297:                        break;
        !          1298:                }
        !          1299: 
        !          1300:                /* else keep looking... */
        !          1301:                text++;
        !          1302:        }
        !          1303: 
        !          1304:        return errmsg;
        !          1305: # endif /* not COHERENT */
        !          1306: }
        !          1307: 
        !          1308: /*ARGSUSED*/
        !          1309: void cmd_errlist(frommark, tomark, cmd, bang, extra)
        !          1310:        MARK    frommark, tomark;
        !          1311:        CMD     cmd;
        !          1312:        int     bang;
        !          1313:        char    *extra;
        !          1314: {
        !          1315:        static long     endline;/* original number of lines in this file */
        !          1316:        static long     offset; /* offset of the next line in the errlist file */
        !          1317:        int             i;
        !          1318:        char            *errmsg;
        !          1319: 
        !          1320:        /* if a new errlist file is named, open it */
        !          1321:        if (extra && extra[0])
        !          1322:        {
        !          1323:                /* close the old one */
        !          1324:                if (errfd >= 0)
        !          1325:                {
        !          1326:                        close(errfd);
        !          1327:                }
        !          1328: 
        !          1329:                /* open the new one */
        !          1330:                errfd = open(extra, O_RDONLY);
        !          1331:                offset = 0L;
        !          1332:                endline = nlines;
        !          1333:        }
        !          1334:        else if (errfd < 0)
        !          1335:        {
        !          1336:                /* open the default file */
        !          1337:                errfd = open(ERRLIST, O_RDONLY);
        !          1338:                offset = 0L;
        !          1339:                endline = nlines;
        !          1340:        }
        !          1341: 
        !          1342:        /* do we have an errlist file now? */
        !          1343:        if (errfd < 0)
        !          1344:        {
        !          1345:                msg("There is no errlist file");
        !          1346:                beep();
        !          1347:                return;
        !          1348:        }
        !          1349: 
        !          1350:        /* find the next error message in the file */
        !          1351:        do
        !          1352:        {
        !          1353:                /* read the next line from the errlist */
        !          1354:                lseek(errfd, offset, 0);
        !          1355:                if (tread(errfd, tmpblk.c, (unsigned)BLKSIZE) <= 0)
        !          1356:                {
        !          1357:                        msg("No more errors");
        !          1358:                        beep();
        !          1359:                        close(errfd);
        !          1360:                        errfd = -2;
        !          1361:                        return;
        !          1362:                }
        !          1363:                for (i = 0; tmpblk.c[i] != '\n'; i++)
        !          1364:                {
        !          1365:                }
        !          1366:                tmpblk.c[i++] = 0;
        !          1367: 
        !          1368:                /* look for an error message in the line */
        !          1369:                errmsg = parse_errmsg(tmpblk.c);
        !          1370:                if (!errmsg)
        !          1371:                {
        !          1372:                        offset += i;
        !          1373:                }
        !          1374: 
        !          1375:        } while (!errmsg);
        !          1376: 
        !          1377:        /* switch to the file containing the error, if this isn't it */
        !          1378:        if (strcmp(origname, errfile))
        !          1379:        {
        !          1380:                if (!tmpabort(bang))
        !          1381:                {
        !          1382:                        msg("Use :er! to abort changes, or :w to save changes");
        !          1383:                        beep();
        !          1384:                        return;
        !          1385:                }
        !          1386:                tmpstart(errfile);
        !          1387:                endline = nlines;
        !          1388:        }
        !          1389:        else if (endline == 0L)
        !          1390:        {
        !          1391:                endline = nlines;
        !          1392:        }
        !          1393: 
        !          1394:        /* go to the line where the error was detected */
        !          1395:        cursor = MARK_AT_LINE(errline + (nlines - endline));
        !          1396:        if (cursor > MARK_LAST)
        !          1397:        {
        !          1398:                cursor = MARK_LAST;
        !          1399:        }
        !          1400:        if (mode == MODE_VI)
        !          1401:        {
        !          1402:                redraw(cursor, FALSE);
        !          1403:        }
        !          1404: 
        !          1405:        /* display the error message */
        !          1406: #ifdef CRUNCH
        !          1407:        msg("%.70s", errmsg);
        !          1408: #else
        !          1409:        if (nlines > endline)
        !          1410:        {
        !          1411:                msg("line %ld(+%ld): %.60s", errline, nlines - endline, errmsg);
        !          1412:        }
        !          1413:        else if (nlines < endline)
        !          1414:        {
        !          1415:                msg("line %ld(-%ld): %.60s", errline, endline - nlines, errmsg);
        !          1416:        }
        !          1417:        else
        !          1418:        {
        !          1419:                msg("line %ld: %.65s", errline, errmsg);
        !          1420:        }
        !          1421: #endif
        !          1422: 
        !          1423:        /* remember where the NEXT error line will start */
        !          1424:        offset += i;
        !          1425: }
        !          1426: 
        !          1427: 
        !          1428: /*ARGSUSED*/
        !          1429: void cmd_make(frommark, tomark, cmd, bang, extra)
        !          1430:        MARK    frommark, tomark;
        !          1431:        CMD     cmd;
        !          1432:        int     bang;
        !          1433:        char    *extra;
        !          1434: {
        !          1435:        BLK     buf;
        !          1436: 
        !          1437:        /* if the file hasn't been saved, then complain unless ! */
        !          1438:        if (tstflag(file, MODIFIED) && !bang)
        !          1439:        {
        !          1440:                msg("\"%s\" not saved yet", origname);
        !          1441:                return;
        !          1442:        }
        !          1443: 
        !          1444:        /* build the command */
        !          1445:        sprintf(buf.c, "%s %s %s%s", (cmd == CMD_CC ? o_cc : o_make), extra, REDIRECT, ERRLIST);
        !          1446:        qaddstr(buf.c);
        !          1447:        addch('\n');
        !          1448: 
        !          1449:        /* close the old errlist file, if any */
        !          1450:        if (errfd >= 0)
        !          1451:        {
        !          1452:                close(errfd);
        !          1453:                errfd = -3;
        !          1454:        }
        !          1455: 
        !          1456:        /* run the command, with curses temporarily disabled */
        !          1457:        suspend_curses();
        !          1458:        system(buf.c);
        !          1459:        resume_curses(mode == MODE_EX);
        !          1460:        if (mode == MODE_COLON)
        !          1461:                mode = MODE_VI;
        !          1462: 
        !          1463:        /* run the "errlist" command */
        !          1464:        cmd_errlist(MARK_UNSET, MARK_UNSET, cmd, bang, ERRLIST);
        !          1465: }
        !          1466: #endif
        !          1467: 
        !          1468: 
        !          1469: 
        !          1470: #ifndef NO_COLOR
        !          1471: 
        !          1472: /* figure out the number of text colors we use with this configuration */
        !          1473: # ifndef NO_POPUP
        !          1474: #  ifndef NO_VISIBLE
        !          1475: #   define NCOLORS 7
        !          1476: #  else
        !          1477: #   define NCOLORS 6
        !          1478: #  endif
        !          1479: # else
        !          1480: #  ifndef NO_VISIBLE
        !          1481: #   define NCOLORS 6
        !          1482: #  else
        !          1483: #   define NCOLORS 5
        !          1484: #  endif
        !          1485: # endif
        !          1486: 
        !          1487: /* the attribute bytes used in each of "when"s */
        !          1488: static char bytes[NCOLORS];
        !          1489: 
        !          1490: static struct
        !          1491: {
        !          1492:        char    *word;  /* a legal word */
        !          1493:        int     type;   /* what type of word this is */
        !          1494:        int     val;    /* some other value */
        !          1495: }
        !          1496:        words[] =
        !          1497: {
        !          1498:        {"normal",      1,      A_NORMAL},      /* all "when" names must come */
        !          1499:        {"standout",    1,      A_STANDOUT},    /* at the top of the list.    */
        !          1500:        {"bold",        1,      A_BOLD},        /* The first 3 must be normal,*/
        !          1501:        {"underlined",  1,      A_UNDERLINE},   /* standout, and bold; the    */
        !          1502:        {"italics",     1,      A_ALTCHARSET},  /* remaining names follow.    */
        !          1503: #ifndef NO_POPUP
        !          1504:        {"popup",       1,      A_POPUP},
        !          1505: #endif
        !          1506: #ifndef NO_VISIBLE
        !          1507:        {"visible",     1,      A_VISIBLE},
        !          1508: #endif
        !          1509: 
        !          1510:        {"black",       3,      0x00},          /* The color names start right*/
        !          1511:        {"blue",        3,      0x01},          /* after the "when" names.    */
        !          1512:        {"green",       3,      0x02},
        !          1513:        {"cyan",        3,      0x03},
        !          1514:        {"red",         3,      0x04},
        !          1515:        {"magenta",     3,      0x05},
        !          1516:        {"brown",       3,      0x06},
        !          1517:        {"white",       3,      0x07},
        !          1518:        {"yellow",      3,      0x0E}, /* bright brown */
        !          1519:        {"gray",        3,      0x08}, /* bright black?  of course! */
        !          1520:        {"grey",        3,      0x08},
        !          1521: 
        !          1522:        {"bright",      2,      0x08},
        !          1523:        {"light",       2,      0x08},
        !          1524:        {"blinking",    2,      0x80},
        !          1525:        {"on",          0,      0},
        !          1526:        {"n",           1,      A_NORMAL},
        !          1527:        {"s",           1,      A_STANDOUT},
        !          1528:        {"b",           1,      A_BOLD},
        !          1529:        {"u",           1,      A_UNDERLINE},
        !          1530:        {"i",           1,      A_ALTCHARSET},
        !          1531: #ifndef NO_POPUP
        !          1532:        {"p",           1,      A_POPUP},
        !          1533:        {"menu",        1,      A_POPUP},
        !          1534: #endif
        !          1535: #ifndef NO_VISIBLE
        !          1536:        {"v",           1,      A_VISIBLE},
        !          1537: #endif
        !          1538:        {(char *)0,     0,      0}
        !          1539: };
        !          1540: 
        !          1541: /*ARGSUSED*/
        !          1542: void cmd_color(frommark, tomark, cmd, bang, extra)
        !          1543:        MARK    frommark, tomark;
        !          1544:        CMD     cmd;
        !          1545:        int     bang;
        !          1546:        char    *extra;
        !          1547: {
        !          1548:        int     attrbyte;
        !          1549:        int     cmode;
        !          1550:        int     nowbg;  /* BOOLEAN: is the next color background? */
        !          1551: 
        !          1552:        REG char *scan;
        !          1553:        REG     i;
        !          1554: 
        !          1555: 
        !          1556: #ifndef CRUNCH
        !          1557:        /* if no args are given, then report the current colors */
        !          1558:        if (!*extra)
        !          1559:        {
        !          1560:                /* if no colors are set, then say so */
        !          1561:                if (!bytes[0])
        !          1562:                {
        !          1563:                        msg("no colors have been set");
        !          1564:                        return;
        !          1565:                }
        !          1566: 
        !          1567:                /* report all five color combinations */
        !          1568:                for (i = 0; i < NCOLORS; i++)
        !          1569:                {
        !          1570:                        qaddstr("color ");
        !          1571:                        qaddstr(words[i].word);
        !          1572:                        qaddch(' ');
        !          1573:                        if (bytes[i] & 0x80)
        !          1574:                                qaddstr("blinking ");
        !          1575:                        switch (bytes[i] & 0xf)
        !          1576:                        {
        !          1577:                          case 0x08:    qaddstr("gray");        break;
        !          1578:                          case 0x0e:    qaddstr("yellow");      break;
        !          1579:                          case 0x0f:    qaddstr("bright white");break;
        !          1580:                          default:
        !          1581:                                if (bytes[i] & 0x08)
        !          1582:                                        qaddstr("light ");
        !          1583:                                qaddstr(words[(bytes[i] & 0x07) + NCOLORS].word);
        !          1584:                        }
        !          1585:                        qaddstr(" on ");
        !          1586:                        qaddstr(words[((bytes[i] >> 4) & 0x07) + NCOLORS].word);
        !          1587:                        addch('\n');
        !          1588:                        exrefresh();
        !          1589:                }
        !          1590:                return;
        !          1591:        }
        !          1592: #endif
        !          1593: 
        !          1594:        /* The default background color is the same as "normal" chars.
        !          1595:         * There is no default foreground color.
        !          1596:         */
        !          1597:        cmode = A_NORMAL;
        !          1598:        attrbyte = bytes[0] & 0x70;
        !          1599:        nowbg = FALSE;
        !          1600: 
        !          1601:        /* parse each word in the "extra" text */
        !          1602:        for (scan = extra; *extra; extra = scan)
        !          1603:        {
        !          1604:                /* locate the end of the word */
        !          1605:                while (*scan && *scan != ' ')
        !          1606:                {
        !          1607:                        scan++;
        !          1608:                }
        !          1609: 
        !          1610:                /* skip whitespace at the end of the word */
        !          1611:                while(*scan == ' ')
        !          1612:                {
        !          1613:                        *scan++ = '\0';
        !          1614:                }
        !          1615: 
        !          1616:                /* lookup the word */
        !          1617:                for (i = 0; words[i].word && strcmp(words[i].word, extra); i++)
        !          1618:                {
        !          1619:                }
        !          1620: 
        !          1621:                /* if not a word, then complain */
        !          1622:                if (!words[i].word)
        !          1623:                {
        !          1624:                        msg("Invalid color name: %s", extra);
        !          1625:                        return;
        !          1626:                }
        !          1627: 
        !          1628:                /* process the word */
        !          1629:                switch (words[i].type)
        !          1630:                {
        !          1631:                  case 1:
        !          1632:                        cmode = words[i].val;
        !          1633:                        break;
        !          1634: 
        !          1635:                  case 2:
        !          1636:                        attrbyte |= words[i].val;
        !          1637:                        break;
        !          1638: 
        !          1639:                  case 3:
        !          1640:                        if (nowbg)
        !          1641:                                attrbyte = ((attrbyte & ~0x70) | ((words[i].val & 0x07) << 4));
        !          1642:                        else
        !          1643:                                attrbyte |= words[i].val;
        !          1644:                        nowbg = TRUE;
        !          1645:                        break;
        !          1646:                }
        !          1647:        }
        !          1648: 
        !          1649:        /* if nowbg isn't set now, then we were never given a foreground color */
        !          1650:        if (!nowbg)
        !          1651:        {
        !          1652:                msg("usage: color [when] [\"bright\"] [\"blinking\"] foreground [background]");
        !          1653:                return;
        !          1654:        }
        !          1655: 
        !          1656:        /* the first ":color" command MUST define the "normal" colors */
        !          1657:        if (!bytes[0])
        !          1658:                cmode = A_NORMAL;
        !          1659: 
        !          1660:        /* we should now have a cmode and an attribute byte... */
        !          1661: 
        !          1662:        /* set the color */
        !          1663:        setcolor(cmode, attrbyte);
        !          1664: 
        !          1665:        /* remember what we just did */
        !          1666:        bytes[cmode] = attrbyte;
        !          1667: 
        !          1668:        /* if the other colors haven't been set yet, then set them to defaults */
        !          1669:        if (!bytes[1])
        !          1670:        {
        !          1671:                /* standout is the opposite of normal */
        !          1672:                bytes[1] = ((attrbyte << 4) & 0x70 | (attrbyte >> 4) & 0x07);
        !          1673:                setcolor(A_STANDOUT, bytes[1]);
        !          1674: 
        !          1675:                /* if "normal" isn't bright, then bold defaults to normal+bright
        !          1676:                 * else bold defaults to bright white.
        !          1677:                 */
        !          1678:                bytes[2] = attrbyte | ((attrbyte & 0x08) ? 0x0f : 0x08);
        !          1679:                setcolor(A_BOLD, bytes[2]);
        !          1680: 
        !          1681:                /* all others default to the "standout" colors, without blinking */
        !          1682:                for (i = 3; i < NCOLORS; i++)
        !          1683:                {
        !          1684:                        bytes[i] = (bytes[1] & 0x7f);
        !          1685:                        setcolor(words[i].val, bytes[i]);
        !          1686:                }
        !          1687:        }
        !          1688: 
        !          1689:        /* force a redraw, so we see the new colors */
        !          1690:        redraw(MARK_UNSET, FALSE);
        !          1691: }
        !          1692: 
        !          1693: 
        !          1694: 
        !          1695: void savecolor(fd)
        !          1696:        int     fd;     /* file descriptor to write colors to */
        !          1697: {
        !          1698:        int     i;
        !          1699:        char    buf[80];
        !          1700: 
        !          1701:        /* if no colors are set, then return */
        !          1702:        if (!bytes[0])
        !          1703:        {
        !          1704:                return;
        !          1705:        }
        !          1706: 
        !          1707:        /* save all five color combinations */
        !          1708:        for (i = 0; i < NCOLORS; i++)
        !          1709:        {
        !          1710:                strcpy(buf, "color ");
        !          1711:                strcat(buf, words[i].word);
        !          1712:                strcat(buf, " ");
        !          1713:                if (bytes[i] & 0x80)
        !          1714:                        strcat(buf, "blinking ");
        !          1715:                switch (bytes[i] & 0xf)
        !          1716:                {
        !          1717:                  case 0x08:    strcat(buf, "gray");    break;
        !          1718:                  case 0x0e:    strcat(buf, "yellow");  break;
        !          1719:                  case 0x0f:    strcat(buf, "bright white");break;
        !          1720:                  default:
        !          1721:                        if (bytes[i] & 0x08)
        !          1722:                                strcat(buf, "light ");
        !          1723:                        strcat(buf, words[(bytes[i] & 0x07) + NCOLORS].word);
        !          1724:                }
        !          1725:                strcat(buf, " on ");
        !          1726:                strcat(buf, words[((bytes[i] >> 4) & 0x07) + NCOLORS].word);
        !          1727:                strcat(buf, "\n");
        !          1728:                twrite(fd, buf, (unsigned)strlen(buf));
        !          1729:        }
        !          1730: }
        !          1731: #endif
        !          1732: 
        !          1733: #ifdef SIGTSTP
        !          1734: /* temporarily suspend elvis */
        !          1735: /*ARGSUSED*/
        !          1736: void cmd_suspend(frommark, tomark, cmd, bang, extra)
        !          1737:        MARK    frommark;
        !          1738:        MARK    tomark;
        !          1739:        CMD     cmd;
        !          1740:        int     bang;
        !          1741:        char    *extra;
        !          1742: {
        !          1743:        void    (*func)();      /* stores the previous setting of SIGTSTP */
        !          1744: 
        !          1745: #if ANY_UNIX
        !          1746:        /* the Bourne shell can't handle ^Z */
        !          1747:        if (!strcmp(o_shell, "/bin/sh"))
        !          1748:        {
        !          1749:                msg("The /bin/sh shell doesn't support ^Z");
        !          1750:                return;
        !          1751:        }
        !          1752: #endif
        !          1753: 
        !          1754:        move(LINES - 1, 0);
        !          1755:        if (tstflag(file, MODIFIED))
        !          1756:        {
        !          1757:                addstr("Warning: \"");
        !          1758:                addstr(origname);
        !          1759:                addstr("\" modified but not yet saved");
        !          1760:                clrtoeol();
        !          1761:        }
        !          1762:        refresh();
        !          1763:        suspend_curses();
        !          1764:        func = signal(SIGTSTP, SIG_DFL);
        !          1765:        kill (0, SIGTSTP);
        !          1766: 
        !          1767:        /* the process stops and resumes here */
        !          1768: 
        !          1769:        signal(SIGTSTP, func);
        !          1770:        resume_curses(TRUE);
        !          1771:        if (mode == MODE_VI || mode == MODE_COLON)
        !          1772:                redraw(MARK_UNSET, FALSE);
        !          1773:        else
        !          1774:                refresh ();
        !          1775: }
        !          1776: #endif

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