Path: utzoo!utgpu!news-server.csri.toronto.edu!rutgers!ucsd!swrinde!elroy.jpl.nasa.gov!mahendo!wlbr!roger.imsd.contel.com!mh From: mh@roger.imsd.contel.com (Mike H.) Newsgroups: comp.windows.news Subject: NeWS version of elvis (the vi clone) part 9 of 9 Message-ID: <1991Jan11.022120.27876@wlbr.imsd.contel.com> Date: 11 Jan 91 02:21:20 GMT Sender: news@wlbr.imsd.contel.com (news) Distribution: comp Organization: Contel FSD, Westlake Village, CA Lines: 2075 Nntp-Posting-Host: roger.imsd.contel.com #! /bin/sh # This is a shell archive, meaning: # 1. Remove everything above the #! /bin/sh line. # 2. Save the resulting text in a file. # 3. Execute the file with /bin/sh (not csh) to create the files: # vars.c # vcmd.c # vi.c # virec.c # wildcard.c # This archive created: Thu Jan 10 17:21:11 1991 export PATH; PATH=/bin:$PATH if test -f 'vars.c' then echo shar: will not over-write existing file "'vars.c'" else cat << \SHAR_EOF > 'vars.c' /* vars.c */ /* Author: * Steve Kirkendall * 14407 SW Teal Blvd. #C * Beaverton, OR 97005 * kirkenda@cs.pdx.edu */ /* This file contains variables which weren't happy anyplace else */ #include "config.h" #include "vi.h" /*------------------------------------------------------------------------*/ /* used to remember whether the file has been modified */ struct _viflags viflags; /* used to access the tmp file */ long lnum[MAXBLKS]; long nlines; int tmpfd = -1; /* used to keep track of the current file & alternate file */ long origtime; char origname[256]; char prevorig[256]; long prevline = 1; /* used to track various places in the text */ MARK mark[NMARKS]; /* marks 'a through 'z, plus mark '' */ MARK cursor; /* the cursor position within the file */ /* which mode of the editor we're in */ int mode; /* vi mode? ex mode? quitting? */ /* used to manage the args list */ char args[BLKSIZE]; /* list of filenames to edit */ int argno; /* index of current file in args list */ int nargs; /* number of filenames in args[] */ /* dummy var, never explicitly referenced */ int bavar; /* used only in BeforeAfter macros */ /* have we made a multi-line change? */ int mustredraw; /* must we redraw the whole screen? */ /* used to detect changes that invalidate cached text/blocks */ long changes; /* incremented when file is changed */ int significant; /* boolean: was a *REAL* change made? */ /* used to support the pfetch() macro */ int plen; /* length of the line */ long pline; /* line number that len refers to */ long pchgs; /* "changes" level that len refers to */ char *ptext; /* text of previous line, if valid */ /* misc temporary storage - mostly for strings */ BLK tmpblk; /* a block used to accumulate changes */ /* screen oriented stuff */ long topline; /* file line number of top line */ int leftcol; /* column number of left col */ int physcol; /* physical column number that cursor is on */ int physrow; /* physical row number that cursor is on */ /* used to help minimize that "[Hit a key to continue]" message */ int exwrote; /* Boolean: was the last ex command wordy? */ /* This variable affects the behaviour of certain functions -- most importantly * the input function. */ int doingdot; /* boolean: are we doing the "." command? */ /* This variable affects the behaviour of the ":s" command, and it is also * used to detect & prohibit nesting of ":g" commands */ int doingglobal; /* boolean: are doing a ":g" command? */ /* These are used for reporting multi-line changes to the user */ long rptlines; /* number of lines affected by a command */ char *rptlabel; /* description of how lines were affected */ /* These store info that pertains to the shift-U command */ long U_line; /* line# of the undoable line, or 0l for none */ char U_text[BLKSIZE]; /* contents of the undoable line */ /* Bigger stack req'ed for TOS */ #if TOS long _stksize = 16384; #endif SHAR_EOF fi # end of overwriting check if test -f 'vcmd.c' then echo shar: will not over-write existing file "'vcmd.c'" else cat << \SHAR_EOF > 'vcmd.c' /* vcmd.c */ /* Author: * Steve Kirkendall * 14407 SW Teal Blvd. #C * Beaverton, OR 97005 * kirkenda@cs.pdx.edu */ /* This file contains the functions that handle VI commands */ #include "config.h" #include "vi.h" #if MSDOS #include #include #endif #if TOS #include #include #endif #if OSK # include #endif /* This function puts the editor in EX mode */ MARK v_quit() { move(LINES - 1, 0); mode = MODE_EX; return cursor; } /* This function causes the screen to be redrawn */ MARK v_redraw() { redraw(MARK_UNSET, FALSE); return cursor; } /* This function executes a single EX command, and waits for a user keystroke * before returning to the VI screen. If that keystroke is another ':', then * another EX command is read and executed. */ /*ARGSUSED*/ MARK v_1ex(m, text) MARK m; /* the current line */ char *text; /* the first command to execute */ { /* run the command. be careful about modes & output */ exwrote = (mode == MODE_COLON); doexcmd(text); exrefresh(); /* if mode is no longer MODE_VI, then we should quit right away! */ if (mode != MODE_VI && mode != MODE_COLON) return cursor; /* The command did some output. Wait for a keystoke. */ if (exwrote) { mode = MODE_VI; msg("[Hit to continue]"); if (getkey(0) == ':') { mode = MODE_COLON; addch('\n'); } else redraw(MARK_UNSET, FALSE); } return cursor; } /* This function undoes the last change */ /*ARGSUSED*/ MARK v_undo(m) MARK m; /* (ignored) */ { if (undo()) { redraw(MARK_UNSET, FALSE); } return cursor; } /* This function deletes the character(s) that the cursor is on */ MARK v_xchar(m, cnt, cmd) MARK m; /* where to start deletions */ long cnt; /* number of chars to delete */ int cmd; /* either 'x' or 'X' */ { DEFAULT(1); /* for 'X', adjust so chars are deleted *BEFORE* cursor */ if (cmd == 'X') { if (markidx(m) < cnt) return MARK_UNSET; m -= cnt; } /* make sure we don't try to delete more thars than there are */ pfetch(markline(m)); if (markidx(m + cnt) > plen) { cnt = plen - markidx(m); } if (cnt == 0L) { return MARK_UNSET; } /* do it */ ChangeText { cut(m, m + cnt); delete(m, m + cnt); } return m; } /* This function defines a mark */ /*ARGSUSED*/ MARK v_mark(m, count, key) MARK m; /* where the mark will be */ long count; /* (ignored) */ int key; /* the ASCII label of the mark */ { if (key < 'a' || key > 'z') { msg("Marks must be from a to z"); } else { mark[key - 'a'] = m; } return m; } /* This function toggles upper & lower case letters */ MARK v_ulcase(m, cnt) MARK m; /* where to make the change */ long cnt; /* number of chars to flip */ { REG char *pos; REG int i, j; static char flip[] = "aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQrRsStTuUvVwWxXyYzZ[](){}<>"; DEFAULT(1); /* fetch the current version of the line */ pfetch(markline(m)); /* for each position in the line */ for (j = 0, i = markidx(m); j < cnt && ptext[i]; j++, i++) { tmpblk.c[j] = 0; /* one of the standard chars? */ for (pos = flip; *pos && *pos != ptext[i]; pos++) { } if (*pos) { tmpblk.c[j] = flip[(int)(pos - flip) ^ 1]; } #ifndef NO_DIGRAPH else /* one of the non-standard chars? */ { for (pos = o_flipcase; *pos && *pos != ptext[i]; pos++) { } if (*pos) { tmpblk.c[j] = o_flipcase[(int)(pos - o_flipcase) ^ 1]; } } #endif /* if nothing special, then don't change it */ if (tmpblk.c[j] == 0) { tmpblk.c[j] = ptext[i]; } } /* if the new text is different from the old, then change it */ if (strncmp(tmpblk.c, &ptext[markidx(m)], j)) { ChangeText { tmpblk.c[j] = '\0'; change(m, m + j, tmpblk.c); } } return m + j; } MARK v_replace(m, cnt, key) MARK m; /* first char to be replaced */ long cnt; /* number of chars to replace */ int key; /* what to replace them with */ { REG char *text; REG int i; DEFAULT(1); /* map ^M to '\n' */ if (key == '\r') { key = '\n'; } /* make sure the resulting line isn't too long */ if (cnt > BLKSIZE - 2 - markidx(m)) { cnt = BLKSIZE - 2 - markidx(m); } /* build a string of the desired character with the desired length */ for (text = tmpblk.c, i = cnt; i > 0; i--) { *text++ = key; } *text = '\0'; /* make sure cnt doesn't extend past EOL */ pfetch(markline(m)); key = markidx(m); if (key + cnt > plen) { cnt = plen - key; } /* do the replacement */ ChangeText { change(m, m + cnt, tmpblk.c); } if (*tmpblk.c == '\n') { return (m & ~(BLKSIZE - 1)) + cnt * BLKSIZE; } else { return m + cnt - 1; } } MARK v_overtype(m) MARK m; /* where to start overtyping */ { MARK end; /* end of a substitution */ static long width; /* width of a single-line replace */ /* the "doingdot" version of replace is really a substitution */ if (doingdot) { /* was the last one really repeatable? */ if (width < 0) { msg("Can't repeat a multi-line overtype command"); return MARK_UNSET; } /* replacing nothing by nothing? Don't bother */ if (width == 0) { return m; } /* replace some chars by repeated text */ return v_subst(m, width); } /* Normally, we input starting here, in replace mode */ ChangeText { end = input(m, m, WHEN_VIREP, -1L); } /* if we ended on the same line we started on, then this * overtype is repeatable via the dot key. */ if (markline(end) == markline(m) && end >= m - 1L) { width = end - m + 1L; } else /* it isn't repeatable */ { width = -1L; } return end; } /* This function selects which cut buffer to use */ /*ARGSUSED*/ MARK v_selcut(m, cnt, key) MARK m; long cnt; int key; { cutname(key); return m; } /* This function pastes text from a cut buffer */ /*ARGSUSED*/ MARK v_paste(m, cnt, cmd) MARK m; /* where to paste the text */ long cnt; /* (ignored) */ int cmd; /* either 'p' or 'P' */ { ChangeText { m = paste(m, cmd == 'p', FALSE); } return m; } /* This function yanks text into a cut buffer */ MARK v_yank(m, n) MARK m, n; /* range of text to yank */ { cut(m, n); return m; } /* This function deletes a range of text */ MARK v_delete(m, n) MARK m, n; /* range of text to delete */ { /* illegal to try and delete nothing */ if (n <= m) { return MARK_UNSET; } /* Do it */ ChangeText { cut(m, n); delete(m, n); } return m; } /* This starts input mode without deleting anything */ MARK v_insert(m, cnt, key) MARK m; /* where to start (sort of) */ long cnt; /* repeat how many times? */ int key; /* what command is this for? {a,A,i,I,o,O} */ { int wasdot; long reps; int after; /* are we appending or inserting? */ long indentref = -1L; DEFAULT(1); ChangeText { /* tweak the insertion point, based on command key */ switch (key) { case 'i': after = FALSE; break; case 'a': pfetch(markline(m)); if (plen > 0) { m++; } after = TRUE; break; case 'I': m = m_front(m, 1L); after = FALSE; break; case 'A': pfetch(markline(m)); m = (m & ~(BLKSIZE - 1)) + plen; after = TRUE; break; case 'O': m &= ~(BLKSIZE - 1); add(m, "\n"); after = FALSE; indentref = 1L; break; case 'o': m = (m & ~(BLKSIZE - 1)) + BLKSIZE; add(m, "\n"); after = FALSE; break; } /* insert the same text once or more */ for (reps = cnt, wasdot = doingdot; reps > 0; reps--, doingdot = TRUE) { m = input(m, m, WHEN_VIINP, indentref); if (after) { m++; } } if (after) { m--; } doingdot = wasdot; } #ifndef CRUNCH # ifndef NO_EXTENSIONS if (key == 'i' && *o_inputmode && mode == MODE_VI) { msg("Now in visual command mode! To return to input mode, hit ."); } # endif #endif return m; } /* This starts input mode with some text deleted */ MARK v_change(m, n) MARK m, n; /* the range of text to change */ { int lnmode; /* is this a line-mode change? */ /* swap them if they're in reverse order */ if (m > n) { MARK tmp; tmp = m; m = n; n = tmp; } /* for line mode, retain the last newline char */ lnmode = (markidx(m) == 0 && markidx(n) == 0 && m != n); if (lnmode) { n -= BLKSIZE; pfetch(markline(n)); n = (n & ~(BLKSIZE - 1)) + plen; } ChangeText { cut(m, n); m = input(m, n, WHEN_VIINP, -1L); } return m; } /* This function replaces a given number of characters with input */ MARK v_subst(m, cnt) MARK m; /* where substitutions start */ long cnt; /* number of chars to replace */ { DEFAULT(1); /* make sure we don't try replacing past EOL */ pfetch(markline(m)); if (markidx(m) + cnt > plen) { cnt = plen - markidx(m); } /* Go for it! */ ChangeText { cut(m, m + cnt); m = input(m, m + cnt, WHEN_VIINP, -1L); } return m; } /* This calls the ex "join" command to join some lines together */ MARK v_join(m, cnt) MARK m; /* the first line to be joined */ long cnt; /* number of other lines to join */ { MARK joint; /* where the lines were joined */ DEFAULT(1); /* figure out where the joint will be */ pfetch(markline(m)); joint = (m & ~(BLKSIZE - 1)) + plen; /* join the lines */ cmd_join(m, m + MARK_AT_LINE(cnt), CMD_JOIN, 0, ""); mustredraw = TRUE; /* the cursor should be left at the joint */ return joint; } /* This calls the ex shifter command to shift some lines */ static MARK shift_help(m, n, excmd) MARK m, n; /* range of lines to shift */ CMD excmd; /* which way do we shift? */ { /* adjust for inclusive endmarks in ex */ n -= BLKSIZE; cmd_shift(m, n, excmd, 0, ""); return m; } /* This calls the ex "<" command to shift some lines left */ MARK v_lshift(m, n) MARK m, n; /* range of lines to shift */ { return shift_help(m, n, CMD_SHIFTL); } /* This calls the ex ">" command to shift some lines right */ MARK v_rshift(m, n) MARK m, n; /* range of lines to shift */ { return shift_help(m, n, CMD_SHIFTR); } /* This runs some lines through a filter program */ MARK v_filter(m, n) MARK m, n; /* range of lines to shift */ { char cmdln[100]; /* a shell command line */ /* adjust for inclusive endmarks in ex */ n -= BLKSIZE; if (vgets('!', cmdln, sizeof(cmdln)) > 0) { filter(m, n, cmdln); } redraw(MARK_UNSET, FALSE); return m; } /* This function runs the ex "file" command to show the file's status */ MARK v_status() { cmd_file(cursor, cursor, CMD_FILE, 0, ""); return cursor; } /* This function runs the ":&" command to repeat the previous :s// */ MARK v_again(m, n) MARK m, n; { cmd_substitute(m, n - BLKSIZE, CMD_SUBAGAIN, TRUE, ""); return cursor; } /* This function switches to the previous file, if possible */ MARK v_switch() { if (!*prevorig) msg("No previous file"); else { strcpy(tmpblk.c, prevorig); cmd_edit(cursor, cursor, CMD_EDIT, 0, tmpblk.c); } return cursor; } /* This function does a tag search on a keyword */ /*ARGSUSED*/ MARK v_tag(keyword, m, cnt) char *keyword; MARK m; long cnt; { /* move the cursor to the start of the tag name, where m is */ cursor = m; /* perform the tag search */ cmd_tag(cursor, cursor, CMD_TAG, 0, keyword); return cursor; } #ifndef NO_EXTENSIONS /* This function looks up a keyword by calling the helpprog program */ /*ARGSUSED*/ MARK v_keyword(keyword, m, cnt) char *keyword; MARK m; long cnt; { int waswarn; char cmdline[130]; move(LINES - 1, 0); addstr("---------------------------------------------------------\n"); clrtoeol(); refresh(); sprintf(cmdline, "%s %s", o_keywordprg, keyword); waswarn = *o_warn; *o_warn = FALSE; Suspend_curses(); if (system(cmdline)) { addstr("<<< failed >>>\n"); } Resume_curses(FALSE); mode = MODE_VI; redraw(MARK_UNSET, FALSE); *o_warn = waswarn; return m; } MARK v_increment(keyword, m, cnt) char *keyword; MARK m; long cnt; { static sign; char newval[12]; long atol(); DEFAULT(1); /* get one more keystroke, unless doingdot */ if (!doingdot) { sign = getkey(0); } /* adjust the number, based on that second keystroke */ switch (sign) { case '+': case '#': cnt = atol(keyword) + cnt; break; case '-': cnt = atol(keyword) - cnt; break; case '=': break; default: return MARK_UNSET; } sprintf(newval, "%ld", cnt); ChangeText { change(m, m + strlen(keyword), newval); } return m; } #endif /* This function acts like the EX command "xit" */ /*ARGSUSED*/ MARK v_xit(m, cnt, key) MARK m; /* ignored */ long cnt; /* ignored */ int key; /* must be a second 'Z' */ { /* if second char wasn't 'Z', fail */ if (key != 'Z') { return MARK_UNSET; } /* move the cursor to the bottom of the screen */ move(LINES - 1, 0); clrtoeol(); /* do the xit command */ cmd_xit(m, m, CMD_XIT, FALSE, ""); /* return the cursor */ return m; } /* This function undoes changes to a single line, if possible */ MARK v_undoline(m) MARK m; /* where we hope to undo the change */ { /* make sure we have the right line in the buffer */ if (markline(m) != U_line) { return MARK_UNSET; } /* fix it */ ChangeText { strcat(U_text, "\n"); change(MARK_AT_LINE(U_line), MARK_AT_LINE(U_line + 1), U_text); } /* nothing in the buffer anymore */ U_line = -1L; /* return, with the cursor at the front of the line */ return m & ~(BLKSIZE - 1); } #ifndef NO_ERRLIST MARK v_errlist(m) MARK m; { cmd_errlist(m, m, CMD_ERRLIST, FALSE, ""); return cursor; } #endif #ifndef NO_AT /*ARGSUSED*/ MARK v_at(m, cnt, key) MARK m; long cnt; int key; { if (!fromcutbuf(key)) { return MARK_UNSET; } return cursor; } #endif SHAR_EOF fi # end of overwriting check if test -f 'vi.c' then echo shar: will not over-write existing file "'vi.c'" else cat << \SHAR_EOF > 'vi.c' /* vi.c */ /* Author: * Steve Kirkendall * 14407 SW Teal Blvd. #C * Beaverton, OR 97005 * kirkenda@cs.pdx.edu */ #include "config.h" #include #include "vi.h" /* This array describes what each key does */ #define NO_FUNC (MARK (*)())0 #define NO_ARGS 0 #define CURSOR_COUNT 1 #define CURSOR 2 #define CURSOR_CNT_KEY 3 #define CURSOR_MOVED 4 #define CURSOR_EOL 5 #define ZERO 6 #define DIGIT 7 #define CURSOR_TEXT 8 #define CURSOR_CNT_CMD 9 #define KEYWORD 10 #define NO_FLAGS 0x00 #define MVMT 0x01 /* this is a movement command */ #define PTMV 0x02 /* this can be *part* of a movement command */ #define FRNT 0x04 /* after move, go to front of line */ #define INCL 0x08 /* include last char when used with c/d/y */ #define LNMD 0x10 /* use line mode of c/d/y */ #define NCOL 0x20 /* this command can't change the column# */ #define NREL 0x40 /* this is "non-relative" -- set the '' mark */ #define SDOT 0x80 /* set the "dot" variables, for the "." cmd */ static struct keystru { MARK (*func)(); /* the function to run */ uchar args; /* description of the args needed */ uchar flags; /* other stuff */ } vikeys[] = { /* NUL not defined */ {NO_FUNC, NO_ARGS, NO_FLAGS}, /* ^A not defined */ {NO_FUNC, NO_ARGS, NO_FLAGS}, /* ^B page backward */ {m_scroll, CURSOR_CNT_CMD, FRNT}, /* ^C not defined */ {NO_FUNC, NO_ARGS, NO_FLAGS}, /* ^D scroll dn 1/2page*/ {m_scroll, CURSOR_CNT_CMD, NCOL}, /* ^E scroll up */ {m_scroll, CURSOR_CNT_CMD, NCOL}, /* ^F page forward */ {m_scroll, CURSOR_CNT_CMD, FRNT}, /* ^G show file status */ {v_status, NO_ARGS, NO_FLAGS}, /* ^H move left, like h*/ {m_left, CURSOR_COUNT, MVMT}, /* ^I not defined */ {NO_FUNC, NO_ARGS, NO_FLAGS}, /* ^J move down */ {m_updnto, CURSOR_CNT_CMD, MVMT|LNMD}, /* ^K not defined */ {NO_FUNC, NO_ARGS, NO_FLAGS}, /* ^L redraw screen */ {v_redraw, NO_ARGS, NO_FLAGS}, /* ^M mv front next ln */ {m_updnto, CURSOR_CNT_CMD, MVMT|FRNT|LNMD}, /* ^N move down */ {m_updnto, CURSOR_CNT_CMD, MVMT|LNMD}, /* ^O not defined */ {NO_FUNC, NO_ARGS, NO_FLAGS}, /* ^P move up */ {m_updnto, CURSOR_CNT_CMD, MVMT|LNMD}, /* ^Q not defined */ {NO_FUNC, NO_ARGS, NO_FLAGS}, /* ^R redraw screen */ {v_redraw, NO_ARGS, NO_FLAGS}, /* ^S not defined */ {NO_FUNC, NO_ARGS, NO_FLAGS}, /* ^T not defined */ {NO_FUNC, NO_ARGS, NO_FLAGS}, /* ^U scroll up 1/2page*/ {m_scroll, CURSOR_CNT_CMD, NCOL}, /* ^V not defined */ {NO_FUNC, NO_ARGS, NO_FLAGS}, /* ^W not defined */ {NO_FUNC, NO_ARGS, NO_FLAGS}, /* ^X not defined */ {NO_FUNC, NO_ARGS, NO_FLAGS}, /* ^Y scroll down */ {m_scroll, CURSOR_CNT_CMD, NCOL}, /* ^Z not defined */ {NO_FUNC, NO_ARGS, NO_FLAGS}, /* ESC not defined */ {NO_FUNC, NO_ARGS, NO_FLAGS}, /* ^\ not defined */ {NO_FUNC, NO_ARGS, NO_FLAGS}, /* ^] keyword is tag */ {v_tag, KEYWORD, NO_FLAGS}, /* ^^ previous file */ {v_switch, CURSOR, NO_FLAGS}, /* ^_ not defined */ {NO_FUNC, NO_ARGS, NO_FLAGS}, /* SPC move right,like l*/ {m_right, CURSOR_COUNT, MVMT}, /* ! run thru filter */ {v_filter, CURSOR_MOVED, FRNT|LNMD|INCL}, /* " select cut buffer*/ {v_selcut, CURSOR_CNT_KEY, PTMV}, #ifndef NO_EXTENSIONS /* # increment number */ {v_increment, KEYWORD, SDOT}, #else /* # not defined */ {NO_FUNC, NO_ARGS, NO_FLAGS}, #endif /* $ move to rear */ {m_rear, CURSOR, MVMT|INCL}, /* % move to match */ {m_match, CURSOR, MVMT|INCL}, /* & repeat subst */ {v_again, CURSOR_MOVED, SDOT|NCOL|LNMD|INCL}, /* ' move to a mark */ {m_tomark, CURSOR_CNT_KEY, MVMT|FRNT|NREL|LNMD|INCL}, #ifndef NO_SENTENCE /* ( mv back sentence */ {m_bsentence, CURSOR_COUNT, MVMT}, /* ) mv fwd sentence */ {m_fsentence, CURSOR_COUNT, MVMT}, #else /* ( not defined */ {NO_FUNC, NO_ARGS, NO_FLAGS}, /* ) not defined */ {NO_FUNC, NO_ARGS, NO_FLAGS}, #endif #ifndef NO_ERRLIST /* * errlist */ {v_errlist, CURSOR, FRNT|NREL}, #else /* * not defined */ {NO_FUNC, NO_ARGS, NO_FLAGS}, #endif /* + mv front next ln */ {m_updnto, CURSOR_CNT_CMD, MVMT|FRNT|LNMD}, #ifndef NO_CHARSEARCH /* , reverse [fFtT] cmd*/ {m__ch, CURSOR_CNT_CMD, MVMT|INCL}, #else /* , not defined */ {NO_FUNC, NO_ARGS, NO_FLAGS}, #endif /* - mv front prev ln */ {m_updnto, CURSOR_CNT_CMD, MVMT|FRNT|LNMD}, /* . special... */ {NO_FUNC, NO_ARGS, NO_FLAGS}, /* / forward search */ {m_fsrch, CURSOR_TEXT, MVMT|NREL}, /* 0 part of count? */ {NO_FUNC, ZERO, MVMT|PTMV}, /* 1 part of count */ {NO_FUNC, DIGIT, PTMV}, /* 2 part of count */ {NO_FUNC, DIGIT, PTMV}, /* 3 part of count */ {NO_FUNC, DIGIT, PTMV}, /* 4 part of count */ {NO_FUNC, DIGIT, PTMV}, /* 5 part of count */ {NO_FUNC, DIGIT, PTMV}, /* 6 part of count */ {NO_FUNC, DIGIT, PTMV}, /* 7 part of count */ {NO_FUNC, DIGIT, PTMV}, /* 8 part of count */ {NO_FUNC, DIGIT, PTMV}, /* 9 part of count */ {NO_FUNC, DIGIT, PTMV}, /* : run single EX cmd*/ {v_1ex, CURSOR_TEXT, NO_FLAGS}, #ifndef NO_CHARSEARCH /* ; repeat [fFtT] cmd*/ {m__ch, CURSOR_CNT_CMD, MVMT|INCL}, #else /* ; not defined */ {NO_FUNC, NO_ARGS, NO_FLAGS}, #endif /* < shift text left */ {v_lshift, CURSOR_MOVED, SDOT|FRNT|LNMD|INCL}, /* = not defined */ {NO_FUNC, NO_ARGS, NO_FLAGS}, /* > shift text right */ {v_rshift, CURSOR_MOVED, SDOT|FRNT|LNMD|INCL}, /* ? backward search */ {m_bsrch, CURSOR_TEXT, MVMT|NREL}, #ifndef NO_AT /* @ execute a cutbuf */ {v_at, CURSOR_CNT_KEY, NO_FLAGS}, #else /* @ undefined */ {NO_FUNC, NO_ARGS, NO_FLAGS}, #endif /* A append at EOL */ {v_insert, CURSOR_CNT_CMD, SDOT}, /* B move back Word */ {m_bword, CURSOR_CNT_CMD, MVMT}, /* C change to EOL */ {v_change, CURSOR_EOL, SDOT}, /* D delete to EOL */ {v_delete, CURSOR_EOL, SDOT}, /* E move end of Word */ {m_eword, CURSOR_CNT_CMD, MVMT|INCL}, #ifndef NO_CHARSEARCH /* F move bk to char */ {m_Fch, CURSOR_CNT_KEY, MVMT|INCL}, #else /* F not defined */ {NO_FUNC, NO_ARGS, NO_FLAGS}, #endif /* G move to line # */ {m_updnto, CURSOR_CNT_CMD, MVMT|NREL|LNMD|FRNT|INCL}, /* H move to row */ {m_row, CURSOR_CNT_CMD, MVMT|FRNT}, /* I insert at front */ {v_insert, CURSOR_CNT_CMD, SDOT}, /* J join lines */ {v_join, CURSOR_COUNT, SDOT}, #ifndef NO_EXTENSIONS /* K look up keyword */ {v_keyword, KEYWORD, NO_FLAGS}, #else /* K not defined */ {NO_FUNC, NO_ARGS, NO_FLAGS}, #endif /* L move to last row */ {m_row, CURSOR_CNT_CMD, MVMT|FRNT}, /* M move to mid row */ {m_row, CURSOR_CNT_CMD, MVMT|FRNT}, /* N reverse prev srch*/ {m_Nsrch, CURSOR, MVMT}, /* O insert above line*/ {v_insert, CURSOR_CNT_CMD, SDOT}, /* P paste before */ {v_paste, CURSOR_CNT_CMD, NO_FLAGS}, /* Q quit to EX mode */ {v_quit, NO_ARGS, NO_FLAGS}, /* R overtype */ {v_overtype, CURSOR, SDOT}, /* S change line */ {v_change, CURSOR_MOVED, SDOT}, #ifndef NO_CHARSEARCH /* T move bk to char */ {m_Tch, CURSOR_CNT_KEY, MVMT|INCL}, #else /* T not defined */ {NO_FUNC, NO_ARGS, NO_FLAGS}, #endif /* U undo whole line */ {v_undoline, CURSOR, FRNT}, /* V not defined */ {NO_FUNC, NO_ARGS, NO_FLAGS}, /* W move forward Word*/ {m_fword, CURSOR_CNT_CMD, MVMT}, /* X delete to left */ {v_xchar, CURSOR_CNT_CMD, SDOT}, /* Y yank text */ {v_yank, CURSOR_MOVED, NCOL}, /* Z save file & exit */ {v_xit, CURSOR_CNT_KEY, NO_FLAGS}, /* [ move back section*/ {m_bsection, CURSOR_CNT_KEY, MVMT|LNMD|NREL}, /* \ not defined */ {NO_FUNC, NO_ARGS, NO_FLAGS}, /* ] move fwd section */ {m_fsection, CURSOR_CNT_KEY, MVMT|LNMD|NREL}, /* ^ move to front */ {m_front, CURSOR, MVMT}, /* _ not defined */ {NO_FUNC, NO_ARGS, NO_FLAGS}, /* ` move to mark */ {m_tomark, CURSOR_CNT_KEY, MVMT|NREL}, /* a append at cursor */ {v_insert, CURSOR_CNT_CMD, SDOT}, /* b move back word */ {m_bword, CURSOR_CNT_CMD, MVMT}, /* c change text */ {v_change, CURSOR_MOVED, SDOT}, /* d delete op */ {v_delete, CURSOR_MOVED, SDOT|NCOL}, /* e move end word */ {m_eword, CURSOR_CNT_CMD, MVMT|INCL}, #ifndef NO_CHARSEARCH /* f move fwd for char*/ {m_fch, CURSOR_CNT_KEY, MVMT|INCL}, #else /* f not defined */ {NO_FUNC, NO_ARGS, NO_FLAGS}, #endif /* g not defined */ {NO_FUNC, NO_ARGS, NO_FLAGS}, /* h move left */ {m_left, CURSOR_COUNT, MVMT}, /* i insert at cursor */ {v_insert, CURSOR_CNT_CMD, SDOT}, /* j move down */ {m_updnto, CURSOR_CNT_CMD, MVMT|NCOL|LNMD}, /* k move up */ {m_updnto, CURSOR_CNT_CMD, MVMT|NCOL|LNMD}, /* l move right */ {m_right, CURSOR_COUNT, MVMT}, /* m define a mark */ {v_mark, CURSOR_CNT_KEY, NO_FLAGS}, /* n repeat prev srch */ {m_nsrch, CURSOR, MVMT}, /* o insert below line*/ {v_insert, CURSOR_CNT_CMD, SDOT}, /* p paste after */ {v_paste, CURSOR_CNT_CMD, NO_FLAGS}, /* q not defined */ {NO_FUNC, NO_ARGS, NO_FLAGS}, /* r replace chars */ {v_replace, CURSOR_CNT_KEY, SDOT}, /* s subst N chars */ {v_subst, CURSOR_COUNT, SDOT}, #ifndef NO_CHARSEARCH /* t move fwd to char */ {m_tch, CURSOR_CNT_KEY, MVMT|INCL}, #else /* t not defined */ {NO_FUNC, NO_ARGS, NO_FLAGS}, #endif /* u undo */ {v_undo, CURSOR, NO_FLAGS}, /* v not defined */ {NO_FUNC, NO_ARGS, NO_FLAGS}, /* w move fwd word */ {m_fword, CURSOR_CNT_CMD, MVMT}, /* x delete character */ {v_xchar, CURSOR_CNT_CMD, SDOT}, /* y yank text */ {v_yank, CURSOR_MOVED, NCOL}, /* z adjust scrn row */ {m_z, CURSOR_CNT_KEY, NCOL}, /* { back paragraph */ {m_bparagraph, CURSOR_COUNT, MVMT|LNMD}, /* | move to column */ {m_tocol, CURSOR_COUNT, NREL}, /* } fwd paragraph */ {m_fparagraph, CURSOR_COUNT, MVMT|LNMD}, /* ~ upper/lowercase */ {v_ulcase, CURSOR_COUNT, SDOT}, /* DEL not defined */ {NO_FUNC, NO_ARGS, NO_FLAGS} }; void vi() { REG int key; /* keystroke from user */ long count; /* numeric argument to some functions */ REG struct keystru *keyptr;/* pointer to vikeys[] element */ MARK tcurs; /* temporary cursor */ int prevkey;/* previous key, if d/c/y//! */ MARK range; /* start of range for d/c/y//! */ char text[100]; int dotkey; /* last "key" of a change */ int dotpkey;/* last "prevkey" of a change */ int dotkey2;/* last extra "getkey()" of a change */ int dotcnt; /* last "count" of a change */ int firstkey; REG int i; /* tell the redraw() function to start from scratch */ redraw(MARK_UNSET, FALSE); #ifdef lint /* lint says that "range" might be used before it is set. This * can't really happen due to the way "range" and "prevkey" are used, * but lint doesn't know that. This line is here ONLY to keep lint * happy. */ range = 0L; #endif /* safeguard against '.' with no previous command */ dotkey = 0; /* go immediately into insert mode, if ":set inputmode" */ firstkey = 0; #ifndef NO_EXTENSIONS if (*o_inputmode) { firstkey = 'i'; } #endif /* Repeatedly handle VI commands */ for (count = 0, prevkey = '\0'; mode == MODE_VI; ) { /* if we've moved off the undoable line, then we can't undo it at all */ if (markline(cursor) != U_line) { U_line = 0L; } /* report any changes from the previous command */ if (rptlines >= *o_report) { redraw(cursor, FALSE); msg("%ld lines %s", rptlines, rptlabel); } rptlines = 0L; /* get the next command key. It must be ASCII */ if (firstkey) { key = firstkey; firstkey = 0; } else { do { key = getkey(WHEN_VICMD); } while (key < 0 || key > 127); } /* change cw and cW commands to ce and cE, respectively */ /* (Why? because the real vi does it that way!) */ if (prevkey == 'c') { if (key == 'w') key = 'e'; else if (key == 'W') key = 'E'; /* wouldn't work right at the end of a word unless we * backspace one character before doing the move. This * will fix most cases. !!! but not all. */ if (markidx(cursor) > 0 && (key == 'e' || key == 'E')) { cursor--; } } /* look up the structure describing this command */ keyptr = &vikeys[key]; /* if we're in the middle of a d/c/y//! command, reject * anything but movement or a doubled version like "dd". */ if (prevkey && key != prevkey && !(keyptr->flags & (MVMT|PTMV))) { Beep(); prevkey = 0; count = 0; continue; } /* set the "dot" variables, if we're supposed to */ if ((keyptr->flags & SDOT) || (prevkey && vikeys[prevkey].flags & SDOT)) { dotkey = key; dotpkey = prevkey; dotkey2 = '\0'; dotcnt = count; /* remember the line before any changes are made */ if (U_line != markline(cursor)) { U_line = markline(cursor); strcpy(U_text, fetchline(U_line)); } } /* if this is "." then set other vars from the "dot" vars */ if (key == '.') { key = dotkey; keyptr = &vikeys[key]; prevkey = dotpkey; if (prevkey) { range = cursor; } if (count == 0) { count = dotcnt; } doingdot = TRUE; /* remember the line before any changes are made */ if (U_line != markline(cursor)) { U_line = markline(cursor); strcpy(U_text, fetchline(U_line)); } } else { doingdot = FALSE; } /* process the key as a command */ tcurs = cursor; switch (keyptr->args) { case ZERO: if (count == 0) { tcurs = cursor & ~(BLKSIZE - 1); break; } /* else fall through & treat like other digits... */ case DIGIT: count = count * 10 + key - '0'; break; case KEYWORD: /* if not on a keyword, fail */ pfetch(markline(cursor)); key = markidx(cursor); if (isascii(ptext[key]) && !isalnum(ptext[key]) && ptext[key] != '_') { tcurs = MARK_UNSET; break; } /* find the start of the keyword */ while (key > 0 && (!isascii(ptext[key-1]) || isalnum(ptext[key - 1]) || ptext[key - 1] == '_')) { key--; } tcurs = (cursor & ~(BLKSIZE - 1)) + key; /* copy it into a buffer, and NUL-terminate it */ i = 0; do { text[i++] = ptext[key++]; } while (!isascii(ptext[key]) || isalnum(ptext[key]) || ptext[key] == '_'); text[i] = '\0'; /* call the function */ tcurs = (*keyptr->func)(text, tcurs, count); count = 0L; break; case NO_ARGS: if (keyptr->func) { (*keyptr->func)(); } else { Beep(); } count = 0L; break; case CURSOR_COUNT: tcurs = (*keyptr->func)(cursor, count); count = 0L; break; case CURSOR: tcurs = (*keyptr->func)(cursor); count = 0L; break; case CURSOR_CNT_KEY: if (doingdot) { tcurs = (*keyptr->func)(cursor, count, dotkey2); } else { /* get a key */ i = getkey(0); if (i == '\033') /* ESC */ { count = 0; tcurs = MARK_UNSET; break; /* exit from "case CURSOR_CNT_KEY" */ } else if (i == ('V' & 0x1f)) { i = getkey(0); } /* if part of an SDOT command, remember it */ if (keyptr->flags & SDOT || (prevkey && vikeys[prevkey].flags & SDOT)) { dotkey2 = i; } /* do it */ tcurs = (*keyptr->func)(cursor, count, i); } count = 0L; break; case CURSOR_MOVED: /* '&' and uppercase keys always act like doubled */ if (key == '&' || isascii(key) && isupper(key)) { prevkey = key; } if (prevkey) { /* doubling up a command */ if (!count) count = 1L; range = cursor; tcurs = range + MARK_AT_LINE(count - 1L); count = 0L; } else { prevkey = key; range = cursor; key = -1; /* so we don't think we doubled yet */ } break; case CURSOR_EOL: prevkey = key; /* a zero-length line needs special treatment */ pfetch(markline(cursor)); if (plen == 0) { /* act on a zero-length section of text */ range = tcurs = cursor; key = ' '; } else { /* act like CURSOR_MOVED with '$' movement */ range = cursor; tcurs = m_rear(cursor, 1L); key = '$'; } count = 0L; keyptr = &vikeys[key]; break; case CURSOR_TEXT: do { text[0] = key; if (vgets(key, text + 1, sizeof text - 1) >= 0) { /* reassure user that was hit */ qaddch('\r'); refresh(); /* call the function with the text */ tcurs = (*keyptr->func)(cursor, text); } else { if (exwrote || mode == MODE_COLON) { redraw(MARK_UNSET, FALSE); } mode = MODE_VI; } } while (mode == MODE_COLON); count = 0L; break; case CURSOR_CNT_CMD: tcurs = (*keyptr->func)(cursor, count, key); count = 0L; break; } /* if that command took us out of vi mode, then exit the loop * NOW, without tweaking the cursor or anything. This is very * important when mode == MODE_QUIT. */ if (mode != MODE_VI) { break; } /* now move the cursor, as appropriate */ if (keyptr->args == CURSOR_MOVED) { /* the < and > keys have FRNT, * but it shouldn't be applied yet */ tcurs = adjmove(cursor, tcurs, 0); } else { tcurs = adjmove(cursor, tcurs, (int)keyptr->flags); } /* was that the end of a d/c/y//! command? */ if (prevkey && (prevkey == key || (keyptr->flags & MVMT)) && count == 0L) { /* if the movement command failed, cancel operation */ if (tcurs == MARK_UNSET) { prevkey = 0; count = 0; continue; } /* make sure range=front and tcurs=rear. Either way, * leave cursor=range since that's where we started. */ cursor = range; if (tcurs < range) { range = tcurs; tcurs = cursor; } /* adjust for line mode & inclusion of last char/line */ i = (keyptr->flags | vikeys[prevkey].flags); if (key == prevkey) { i |= (INCL|LNMD); } switch (i & (INCL|LNMD)) { case INCL: tcurs++; break; case INCL|LNMD: tcurs += BLKSIZE; /* fall through... */ case LNMD: range &= ~(BLKSIZE - 1); tcurs &= ~(BLKSIZE - 1); break; } /* run the function */ tcurs = (*vikeys[prevkey].func)(range, tcurs); (void)adjmove(cursor, cursor, 0); cursor = adjmove(cursor, tcurs, (int)vikeys[prevkey].flags); /* cleanup */ prevkey = 0; } else if (!prevkey) { cursor = tcurs; } } } /* This function adjusts the MARK value that they return; here we make sure * it isn't past the end of the line, and that the column hasn't been * *accidentally* changed. */ MARK adjmove(old, new, flags) MARK old; /* the cursor position before the command */ REG MARK new; /* the cursor position after the command */ int flags; /* various flags regarding cursor mvmt */ { static int colno; /* the column number that we want */ REG char *text; /* used to scan through the line's text */ REG int i; #ifdef DEBUG watch(); #endif /* if the command failed, bag it! */ if (new == MARK_UNSET) { Beep(); return old; } /* if this is a non-relative movement, set the '' mark */ if (flags & NREL) { mark[26] = old; } /* make sure it isn't past the end of the file */ if (markline(new) < 1) { new = MARK_FIRST; } else if (markline(new) > nlines) { new = MARK_LAST; } /* fetch the new line */ pfetch(markline(new)); /* move to the front, if we're supposed to */ if (flags & FRNT) { new = m_front(new, 1L); } /* change the column#, or change the mark to suit the column# */ if (!(flags & NCOL)) { /* change the column# */ i = markidx(new); if (i == BLKSIZE - 1) { new &= ~(BLKSIZE - 1); if (plen > 0) { new += plen - 1; } colno = BLKSIZE * 8; /* one heck of a big colno */ } else if (plen > 0) { if (i >= plen) { new = (new & ~(BLKSIZE - 1)) + plen - 1; } colno = idx2col(new, ptext, FALSE); } else { new &= ~(BLKSIZE - 1); colno = 0; } } else { /* adjust the mark to get as close as possible to column# */ for (i = 0, text = ptext; i <= colno && *text; text++) { if (*text == '\t' && !*o_list) { i += *o_tabstop - (i % *o_tabstop); } else if (UCHAR(*text) < ' ' || *text == 127) { i += 2; } #ifndef NO_CHARATTR else if (*o_charattr && text[0] == '\\' && text[1] == 'f' && text[2]) { text += 2; /* plus one more in "for()" stmt */ } #endif else { i++; } } if (text > ptext) { text--; } new = (new & ~(BLKSIZE - 1)) + (int)(text - ptext); } return new; } #ifdef DEBUG watch() { static wasset; if (*origname) { wasset = TRUE; } else if (wasset) { msg("origname was clobbered"); endwin(); abort(); } if (nlines == 0) { msg("nlines=0"); endwin(); abort(); } } #endif SHAR_EOF fi # end of overwriting check if test -f 'virec.c' then echo shar: will not over-write existing file "'virec.c'" else cat << \SHAR_EOF > 'virec.c' /* virec.c */ /* Author: * Steve Kirkendall * 14407 SW Teal Blvd. #C * Beaverton, OR 97005 * kirkenda@cs.pdx.edu */ /* This file contains the file recovery program */ #include "config.h" #include #include #include "vi.h" #if TOS # include #else # if OSK # include "osk.h" # else # include # endif #endif extern char *getenv(); struct stat stbuf; BLK hdr; BLK text; /* the name of the directory where tmp files are stored. */ char o_directory[30] = TMPDIR; char *progname; main(argc, argv) int argc; char **argv; { char *tmp; void recover(); #if MSDOS || TOS char **wildexpand(); argv = wildexpand(&argc, argv); #endif progname = argv[0]; /* set the o_directory variable */ if ((tmp = getenv("TMP")) /* yes, ASSIGNMENT! */ || (tmp = getenv("TEMP"))) /* yes, ASSIGNMENT! */ { strcpy(o_directory, tmp); } if (argc >= 3 && !strcmp(argv[1], "-d")) { strcpy(o_directory, argv[2]); argc -= 2; argv += 2; } /* process the arguments */ if (argc < 2) { /* maybe stdin comes from a file? */ if (isatty(0)) { fprintf(stderr, "usage: %s [-d tmpdir] lostfile...\n", progname); } else if (read(0, &hdr, (unsigned)BLKSIZE) != BLKSIZE) { fprintf(stderr, "couldn't get header\n"); } else { copytext(0, stdout); } } else { while (--argc > 0) { recover(*++argv); } } exit(0); } /* This function recovers a single file */ void recover(filename) char *filename; { char tmpname[100]; int tmpfd; int count; FILE *fp; long mtime; int i, j; int sum; /* used for calculating a checksum for this */ char *scan; /* get the file's status info */ if (stat(filename, &stbuf) < 0) { /* if serious error, give up on this file */ if (errno != ENOENT) { perror(filename); return; } /* else fake it for a new file */ stat(".", &stbuf); #if OSK stbuf.st_mode = S_IREAD; #else stbuf.st_mode = S_IFREG; #endif stbuf.st_mtime = 0L; } /* generate a checksum from the file's name */ for (sum = 0, scan = filename + strlen(filename); --scan >= filename && (isascii(*scan) && isalnum(*scan) || *scan == '.'); sum = sum + *scan) { } sum &= 0xf; /* find the tmp file */ #if MSDOS || TOS /* MS-Dos doesn't allow multiple slashes, but supports drives * with current directories. * This relies on TMPNAME beginning with "%s\\"!!!! */ strcpy(tmpname, o_directory); if ((i = strlen(tmpname)) && !strchr(":/\\", tmpname[i-1])) tmpname[i++]=SLASH; sprintf(tmpname+i, TMPNAME+3, sum, stbuf.st_ino, stbuf.st_dev); #else sprintf(tmpname, TMPNAME, o_directory, sum, stbuf.st_ino, stbuf.st_dev, 0); #endif count = tnamerec(tmpname, TMPNAME); tmpfd = open(tmpname, O_RDONLY | O_BINARY); if (tmpfd < 0) { char buf[512]; sprintf(buf, "recoverable version of %s", filename); perror(buf); fprintf(stderr, "make sure your TMP or TEMP environment variable is correct\n"); return; } /* make sure the file hasn't been modified more recently */ mtime = stbuf.st_mtime; fstat(tmpfd, &stbuf); if (stbuf.st_mtime < mtime || count > 0) { if (count > 0) { printf("%d temp files are recoverable\n", count+1); printf("\tyou may want to do more than one recover\n"); printf("\tsince the one that *is* recovered is picked\n"); printf("\tat random.\n"); } printf("\"%s\" has been modified more recently than its recoverable version\n", filename); puts("Do you still want to recover it?\n"); puts("\ty - Yes, discard the current version and recover it.\n"); puts("\tn - No, discard the recoverable version and keep the current version\n"); puts("\tq - Quit without doing anything for this file.\n"); puts("Enter y, n, or q --> "); fflush(stdout); for (;;) { switch (getchar()) { case 'y': case 'Y': goto BreakBreak; case 'n': case 'N': close(tmpfd); unlink(tmpname); return; case 'q': case 'Q': close(tmpfd); return; } } BreakBreak:; } /* make sure this tmp file is intact */ if (read(tmpfd, &hdr, (unsigned)BLKSIZE) != BLKSIZE) { fprintf(stderr, "%s: bad header in tmp file\n", filename); close(tmpfd); unlink(tmpname); return; } for (i = j = 1; i < MAXBLKS && hdr.n[i]; i++) { if (hdr.n[i] > j) { j = hdr.n[i]; } } lseek(tmpfd, (long)j * (long)BLKSIZE, 0); if (read(tmpfd, &text, (unsigned)BLKSIZE) != BLKSIZE) { fprintf(stderr, "%s: bad data block in tmp file\n", filename); close(tmpfd); unlink(tmpname); return; } /* open the normal text file for writing */ fp = fopen(filename, "w"); if (!fp) { perror(filename); close(tmpfd); return; } /* copy the text */ copytext(tmpfd, fp); /* cleanup */ close(tmpfd); fclose(fp); unlink(tmpname); } /* This function moves text from the tmp file to the normal file */ copytext(tmpfd, fp) int tmpfd; /* fd of the tmp file */ FILE *fp; /* the stream to write it to */ { int i; /* write the data blocks to the normal text file */ for (i = 1; i < MAXBLKS && hdr.n[i]; i++) { lseek(tmpfd, (long)hdr.n[i] * (long)BLKSIZE, 0); read(tmpfd, &text, (unsigned)BLKSIZE); fputs(text.c, fp); } } #if MSDOS || TOS #define WILDCARD_NO_MAIN #include "wildcard.c" #endif SHAR_EOF fi # end of overwriting check if test -f 'wildcard.c' then echo shar: will not over-write existing file "'wildcard.c'" else cat << \SHAR_EOF > 'wildcard.c' /* wildcard.c */ /* Author: * Guntram Blohm * Buchenstrasse 19 * 7904 Erbach, West Germany * Tel. ++49-7305-6997 * sorry - no regular network connection */ /* this program implements wildcard expansion for elvis/dos. It works * like UNIX echo, but uses the dos wildcard conventions * (*.* matches all files, * matches files without extension only, * filespecs may contain drive letters, wildcards not allowed in directory * names). * * It is also #included into ctags.c, ref.c, ...; in this case, * we don't want a main function here. */ #include #include #ifdef __TURBOC__ #include #endif #ifdef M_I86 #define findfirst(a,b,c) _dos_findfirst(a,c,b) #define findnext _dos_findnext #define ffblk find_t #define ff_name name #include #endif #ifdef M68000 #include #include #define findfirst(a,b,c) (Fsetdta(b), (Fsfirst(a,c))) #define findnext(x) (Fsnext()) #define ff_name d_fname #endif #define MAXFILES 1000 int pstrcmp(); extern char *calloc(); char *files[MAXFILES]; int nfiles; #ifndef WILDCARD_NO_MAIN main(argc, argv) char **argv; { int i; for (i=1; i=buf) { if (*filespec=='?' || *filespec=='*') wildcard=1; if (*filespec=='/' || *filespec=='\\' || *filespec==':') break; } if (!wildcard) addfile(buf); else { lastn=nfiles; filespec++; if ((err=findfirst(buf, &findbuf, 0))!=0) addfile(buf); while (!err) { strcpy(filespec, findbuf.ff_name); addfile(buf); err=findnext(&findbuf); } if (lastn!=nfiles) qsort(files+lastn, nfiles-lastn, sizeof(char *), pstrcmp); } } addfile(buf) char *buf; { char *p; for (p=buf; *p; p++) *p=tolower(*p); if (nfiles