home *** CD-ROM | disk | FTP | other *** search
/ Programmer 7500 / MAX_PROGRAMMERS.iso / INFO / EDITOR / ELVIS14S.ZIP / REFS < prev    next >
Encoding:
Text File  |  1990-12-13  |  18.9 KB  |  715 lines
  1. main(argc, argv)
  2.     int    argc;
  3.     char    *argv[];
  4. int access(file, mode)
  5.     char *file;
  6. char *mktemp(template)
  7.     char *template;
  8. int tread(fd, buf, maxlen)
  9.     int fd;
  10.     char *buf;
  11.     int maxlen;
  12. int twrite(fd, buf, maxlen)
  13.     int fd;
  14.     char *buf;
  15.     int maxlen;
  16. void blkinit()
  17. BLK *blkget(logical)
  18.     int    logical;    /* logical block number to fetch */
  19. void blkflush(this)
  20.     REG struct _blkbuf    *this;    /* the buffer to flush */
  21. void blkdirty(bp)
  22.     BLK    *bp;    /* buffer returned by blkget() */
  23. BLK *blkadd(logical)
  24.     int    logical;    /* where to insert the new block */
  25. void blksync()
  26. void beforedo(forundo)
  27.     int        forundo;    /* boolean: is this for an undo? */
  28. void afterdo()
  29. void abortdo()
  30. int undo()
  31. void cmd_debug(frommark, tomark, cmd, bang, extra)
  32.     MARK    frommark;
  33.     MARK    tomark;
  34.     CMD    cmd;
  35.     int    bang;
  36.     char    *extra;
  37. void cmd_validate(frommark, tomark, cmd, bang, extra)
  38.     MARK    frommark;
  39.     MARK    tomark;
  40.     CMD    cmd;
  41.     int    bang;
  42.     char    *extra;
  43. void cmd_mark(frommark, tomark, cmd, bang, extra)
  44.     MARK    frommark;
  45.     MARK    tomark;
  46.     CMD    cmd;
  47.     int    bang;
  48.     char    *extra;
  49. void cmd_write(frommark, tomark, cmd, bang, extra)
  50.     MARK    frommark;
  51.     MARK    tomark;
  52.     CMD    cmd;
  53.     int    bang;
  54.     char    *extra;
  55. void cmd_shell(frommark, tomark, cmd, bang, extra)
  56.     MARK    frommark, tomark;
  57.     CMD    cmd;
  58.     int    bang;
  59.     char    *extra;
  60. void cmd_global(frommark, tomark, cmd, bang, extra)
  61.     MARK    frommark, tomark;
  62.     CMD    cmd;
  63.     int    bang;
  64.     char    *extra;    /* rest of the command line */
  65. void cmd_file(frommark, tomark, cmd, bang, extra)
  66.     MARK    frommark, tomark;
  67.     CMD    cmd;
  68.     int    bang;
  69.     char    *extra;
  70. void cmd_edit(frommark, tomark, cmd, bang, extra)
  71.     MARK    frommark, tomark;
  72.     CMD    cmd;
  73.     int    bang;
  74.     char    *extra;
  75. void cmd_next(frommark, tomark, cmd, bang, extra)
  76.     MARK    frommark, tomark;
  77.     CMD    cmd;
  78.     int    bang;
  79.     char    *extra;
  80. void cmd_xit(frommark, tomark, cmd, bang, extra)
  81.     MARK    frommark, tomark;
  82.     CMD    cmd;
  83.     int    bang;
  84.     char    *extra;
  85. void cmd_args(frommark, tomark, cmd, bang, extra)
  86.     MARK    frommark, tomark;
  87.     CMD    cmd;
  88.     int    bang;
  89.     char    *extra;
  90. void cmd_cd(frommark, tomark, cmd, bang, extra)
  91.     MARK    frommark, tomark;
  92.     CMD    cmd;
  93.     int    bang;
  94.     char    *extra;
  95. void cmd_map(frommark, tomark, cmd, bang, extra)
  96.     MARK    frommark, tomark;
  97.     CMD    cmd;
  98.     int    bang;
  99.     char    *extra;
  100. void cmd_set(frommark, tomark, cmd, bang, extra)
  101.     MARK    frommark, tomark;
  102.     CMD    cmd;
  103.     int    bang;
  104.     char    *extra;
  105. void cmd_tag(frommark, tomark, cmd, bang, extra)
  106.     MARK    frommark, tomark;
  107.     CMD    cmd;
  108.     int    bang;
  109.     char    *extra;
  110. void cmd_visual(frommark, tomark, cmd, bang, extra)
  111.     MARK    frommark, tomark;
  112.     CMD    cmd;
  113.     int    bang;
  114.     char    *extra;
  115. void cmd_version(frommark, tomark, cmd, bang, extra)
  116.     MARK    frommark;
  117.     MARK    tomark;
  118.     CMD    cmd;
  119.     int    bang;
  120.     char    *extra;
  121. void cmd_mkexrc(frommark, tomark, cmd, bang, extra)
  122.     MARK    frommark;
  123.     MARK    tomark;
  124.     CMD    cmd;
  125.     int    bang;
  126.     char    *extra;
  127. void cmd_digraph(frommark, tomark, cmd, bang, extra)
  128.     MARK    frommark;
  129.     MARK    tomark;
  130.     CMD    cmd;
  131.     int    bang;
  132.     char    *extra;
  133. void cmd_errlist(frommark, tomark, cmd, bang, extra)
  134.     MARK    frommark, tomark;
  135.     CMD    cmd;
  136.     int    bang;
  137.     char    *extra;
  138. void cmd_make(frommark, tomark, cmd, bang, extra)
  139.     MARK    frommark, tomark;
  140.     CMD    cmd;
  141.     int    bang;
  142.     char    *extra;
  143. void cmd_abbr(frommark, tomark, cmd, bang, extra)
  144.     MARK    frommark, tomark;
  145.     CMD    cmd;
  146.     int    bang;
  147.     char    *extra;
  148. void cmd_substitute(frommark, tomark, cmd, bang, extra)
  149.     MARK    frommark;
  150.     MARK    tomark;
  151.     CMD    cmd;
  152.     int    bang;
  153.     char    *extra;    /* rest of the command line */
  154. void cmd_delete(frommark, tomark, cmd, bang, extra)
  155.     MARK    frommark;
  156.     MARK    tomark;
  157.     CMD    cmd;
  158.     int    bang;
  159.     char    *extra;
  160. void cmd_append(frommark, tomark, cmd, bang, extra)
  161.     MARK    frommark;
  162.     MARK    tomark;
  163.     CMD    cmd;
  164.     int    bang;
  165.     char    *extra;
  166. void cmd_put(frommark, tomark, cmd, bang, extra)
  167.     MARK    frommark;
  168.     MARK    tomark;
  169.     CMD    cmd;
  170.     int    bang;
  171.     char    *extra;
  172. void cmd_join(frommark, tomark, cmd, bang, extra)
  173.     MARK    frommark;
  174.     MARK    tomark;
  175.     CMD    cmd;
  176.     int    bang;
  177.     char    *extra;
  178. void cmd_shift(frommark, tomark, cmd, bang, extra)
  179.     MARK    frommark;
  180.     MARK    tomark;
  181.     CMD    cmd;
  182.     int    bang;
  183.     char    *extra;
  184. void cmd_read(frommark, tomark, cmd, bang, extra)
  185.     MARK    frommark;
  186.     MARK    tomark;
  187.     CMD    cmd;
  188.     int    bang;
  189.     char    *extra;
  190. void cmd_undo(frommark, tomark, cmd, bang, extra)
  191.     MARK    frommark;
  192.     MARK    tomark;
  193.     CMD    cmd;
  194.     int    bang;
  195.     char    *extra;
  196. void cmd_print(frommark, tomark, cmd, bang, extra)
  197.     MARK    frommark;
  198.     MARK    tomark;
  199.     CMD    cmd;
  200.     int    bang;
  201.     char    *extra;
  202. void cmd_move(frommark, tomark, cmd, bang, extra)
  203.     MARK    frommark;
  204.     MARK    tomark;
  205.     CMD    cmd;
  206.     int    bang;
  207.     char    *extra;
  208. void cmd_source(frommark, tomark, cmd, bang, extra)
  209.     MARK    frommark;
  210.     MARK    tomark;
  211.     CMD    cmd;
  212.     int    bang;
  213.     char    *extra;
  214. void cmd_at(frommark, tomark, cmd, bang, extra)
  215.     MARK    frommark;
  216.     MARK    tomark;
  217.     CMD    cmd;
  218.     int    bang;
  219.     char    *extra;
  220. main(argc, argv)
  221.     int    argc;
  222.     char    **argv;
  223. ctags(fp, name, refs)
  224.     FILE    *fp;        /* stream of the file to scan */
  225.     char    *name;        /* name of the file being scanned */
  226.     FILE    *refs;        /* NULL, or where to write refs lines */
  227. void initscr()
  228. void endwin()
  229. void suspend_curses()
  230. void resume_curses(quietly)
  231.     int    quietly;
  232. int getsize(signo)
  233.     int    signo;
  234. int faddch(ch)
  235.     int    ch;
  236. void qaddstr(str)
  237.     char    *str;
  238. void attrset(a)
  239.     int    a;
  240. void insch(ch)
  241.     int    ch;
  242. ttyread(buf, len)
  243.     char *buf;
  244.     int len;
  245. alarm(time)
  246.     int time;
  247. sleep(seconds)
  248.     unsigned seconds;
  249. ttyread(buf, len)
  250.     char *buf;
  251.     int len;
  252. alarm(time)
  253.     int time;
  254. ttywrite(buf, len)
  255.     char *buf;
  256.     int len;
  257. ttyread(buf, len)
  258.     char *buf;
  259.     int len;
  260. alarm(time)
  261.     int time;
  262. int cutneeds(need)
  263.     BLK        *need;    /* this is where we deposit the list */
  264. void cutswitch(tmpname)
  265.     char    *tmpname; /* name of the tmp file */
  266. void cutend()
  267. void cutname(name)
  268.     int    name;    /* a single character */
  269. void cut(from, to)
  270.     MARK    from;        /* start of text to cut */
  271.     MARK    to;        /* end of text to cut */
  272. MARK paste(at, after, retend)
  273.     MARK    at;    /* where to insert the text */
  274.     int    after;    /* boolean: insert after mark? (rather than before) */
  275.     int    retend;    /* boolean: return end of text? (rather than start) */
  276. int cb2str(name, buf, size)
  277.     int    name;    /* the name of a cut-buffer to get: a-z only! */
  278.     char    *buf;    /* where to put the string */
  279.     unsigned size;    /* size of buf */
  280. char    *parseptrn(ptrn)
  281.     REG char    *ptrn;
  282. char *linespec(s, markptr)
  283.     REG char    *s;        /* start of the line specifier */
  284.     MARK        *markptr;    /* where to store the mark's value */
  285. void ex()
  286. void doexcmd(cmdbuf)
  287.     char        *cmdbuf;    /* string containing an ex command */
  288. int doexrc(filename)
  289.     char    *filename;    /* name of a ".exrc" file */
  290. void exstring(buf, len)
  291.     char    *buf;    /* the commands to execute */
  292.     int    len;    /* the length of the string */
  293. char digraph(key1, key2)
  294.     char    key1;    /* the underlying character */
  295.     char    key2;    /* the second character */
  296. void do_digraph(bang, extra)
  297.     int    bang;
  298.     char    extra[];
  299. void savedigs(fd)
  300.     int        fd;
  301. void do_abbr(extra)
  302.     char    *extra;
  303. void saveabbr(fd)
  304.     int    fd;    /* fd to which the :abbr commands should be written */
  305. MARK input(from, to, when)
  306.     MARK    from;    /* where to start inserting text */
  307.     MARK    to;    /* extent of text to delete */
  308.     int    when;    /* either WHEN_VIINP or WHEN_VIREP */
  309. void main(argc, argv)
  310.     int    argc;
  311.     char    *argv[];
  312. int trapint(signo)
  313.     int    signo;
  314. char *fetchline(line)
  315.     long    line;    /* line number of the line to fetch */
  316. void regerror(txt)
  317.     char    *txt;    /* an error message */
  318. void    pfetch(l)
  319.     long    l;    /* line number of line to fetch */
  320. debout(msg, arg1, arg2, arg3, arg4, arg5)
  321.     char    *msg, *arg1, *arg2, *arg3, *arg4, *arg5;
  322. void delete(frommark, tomark)
  323.     MARK        frommark;    /* first char to be deleted */
  324.     MARK        tomark;        /* AFTER last char to be deleted */
  325. void add(atmark, newtext)
  326.     MARK        atmark;        /* where to insert the new text */
  327.     char        *newtext;    /* NUL-terminated string to insert */
  328. void change(frommark, tomark, newtext)
  329.     MARK    frommark, tomark;
  330.     char    *newtext;
  331. MARK    m_updnto(m, cnt, cmd)
  332.     MARK    m;    /* movement is relative to this mark */
  333.     long    cnt;    /* a numeric argument */
  334. MARK    m_right(m, cnt)
  335.     MARK    m;    /* movement is relative to this mark */
  336.     long    cnt;    /* a numeric argument */
  337. MARK    m_left(m, cnt)
  338.     MARK    m;    /* movement is relative to this mark */
  339.     long    cnt;    /* a numeric argument */
  340. MARK    m_tocol(m, cnt)
  341.     MARK    m;    /* movement is relative to this mark */
  342.     long    cnt;    /* a numeric argument */
  343. MARK    m_front(m, cnt)
  344.     MARK    m;    /* movement is relative to this mark */
  345.     long    cnt;    /* a numeric argument (ignored) */
  346. MARK    m_rear(m, cnt)
  347.     MARK    m;    /* movement is relative to this mark */
  348.     long    cnt;    /* a numeric argument (ignored) */
  349. MARK    m_fsentence(m, cnt)
  350.     MARK    m;    /* movement is relative to this mark */
  351.     long    cnt;    /* a numeric argument */
  352. MARK    m_bsentence(m, cnt)
  353.     MARK    m;    /* movement is relative to this mark */
  354.     long    cnt;    /* a numeric argument */
  355. MARK    m_fparagraph(m, cnt)
  356.     MARK    m;    /* movement is relative to this mark */
  357.     long    cnt;    /* a numeric argument */
  358. MARK    m_bparagraph(m, cnt)
  359.     MARK    m;    /* movement is relative to this mark */
  360.     long    cnt;    /* a numeric argument */
  361. MARK    m_fsection(m, cnt, key)
  362.     MARK    m;    /* movement is relative to this mark */
  363.     long    cnt;    /* (ignored) */
  364.     int    key;    /* second key stroke - must be ']' */
  365. MARK    m_bsection(m, cnt, key)
  366.     MARK    m;    /* movement is relative to this mark */
  367.     long    cnt;    /* (ignored) */
  368.     int    key;    /* second key stroke - must be '[' */
  369. MARK    m_match(m, cnt)
  370.     MARK    m;    /* movement is relative to this mark */
  371.     long    cnt;    /* a numeric argument (ignored) */
  372. MARK    m_tomark(m, cnt, key)
  373.     MARK    m;    /* movement is relative to this mark */
  374.     long    cnt;    /* (ignored) */
  375.     int    key;    /* keystroke - the mark to move to */
  376. MARK    m_nsrch(m)
  377.     MARK    m;    /* where to start searching */
  378. MARK    m_Nsrch(m)
  379.     MARK    m;    /* where to start searching */
  380. MARK    m_fsrch(m, ptrn)
  381.     MARK    m;    /* where to start searching */
  382.     char    *ptrn;    /* pattern to search for */
  383. MARK    m_bsrch(m, ptrn)
  384.     MARK    m;    /* where to start searching */
  385.     char    *ptrn;    /* pattern to search for */
  386. MARK    m__ch(m, cnt, cmd)
  387.     MARK    m;    /* current position */
  388.     long    cnt;
  389.     char    cmd;    /* command: either ',' or ';' */
  390. MARK    m_fch(m, cnt, key)
  391.     MARK    m;    /* where to search from */
  392.     long    cnt;
  393.     char    key;    /* what to search for */
  394. MARK    m_Fch(m, cnt, key)
  395.     MARK    m;    /* where to search from */
  396.     long    cnt;
  397.     char    key;    /* what to search for */
  398. MARK    m_tch(m, cnt, key)
  399.     MARK    m;    /* where to search from */
  400.     long    cnt;
  401.     char    key;    /* what to search for */
  402. MARK    m_Tch(m, cnt, key)
  403.     MARK    m;    /* where to search from */
  404.     long    cnt;
  405.     char    key;    /* what to search for */
  406. MARK m_row(m, cnt, key)
  407.     MARK    m;    /* the cursor position */
  408.     long    cnt;    /* the row we'll move to */
  409.     int    key;    /* the keystroke of this move - H/L/M */
  410. MARK m_z(m, cnt, key)
  411.     MARK    m;    /* the cursor */
  412.     long    cnt;    /* the line number we're repositioning */
  413.     int    key;    /* key struck after the z */
  414. MARK m_scroll(m, cnt, key)
  415.     MARK    m;    /* the cursor position */
  416.     long    cnt;    /* for some keys: the number of lines to scroll */
  417.     int    key;    /* keystroke that causes this movement */
  418. MARK    m_fword(m, cnt, cmd)
  419.     MARK    m;    /* movement is relative to this mark */
  420.     long    cnt;    /* a numeric argument */
  421.     int    cmd;    /* either 'w' or 'W' */
  422. MARK    m_bword(m, cnt, cmd)
  423.     MARK    m;    /* movement is relative to this mark */
  424.     long    cnt;    /* a numeric argument */
  425.     int    cmd;    /* either 'b' or 'B' */
  426. MARK    m_eword(m, cnt, cmd)
  427.     MARK    m;    /* movement is relative to this mark */
  428.     long    cnt;    /* a numeric argument */
  429.     int    cmd;    /* either 'e' or 'E' */
  430. void initopts()
  431. void dumpopts(all)
  432.     int    all;    /* boolean: dump all options, or just set ones? */
  433. void saveopts(fd)
  434.     int    fd;    /* file descriptor to write to */
  435. void setopts(assignments)
  436.     char    *assignments;    /* a string containing option assignments */
  437. int fstat(fd, buff)
  438.       int         fd;
  439.       struct stat *buff;
  440. int stat(filename, buff)
  441.       char        *filename;
  442.       struct stat *buff;
  443. link(from,to)
  444.     char *from,*to;
  445. sig_handler(sig)
  446.     int sig;
  447. procref signal(sig,func)
  448.     int sig;
  449.     int (*func)();
  450. perror(str)
  451.     char *str;
  452. isatty(fd)
  453.     int fd;
  454. void v_up()
  455. void v_cb()
  456. void v_cs()
  457. void v_ce()
  458. void v_cl()
  459. void v_cd()
  460. void v_al()
  461. void v_dl()
  462. void v_sr()
  463. void v_move(x,y)
  464.     int x, y;
  465. int v_put(ch)
  466.     int ch;
  467. int v_cols()
  468. int v_rows()
  469. int switchar()
  470. void garbage()
  471. long allocate()
  472. void redrawrange(after, pre, post)
  473.     long    after;    /* lower bound of redrawafter */
  474.     long    pre;    /* upper bound of preredraw */
  475.     long    post;    /* upper bound of postredraw */
  476. int idx2col(curs, text, inputting)
  477.     MARK        curs;    /* the line# & index# of the cursor */
  478.     REG char    *text;    /* the text of the line, from fetchline */
  479.     int        inputting;    /* boolean: called from input() ? */
  480. int mark2phys(m, text, inputting)
  481.     MARK    m;        /* a mark to convert */
  482.     char    *text;        /* the line that m refers to */
  483.     int    inputting;    /* boolean: caled from input() ? */
  484. void redraw(curs, inputting)
  485.     MARK    curs;        /* where to leave the screen's cursor */
  486.     int    inputting;    /* boolean: being called from input() ? */
  487. main(argc, argv)
  488.     int    argc;
  489.     char    **argv;
  490. int lookinfor(filename, func)
  491.     char    *filename;    /* name of file to look in */
  492.     char    *func;        /* name of function to look for */
  493. desired(line, word)
  494.     char    *line;    /* the line buffer */
  495.     char    *word;    /* the string it should contain */
  496. main(argc, argv)
  497.     int    argc;    /* number of command-line args */
  498.     char    **argv;    /* values of the command line args */
  499. usage()
  500. refont(fp)
  501.     FILE    *fp;
  502. regexp *regcomp(text)
  503.     char        *text;
  504. int match1(re, ch, token)
  505.     regexp        *re;
  506.     REG char    ch;
  507.     REG int        token;
  508. int match(re, str, prog, here)
  509.     regexp        *re;    /* the regular expression */
  510.     char        *str;    /* the string */
  511.     REG char    *prog;    /* a portion of re->program, an compiled RE */
  512.     REG char    *here;    /* a portion of str, the string to compare it to */
  513. int regexec(re, str, bol)
  514.     regexp    *re;    /* the compiled regexp to search for */
  515.     char    *str;    /* the string to search through */
  516.     int    bol;    /* boolean: does str start at the beginning of a line? */
  517. regexp *regcomp(exp)
  518.     char    *exp;
  519. int regexec(prog, string, bolflag)
  520.     struct regexp    *prog;
  521.     char        *string;
  522.     int        bolflag;
  523. void regsub(re, src, dst)
  524.     regexp        *re;
  525.     REG char    *src;
  526.     REG char    *dst;
  527. main(argc, argv)
  528.     int argc;
  529.     char **argv;
  530. execute(buf)
  531.     char *buf;
  532. searchpath(from, to)
  533.     char *from, *to;
  534. try(name)
  535.     char *name;
  536. cmd_exit()
  537. cmd_set(line)
  538.     char *line;
  539. doset(line, value)
  540.     char *line, *value;
  541. script(name)
  542.     char *name;
  543. int system(cmd)
  544.     const char    *cmd;
  545. int rpipe(cmd, in)
  546.     char    *cmd;    /* the filter command to use */
  547.     int    in;    /* the fd to use for stdin */
  548. int rpclose(fd)
  549.     int    fd;
  550. int system(cmd)
  551.     char    *cmd;    /* a command to run */
  552. char *wildcard(names)
  553.     char    *names;
  554. int filter(from, to, cmd)
  555.     MARK    from, to;    /* the range of lines to filter */
  556.     char    *cmd;        /* the filter command */
  557. int tgetent(bp, name)
  558.     char    *bp;    /* buffer for storing the entry -- ignored */
  559.     char    *name;    /* name of the entry */
  560. int tgetnum(id)
  561.     char    *id;
  562. int tgetflag(id)
  563.     char    *id;
  564. char *tgetstr(id, bp)
  565.     char    *id;
  566.     char    **bp;    /* pointer to pointer to buffer - ignored */
  567. char *tgoto(cm, destcol, destrow)
  568.     char    *cm;    /* cursor movement string -- ignored */
  569.     int    destcol;/* destination column, 0 - 79 */
  570.     int    destrow;/* destination row, 0 - 24 */
  571. void tputs(cp, affcnt, outfn)
  572.     char    *cp;        /* the string to output */
  573.     int    affcnt;        /* number of affected lines -- ignored */
  574.     int    (*outfn)();    /* the output function */
  575. int vgets(prompt, buf, bsize)
  576.     char    prompt;    /* the prompt character, or '\0' for none */
  577.     char    *buf;    /* buffer into which the string is read */
  578.     int    bsize;    /* size of the buffer */
  579. void beep()
  580. void endmsgs()
  581. void msg(fmt, arg1, arg2, arg3, arg4, arg5, arg6, arg7)
  582.     char    *fmt;
  583.     long    arg1, arg2, arg3, arg4, arg5, arg6, arg7;
  584. void exrefresh()
  585. int fromcutbuf(cbname)
  586.     int    cbname;
  587. int getkey(when)
  588.     int        when;        /* which bits must be ON? */
  589. void mapkey(rawin, cooked, when, name)
  590.     char    *rawin;    /* the input key sequence, before mapping */
  591.     char    *cooked;/* after mapping */
  592.     short    when;    /* bitmap of when mapping should happen */
  593.     char    *name;    /* name of the key, if any */
  594. void dumpkey(when)
  595.     int    when;    /* WHEN_XXXX of mappings to be dumped */
  596. void savekeys(fd)
  597.     int    fd;    /* file descriptor to save them to */
  598. int tmpstart(filename)
  599.     char        *filename; /* name of the original file */
  600. int tmpsave(filename, bang)
  601.     char    *filename;    /* the name to save it to */
  602.     int    bang;        /* forced write? */
  603. int tmpabort(bang)
  604.     int    bang;
  605. int tmpend(bang)
  606.     int    bang;
  607. sync()
  608. MARK v_quit()
  609. MARK v_redraw()
  610. MARK v_1ex(m, text)
  611.     MARK    m;    /* the current line */
  612.     char    *text;    /* the first command to execute */
  613. MARK v_undo(m)
  614.     MARK    m;    /* (ignored) */
  615. MARK v_xchar(m, cnt, cmd)
  616.     MARK    m;    /* where to start deletions */
  617.     long    cnt;    /* number of chars to delete */
  618.     int    cmd;    /* either 'x' or 'X' */
  619. MARK v_mark(m, count, key)
  620.     MARK    m;    /* where the mark will be */
  621.     long    count;    /* (ignored) */
  622.     int    key;    /* the ASCII label of the mark */
  623. MARK v_ulcase(m, cnt)
  624.     MARK    m;    /* where to make the change */
  625.     long    cnt;    /* number of chars to flip */
  626. MARK v_replace(m, cnt, key)
  627.     MARK    m;    /* first char to be replaced */
  628.     long    cnt;    /* number of chars to replace */
  629.     int    key;    /* what to replace them with */
  630. MARK v_overtype(m)
  631.     MARK        m;    /* where to start overtyping */
  632. MARK v_selcut(m, cnt, key)
  633.     MARK    m;
  634.     long    cnt;
  635.     int    key;
  636. MARK v_paste(m, cnt, cmd)
  637.     MARK    m;    /* where to paste the text */
  638.     long    cnt;    /* (ignored) */
  639.     int    cmd;    /* either 'p' or 'P' */
  640. MARK v_yank(m, n)
  641.     MARK    m, n;    /* range of text to yank */
  642. MARK v_delete(m, n)
  643.     MARK    m, n;    /* range of text to delete */
  644. MARK v_insert(m, cnt, key)
  645.     MARK    m;    /* where to start (sort of) */
  646.     long    cnt;    /* repeat how many times? */
  647.     int    key;    /* what command is this for? {a,A,i,I,o,O} */
  648. MARK v_change(m, n)
  649.     MARK    m, n;    /* the range of text to change */
  650. MARK v_subst(m, cnt)
  651.     MARK    m;    /* where substitutions start */
  652.     long    cnt;    /* number of chars to replace */
  653. MARK v_join(m, cnt)
  654.     MARK    m;    /* the first line to be joined */
  655.     long    cnt;    /* number of other lines to join */
  656. MARK v_lshift(m, n)
  657.     MARK    m, n;    /* range of lines to shift */
  658. MARK v_rshift(m, n)
  659.     MARK    m, n;    /* range of lines to shift */
  660. MARK v_filter(m, n)
  661.     MARK    m, n;    /* range of lines to shift */
  662. MARK v_status()
  663. MARK v_again(m, n)
  664.     MARK    m, n;
  665. MARK v_switch()
  666. MARK v_tag(keyword, m, cnt)
  667.     char    *keyword;
  668.     MARK    m;
  669.     long    cnt;
  670. MARK v_keyword(keyword, m, cnt)
  671.     char    *keyword;
  672.     MARK    m;
  673.     long    cnt;
  674. MARK v_increment(keyword, m, cnt)
  675.     char    *keyword;
  676.     MARK    m;
  677.     long    cnt;
  678. MARK v_xit(m, cnt, key)
  679.     MARK    m;    /* ignored */
  680.     long    cnt;    /* ignored */
  681.     int    key;    /* must be a second 'Z' */
  682. MARK v_undoline(m)
  683.     MARK    m;    /* where we hope to undo the change */
  684. MARK v_errlist(m)
  685.     MARK    m;
  686. MARK v_at(m, cnt, key)
  687.     MARK    m;
  688.     long    cnt;
  689.     int    key;
  690. void vi()
  691. MARK adjmove(old, new, flags)
  692.     MARK        old;    /* the cursor position before the command */
  693.     REG MARK    new;    /* the cursor position after the command */
  694.     int        flags;    /* various flags regarding cursor mvmt */
  695. watch()
  696. main(argc, argv)
  697.     int    argc;
  698.     char    **argv;
  699. void recover(filename)
  700.     char    *filename;
  701. copytext(tmpfd, fp)
  702.     int    tmpfd;    /* fd of the tmp file */
  703.     FILE    *fp;    /* the stream to write it to */
  704. main(argc, argv)
  705.     char **argv;
  706. char **wildexpand(argc, argv)
  707.     int *argc;
  708.     char **argv;
  709. expand(name)
  710.     char *name;
  711. addfile(buf)
  712.     char *buf;
  713. int pstrcmp(a, b)
  714.     char **a, **b;
  715.