home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / misc / volume44 / vim / part14 < prev    next >
Encoding:
Internet Message Format  |  1994-08-22  |  68.5 KB
  1. From: mool@oce.nl (Bram Moolenaar)
  2. Newsgroups: comp.sources.misc
  3. Subject: v44i033:  vim - Vi IMproved editor, v3.0, Part14/26
  4. Date: 16 Aug 1994 21:18:35 -0500
  5. Organization: Sterling Software
  6. Sender: kent@sparky.sterling.com
  7. Approved: kent@sparky.sterling.com
  8. Message-ID: <32rs1r$kfm@sparky.sterling.com>
  9. References: <csm-v44i019=vim.211640@sparky.sterling.com>
  10. X-Md4-Signature: 83372001bb77555c58b36fc0f1a14d01
  11.  
  12. Submitted-by: mool@oce.nl (Bram Moolenaar)
  13. Posting-number: Volume 44, Issue 33
  14. Archive-name: vim/part14
  15. Environment: UNIX, AMIGA, MS-DOS, Windows NT
  16. Supersedes: vim: Volume 41, Issue 50-75
  17.  
  18. #! /bin/sh
  19. # This is a shell archive.  Remove anything before this line, then feed it
  20. # into a shell via "sh file" or similar.  To overwrite existing files,
  21. # type "sh file -c".
  22. # Contents:  vim/macros/maze/maze_5.78 vim/src/param.c vim/src/tags
  23. # Wrapped by kent@sparky on Mon Aug 15 21:44:07 1994
  24. PATH=/bin:/usr/bin:/usr/ucb:/usr/local/bin:/usr/lbin:$PATH ; export PATH
  25. echo If this archive is complete, you will see the following message:
  26. echo '          "shar: End of archive 14 (of 26)."'
  27. if test -f 'vim/macros/maze/maze_5.78' -a "${1}" != "-c" ; then 
  28.   echo shar: Will not clobber existing file \"'vim/macros/maze/maze_5.78'\"
  29. else
  30.   echo shar: Extracting \"'vim/macros/maze/maze_5.78'\" \(626 characters\)
  31.   sed "s/^X//" >'vim/macros/maze/maze_5.78' <<'END_OF_FILE'
  32. X._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._
  33. X| ._| . . ._| | |_._._. . ._|_._._._._. ._|_. ._|_._. ._| . ._|_. | . ._._. |
  34. X| ._|_| |_. | | | | ._._|_._|_._. . |_. | | | ._._| |_._._| | ._. ._| . . |_|
  35. X|_._._._. | ._|_. ._._._. | | ._. |_._. . | ._._| |_. | ._._._. |_. | |_|_| |
  36. X| | . |_._| . ._._._| ._._. ._._| | | |_| . | |_. . ._|_| ._._. |_._|_| . | |
  37. X|_._|_._._._|_._._._|_|_._._._|_._|_._._._|_._._._|_._._._|_._._._._._._|_._|
  38. X
  39. XSee Vim solve a maze!
  40. X
  41. X   type ":so maze_mac<RETURN>" to load the macros
  42. X
  43. X   type "g" to start
  44. X
  45. Xto interrupt type "<CTRL-C>"
  46. X     to quit type ":q!<RETURN>"
  47. X
  48. END_OF_FILE
  49.   if test 626 -ne `wc -c <'vim/macros/maze/maze_5.78'`; then
  50.     echo shar: \"'vim/macros/maze/maze_5.78'\" unpacked with wrong size!
  51.   fi
  52.   # end of 'vim/macros/maze/maze_5.78'
  53. fi
  54. if test -f 'vim/src/param.c' -a "${1}" != "-c" ; then 
  55.   echo shar: Will not clobber existing file \"'vim/src/param.c'\"
  56. else
  57.   echo shar: Extracting \"'vim/src/param.c'\" \(35665 characters\)
  58.   sed "s/^X//" >'vim/src/param.c' <<'END_OF_FILE'
  59. X/* vi:ts=4:sw=4
  60. X *
  61. X * VIM - Vi IMproved        by Bram Moolenaar
  62. X *
  63. X * Read the file "credits.txt" for a list of people who contributed.
  64. X * Read the file "uganda.txt" for copying and usage conditions.
  65. X */
  66. X
  67. X/*
  68. X * Code to handle user-settable parameters. This is all pretty much table-
  69. X * driven. To add a new parameter, put it in the params array, and add a
  70. X * variable for it in param.h. If it's a numeric parameter, add any necessary
  71. X * bounds checks to doset().
  72. X */
  73. X
  74. X#include "vim.h"
  75. X#include "globals.h"
  76. X#include "proto.h"
  77. X#include "param.h"
  78. X
  79. Xstruct param
  80. X{
  81. X    char        *fullname;        /* full parameter name */
  82. X    char        *shortname;     /* permissible abbreviation */
  83. X    short         flags;            /* see below */
  84. X    char_u        *var;            /* pointer to variable */
  85. X};
  86. X
  87. X/*
  88. X * Flags
  89. X * Note: Don't use P_STRING and P_IND at the same time
  90. X */
  91. X#define P_BOOL            0x01    /* the parameter is boolean */
  92. X#define P_NUM            0x02    /* the parameter is numeric */
  93. X#define P_STRING        0x04    /* the parameter is a string */
  94. X#define P_CHANGED        0x08    /* the parameter has been changed */
  95. X#define P_EXPAND        0x10    /* environment expansion */
  96. X#define P_IND            0x20    /* indirect, is in curwin or curbuf */
  97. X
  98. X/*
  99. X * The options that are in curwin or curbuf have P_IND set and a var field
  100. X * that contains one of the values below. The values are odd to make it very
  101. X * unlikely that another variable has the same value.
  102. X * Note: P_EXPAND and P_IND can never be used at the same time.
  103. X * Note: P_IND cannot be used for a terminal option.
  104. X */
  105. X#define PV_LIST        1
  106. X#define PV_NU        3
  107. X#define PV_SCROLL    5
  108. X#define PV_WRAP        7
  109. X
  110. X#define PV_AI        11
  111. X#define PV_BIN        13
  112. X#define PV_EOL        14
  113. X#define PV_ET        15
  114. X#define PV_ML        17
  115. X#define PV_RO        19
  116. X#define PV_SI        21
  117. X#define PV_SN        23
  118. X#define PV_SW        25
  119. X#define PV_TS        27
  120. X#define PV_TW        29
  121. X#define PV_TX        31
  122. X#define PV_WM        33
  123. X
  124. X/*
  125. X * The param structure is initialized here.
  126. X * The order of the parameters should be alfabetic
  127. X * The parameters with a NULL variable are 'hidden': a set command for
  128. X * them is ignored and they are not printed.
  129. X */
  130. Xstatic struct param params[] =
  131. X{
  132. X        {"autoindent",    "ai",    P_BOOL|P_IND,        (char_u *)PV_AI},
  133. X        {"autoprint",    "ap",    P_BOOL,                (char_u *)NULL},
  134. X        {"autowrite",    "aw",    P_BOOL,                (char_u *)&p_aw},
  135. X        {"backspace",    "bs",    P_NUM,                (char_u *)&p_bs},
  136. X        {"backup",        "bk",    P_BOOL,                (char_u *)&p_bk},
  137. X#ifdef UNIX
  138. X         {"backupdir",    "bdir",    P_STRING|P_EXPAND,    (char_u *)&p_bdir},
  139. X#endif
  140. X        {"beautify",    "bf",    P_BOOL,                (char_u *)NULL},
  141. X        {"binary",        "bin",    P_BOOL|P_IND,        (char_u *)PV_BIN},
  142. X#ifdef MSDOS
  143. X        {"bioskey",        "biosk",P_BOOL,                (char_u *)&p_biosk},
  144. X#endif
  145. X        {"cmdheight",    "ch",    P_NUM,                (char_u *)&p_ch},
  146. X        {"columns",        "co",    P_NUM,                (char_u *)&Columns},
  147. X        {"compatible",    "cp",    P_BOOL,                (char_u *)&p_cp},
  148. X#ifdef DIGRAPHS
  149. X        {"digraph",        "dg",    P_BOOL,                (char_u *)&p_dg},
  150. X#endif /* DIGRAPHS */
  151. X         {"directory",    "dir",    P_STRING|P_EXPAND,    (char_u *)&p_dir},
  152. X        {"edcompatible",NULL,    P_BOOL,                (char_u *)&p_ed},
  153. X        {"endofline",    "eol",    P_BOOL|P_IND,        (char_u *)PV_EOL},
  154. X        {"equalalways",    "ea",      P_BOOL,                (char_u *)&p_ea},
  155. X        {"equalprg",    "ep",      P_STRING|P_EXPAND,    (char_u *)&p_ep},
  156. X        {"errorbells",    "eb",    P_BOOL,                (char_u *)&p_eb},
  157. X        {"errorfile",    "ef",      P_STRING|P_EXPAND,    (char_u *)&p_ef},
  158. X        {"errorformat",    "efm",     P_STRING,            (char_u *)&p_efm},
  159. X        {"esckeys",        "ek",    P_BOOL,                (char_u *)&p_ek},
  160. X        {"expandtab",    "et",    P_BOOL|P_IND,        (char_u *)PV_ET},
  161. X        {"exrc",        NULL,    P_BOOL,                (char_u *)&p_exrc},
  162. X        {"formatprg",    "fp",      P_STRING|P_EXPAND,    (char_u *)&p_fp},
  163. X        {"gdefault",    "gd",    P_BOOL,                (char_u *)&p_gd},
  164. X        {"graphic",        "gr",    P_BOOL,                (char_u *)&p_gr},
  165. X        {"hardtabs",    "ht",    P_NUM,                (char_u *)NULL},
  166. X        {"helpfile",    "hf",      P_STRING|P_EXPAND,    (char_u *)&p_hf},
  167. X        {"hidden",        "hid",    P_BOOL,                (char_u *)&p_hid},
  168. X        {"highlight",    "hl",    P_STRING,            (char_u *)&p_hl},
  169. X        {"history",     "hi",     P_NUM,                (char_u *)&p_hi},
  170. X        {"icon",         NULL,    P_BOOL,                (char_u *)&p_icon},
  171. X        {"ignorecase",    "ic",    P_BOOL,                (char_u *)&p_ic},
  172. X        {"insertmode",    "im",    P_BOOL,                (char_u *)&p_im},
  173. X        {"joinspaces",     "js",    P_BOOL,                (char_u *)&p_js},
  174. X        {"keywordprg",    "kp",      P_STRING|P_EXPAND,    (char_u *)&p_kp},
  175. X        {"laststatus",    "ls",     P_NUM,                (char_u *)&p_ls},
  176. X        {"lines",        NULL,     P_NUM,                (char_u *)&Rows},
  177. X        {"lisp",        NULL,    P_BOOL,                (char_u *)NULL},
  178. X        {"list",        NULL,    P_BOOL|P_IND,        (char_u *)PV_LIST},
  179. X        {"magic",        NULL,    P_BOOL,                (char_u *)&p_magic},
  180. X        {"makeprg",        "mp",      P_STRING|P_EXPAND,    (char_u *)&p_mp},
  181. X        {"maxmem",        "mm",    P_NUM,                (char_u *)&p_mm},
  182. X        {"maxmemtot",    "mmt",    P_NUM,                (char_u *)&p_mmt},
  183. X        {"mesg",        NULL,    P_BOOL,                (char_u *)NULL},
  184. X        {"modeline",    "ml",    P_BOOL|P_IND,        (char_u *)PV_ML},
  185. X        {"modelines",    "mls",    P_NUM,                (char_u *)&p_mls},
  186. X        {"more",        NULL,    P_BOOL,                (char_u *)&p_more},
  187. X        {"nobuf",        "nb",    P_BOOL,                (char_u *)&p_nb},
  188. X        {"number",        "nu",    P_BOOL|P_IND,        (char_u *)PV_NU},
  189. X        {"open",        NULL,    P_BOOL,                (char_u *)NULL},
  190. X        {"optimize",    "opt",    P_BOOL,                (char_u *)NULL},
  191. X        {"paragraphs",    "para",    P_STRING,            (char_u *)&p_para},
  192. X        {"paste",        NULL,    P_BOOL,                (char_u *)&p_paste},
  193. X        {"patchmode",   "pm",   P_STRING,            (char_u *)&p_pm},
  194. X        {"path",        "pa",      P_STRING|P_EXPAND,    (char_u *)&p_path},
  195. X        {"prompt",        NULL,    P_BOOL,                (char_u *)NULL},
  196. X        {"readonly",    "ro",    P_BOOL|P_IND,        (char_u *)PV_RO},
  197. X        {"redraw",        NULL,    P_BOOL,                (char_u *)NULL},
  198. X        {"remap",        NULL,    P_BOOL,                (char_u *)&p_remap},
  199. X        {"report",        NULL,    P_NUM,                (char_u *)&p_report},
  200. X        {"revins",        "ri",    P_BOOL,                (char_u *)&p_ri},
  201. X        {"ruler",        "ru",    P_BOOL,                (char_u *)&p_ru},
  202. X        {"scroll",        NULL,     P_NUM|P_IND,        (char_u *)PV_SCROLL},
  203. X        {"scrolljump",    "sj",     P_NUM,                (char_u *)&p_sj},
  204. X        {"sections",    "sect",    P_STRING,            (char_u *)&p_sections},
  205. X        {"secure",        NULL,    P_BOOL,                (char_u *)&p_secure},
  206. X        {"shell",        "sh",    P_STRING|P_EXPAND,    (char_u *)&p_sh},
  207. X        {"shellpipe",    "sp",    P_STRING,            (char_u *)&p_sp},
  208. X        {"shelltype",    "st",    P_NUM,                (char_u *)&p_st},
  209. X        {"shiftround",    "sr",    P_BOOL,                (char_u *)&p_sr},
  210. X        {"shiftwidth",    "sw",    P_NUM|P_IND,        (char_u *)PV_SW},
  211. X#ifndef MSDOS
  212. X        {"shortname",    "sn",    P_BOOL|P_IND,        (char_u *)PV_SN},
  213. X#endif
  214. X        {"showcmd",        "sc",    P_BOOL,                (char_u *)&p_sc},
  215. X        {"showmatch",    "sm",    P_BOOL,                (char_u *)&p_sm},
  216. X        {"showmode",    "smd",    P_BOOL,                (char_u *)&p_smd},
  217. X        {"sidescroll",    "ss",    P_NUM,                (char_u *)&p_ss},
  218. X        {"slowopen",    "slow",    P_BOOL,                (char_u *)NULL},
  219. X        {"smartindent", "si",    P_BOOL|P_IND,        (char_u *)PV_SI},
  220. X        {"smarttab",    "sta",    P_BOOL,                (char_u *)&p_sta},
  221. X        {"sourceany",    NULL,    P_BOOL,                (char_u *)NULL},
  222. X        {"splitbelow",    "sb",    P_BOOL,                (char_u *)&p_sb},
  223. X        {"suffixes",    "su",    P_STRING,            (char_u *)&p_su},
  224. X        {"tabstop",     "ts",    P_NUM|P_IND,        (char_u *)PV_TS},
  225. X        {"taglength",    "tl",    P_NUM,                (char_u *)&p_tl},
  226. X        {"tagrelative",    "tr",    P_BOOL,                (char_u *)&p_tr},
  227. X        {"tags",        NULL,    P_STRING|P_EXPAND,    (char_u *)&p_tags},
  228. X        {"term",        NULL,    P_STRING|P_EXPAND,    (char_u *)&term_strings.t_name},
  229. X        {"terse",        NULL,    P_BOOL,                (char_u *)&p_terse},
  230. X        {"textauto",    "ta",    P_BOOL,                (char_u *)&p_ta},
  231. X        {"textmode",    "tx",    P_BOOL|P_IND,        (char_u *)PV_TX},
  232. X        {"textwidth",    "tw",    P_NUM|P_IND,        (char_u *)PV_TW},
  233. X        {"tildeop",     "to",    P_BOOL,                (char_u *)&p_to},
  234. X        {"timeout",     NULL,    P_BOOL,                (char_u *)&p_timeout},
  235. X        {"timeoutlen",    "tm",    P_NUM,                (char_u *)&p_tm},
  236. X        {"title",         NULL,    P_BOOL,                (char_u *)&p_title},
  237. X        {"ttimeout",     NULL,    P_BOOL,                (char_u *)&p_ttimeout},
  238. X        {"ttyfast",     "tf",    P_BOOL,                (char_u *)&p_tf},
  239. X        {"ttytype",        NULL,    P_STRING,            (char_u *)NULL},
  240. X        {"undolevels",    "ul",    P_NUM,                (char_u *)&p_ul},
  241. X        {"updatecount",    "uc",    P_NUM,                (char_u *)&p_uc},
  242. X        {"updatetime",    "ut",    P_NUM,                (char_u *)&p_ut},
  243. X        {"visualbell",    "vb",    P_BOOL,                (char_u *)&p_vb},
  244. X        {"w300",        NULL,     P_NUM,                (char_u *)NULL},
  245. X        {"w1200",        NULL,     P_NUM,                (char_u *)NULL},
  246. X        {"w9600",        NULL,     P_NUM,                (char_u *)NULL},
  247. X        {"warn",        NULL,    P_BOOL,                (char_u *)&p_warn},
  248. X        {"weirdinvert",    "wi",    P_BOOL,                (char_u *)&p_wi},
  249. X        {"whichwrap",    "ww",    P_NUM,                (char_u *)&p_ww},
  250. X        {"wildchar",    "wc",     P_NUM,                (char_u *)&p_wc},
  251. X        {"window",        NULL,     P_NUM,                (char_u *)NULL},
  252. X        {"winheight",    "wh",    P_NUM,                (char_u *)&p_wh},
  253. X        {"wrap",        NULL,    P_BOOL|P_IND,        (char_u *)PV_WRAP},
  254. X        {"wrapmargin",    "wm",    P_NUM|P_IND,        (char_u *)PV_WM},
  255. X        {"wrapscan",    "ws",    P_BOOL,                (char_u *)&p_ws},
  256. X        {"writeany",    "wa",    P_BOOL,                (char_u *)&p_wa},
  257. X        {"writebackup",    "wb",    P_BOOL,                (char_u *)&p_wb},
  258. X        {"yankendofline", "ye",    P_BOOL,                (char_u *)&p_ye},
  259. X
  260. X/* terminal output codes */
  261. X        {"t_cdl",        NULL,    P_STRING,    (char_u *)&term_strings.t_cdl},
  262. X        {"t_ci",        NULL,    P_STRING,    (char_u *)&term_strings.t_ci},
  263. X        {"t_cil",        NULL,    P_STRING,    (char_u *)&term_strings.t_cil},
  264. X        {"t_cm",        NULL,    P_STRING,    (char_u *)&term_strings.t_cm},
  265. X        {"t_cri",        NULL,    P_STRING,    (char_u *)&term_strings.t_cri},
  266. X        {"t_cv",        NULL,    P_STRING,    (char_u *)&term_strings.t_cv},
  267. X        {"t_cvv",        NULL,    P_STRING,    (char_u *)&term_strings.t_cvv},
  268. X        {"t_dl",        NULL,    P_STRING,    (char_u *)&term_strings.t_dl},
  269. X        {"t_cs",        NULL,    P_STRING,    (char_u *)&term_strings.t_cs},
  270. X        {"t_ed",        NULL,    P_STRING,    (char_u *)&term_strings.t_ed},
  271. X        {"t_el",        NULL,    P_STRING,    (char_u *)&term_strings.t_el},
  272. X        {"t_il",        NULL,    P_STRING,    (char_u *)&term_strings.t_il},
  273. X        {"t_ke",        NULL,    P_STRING,    (char_u *)&term_strings.t_ke},
  274. X        {"t_ks",        NULL,    P_STRING,    (char_u *)&term_strings.t_ks},
  275. X        {"t_ms",        NULL,    P_STRING,    (char_u *)&term_strings.t_ms},
  276. X        {"t_se",        NULL,    P_STRING,    (char_u *)&term_strings.t_se},
  277. X        {"t_so",        NULL,    P_STRING,    (char_u *)&term_strings.t_so},
  278. X        {"t_ti",        NULL,    P_STRING,    (char_u *)&term_strings.t_ti},
  279. X        {"t_tb",        NULL,    P_STRING,    (char_u *)&term_strings.t_tb},
  280. X        {"t_tp",        NULL,    P_STRING,    (char_u *)&term_strings.t_tp},
  281. X        {"t_sr",        NULL,    P_STRING,    (char_u *)&term_strings.t_sr},
  282. X        {"t_te",        NULL,    P_STRING,    (char_u *)&term_strings.t_te},
  283. X        {"t_ts",        NULL,    P_STRING,    (char_u *)&term_strings.t_ts},
  284. X        {"t_vb",        NULL,    P_STRING,    (char_u *)&term_strings.t_vb},
  285. X
  286. X/* terminal key codes */
  287. X        {"t_ku",        NULL,    P_STRING,    (char_u *)&term_strings.t_ku},
  288. X        {"t_kd",        NULL,    P_STRING,    (char_u *)&term_strings.t_kd},
  289. X        {"t_kr",        NULL,    P_STRING,    (char_u *)&term_strings.t_kr},
  290. X        {"t_kl",        NULL,    P_STRING,    (char_u *)&term_strings.t_kl},
  291. X        {"t_sku",        NULL,    P_STRING,    (char_u *)&term_strings.t_sku},
  292. X        {"t_skd",        NULL,    P_STRING,    (char_u *)&term_strings.t_skd},
  293. X        {"t_skr",        NULL,    P_STRING,    (char_u *)&term_strings.t_skr},
  294. X        {"t_skl",        NULL,    P_STRING,    (char_u *)&term_strings.t_skl},
  295. X        {"t_f1",        NULL,    P_STRING,    (char_u *)&term_strings.t_f1},
  296. X        {"t_f2",        NULL,    P_STRING,    (char_u *)&term_strings.t_f2},
  297. X        {"t_f3",        NULL,    P_STRING,    (char_u *)&term_strings.t_f3},
  298. X        {"t_f4",        NULL,    P_STRING,    (char_u *)&term_strings.t_f4},
  299. X        {"t_f5",        NULL,    P_STRING,    (char_u *)&term_strings.t_f5},
  300. X        {"t_f6",        NULL,    P_STRING,    (char_u *)&term_strings.t_f6},
  301. X        {"t_f7",        NULL,    P_STRING,    (char_u *)&term_strings.t_f7},
  302. X        {"t_f8",        NULL,    P_STRING,    (char_u *)&term_strings.t_f8},
  303. X        {"t_f9",        NULL,    P_STRING,    (char_u *)&term_strings.t_f9},
  304. X        {"t_f10",        NULL,    P_STRING,    (char_u *)&term_strings.t_f10},
  305. X        {"t_sf1",        NULL,    P_STRING,    (char_u *)&term_strings.t_sf1},
  306. X        {"t_sf2",        NULL,    P_STRING,    (char_u *)&term_strings.t_sf2},
  307. X        {"t_sf3",        NULL,    P_STRING,    (char_u *)&term_strings.t_sf3},
  308. X        {"t_sf4",        NULL,    P_STRING,    (char_u *)&term_strings.t_sf4},
  309. X        {"t_sf5",        NULL,    P_STRING,    (char_u *)&term_strings.t_sf5},
  310. X        {"t_sf6",        NULL,    P_STRING,    (char_u *)&term_strings.t_sf6},
  311. X        {"t_sf7",        NULL,    P_STRING,    (char_u *)&term_strings.t_sf7},
  312. X        {"t_sf8",        NULL,    P_STRING,    (char_u *)&term_strings.t_sf8},
  313. X        {"t_sf9",        NULL,    P_STRING,    (char_u *)&term_strings.t_sf9},
  314. X        {"t_sf10",        NULL,    P_STRING,    (char_u *)&term_strings.t_sf10},
  315. X        {"t_help",        NULL,    P_STRING,    (char_u *)&term_strings.t_help},
  316. X        {"t_undo",        NULL,    P_STRING,    (char_u *)&term_strings.t_undo},
  317. X        {"t_csc",        NULL,    P_STRING,    (char_u *)&term_strings.t_csc},
  318. X        {NULL, NULL, 0, NULL}            /* end marker */
  319. X};
  320. X
  321. X#define PARAM_COUNT (sizeof(params) / sizeof(struct param))
  322. X
  323. Xstatic void param_expand __ARGS((int, int));
  324. Xstatic int findparam __ARGS((char_u *));
  325. Xstatic void    showparams __ARGS((int));
  326. Xstatic void showonep __ARGS((struct param *));
  327. Xstatic int  istermparam __ARGS((struct param *));
  328. Xstatic char_u *get_varp __ARGS((struct param *));
  329. X
  330. X/*
  331. X * Initialize the shell parameter and scroll size.
  332. X */
  333. X    void
  334. Xset_init()
  335. X{
  336. X    char_u    *p;
  337. X    int        i;
  338. X
  339. X    if ((p = vimgetenv((char_u *)"SHELL")) != NULL
  340. X#ifdef MSDOS
  341. X            || (p = vimgetenv((char_u *)"COMSPEC")) != NULL
  342. X#endif
  343. X                                                            )
  344. X    {
  345. X        p = strsave(p);
  346. X        if (p != NULL)        /* we don't want a NULL */
  347. X            p_sh = p;
  348. X    }
  349. X
  350. X#ifdef UNIX
  351. X    /*
  352. X     * Default for p_sp is "| tee".
  353. X     * For known shells it is changed here to include stderr.
  354. X     */
  355. X    p = gettail(p_sh);
  356. X    if (     STRCMP(p, "csh") == 0 ||
  357. X             STRCMP(p, "tcsh") == 0 ||
  358. X             STRCMP(p, "zsh") == 0)
  359. X        p_sp = (char_u *)"|& tee";
  360. X    else if (STRCMP(p, "sh") == 0 ||
  361. X             STRCMP(p, "ksh") == 0 ||
  362. X             STRCMP(p, "bash") == 0)
  363. X        p_sp = (char_u *)"2>&1| tee";
  364. X#endif
  365. X
  366. X    curwin->w_p_scroll = (Rows >> 1);
  367. X    comp_col();
  368. X
  369. X/*
  370. X * set the options in curwin and curbuf that are non-zero
  371. X */
  372. X    curwin->w_p_wrap = TRUE;
  373. X    curbuf->b_p_ml = TRUE;
  374. X    curbuf->b_p_sw = 8;
  375. X    curbuf->b_p_ts = 8;
  376. X#ifdef MSDOS
  377. X    curbuf->b_p_tx = TRUE;        /* texmode is default for MSDOS */
  378. X#endif
  379. X
  380. X    /*
  381. X     * expand environment variables in some string options
  382. X     */
  383. X    for (i = 0; params[i].fullname != NULL; i++)
  384. X        param_expand(i, FALSE);
  385. X    
  386. X    /*
  387. X     * may adjust p_mmt and p_mm for available memory
  388. X     */
  389. X    if (p_mmt == 0)
  390. X    {
  391. X        p_mmt = (mch_avail_mem(FALSE) >> 11);
  392. X        if (p_mm > p_mmt)
  393. X            p_mm = p_mmt;
  394. X    }
  395. X}
  396. X
  397. X/*
  398. X * parse 'arg' for option settings
  399. X * 'arg' may be IObuff, but only when no errors can be present and parameter
  400. X * does not need to be expanded with param_expand().
  401. X *
  402. X * return FAIL if errors are detected, OK otherwise
  403. X */
  404. X    int
  405. Xdoset(arg)
  406. X    char_u        *arg;    /* parameter string (may be written to!) */
  407. X{
  408. X    register int i;
  409. X    char_u        *s;
  410. X    char_u        *errmsg;
  411. X    char_u        *startarg;
  412. X    int            prefix;    /* 0: nothing, 1: "no", 2: "inv" in front of name */
  413. X    int         nextchar;
  414. X    int         len;
  415. X    int         flags;                /* flags for current option */
  416. X    char_u        *varp;                /* pointer to variable for current option */
  417. X    int            errcnt = 0;            /* number of errornous entries */
  418. X    long        oldRows = Rows;        /* remember old Rows */
  419. X    int            oldpaste = p_paste;    /* remember old paste option */
  420. X    long        oldch = p_ch;        /* remember old command line height */
  421. X    int            oldea = p_ea;        /* remember old 'equalalways' */
  422. X    long        olduc = p_uc;        /* remember old 'updatecount' */
  423. X    static int    save_sm = 0;        /* saved options for 'paste' */
  424. X    static int    save_ru = 0;
  425. X    static int    save_ri = 0;
  426. X    int            did_show = FALSE;    /* already showed one value */
  427. X    WIN            *wp;
  428. X
  429. X    if (*arg == NUL)
  430. X    {
  431. X        showparams(0);
  432. X        return OK;
  433. X    }
  434. X    if (STRNCMP(arg, "all", (size_t)3) == 0)
  435. X    {
  436. X        showparams(1);
  437. X        return OK;
  438. X    }
  439. X    if (STRNCMP(arg, "termcap", (size_t)7) == 0)
  440. X    {
  441. X        showparams(2);
  442. X        return OK;
  443. X    }
  444. X
  445. X    while (*arg)        /* loop to process all parameters */
  446. X    {
  447. X        errmsg = NULL;
  448. X        startarg = arg;        /* remember for error message */
  449. X        prefix = 1;
  450. X        if (STRNCMP(arg, "no", (size_t)2) == 0)
  451. X        {
  452. X            prefix = 0;
  453. X            arg += 2;
  454. X        }
  455. X        else if (STRNCMP(arg, "inv", (size_t)3) == 0)
  456. X        {
  457. X            prefix = 2;
  458. X            arg += 3;
  459. X        }
  460. X            /* find end of name */
  461. X        for (len = 0; isalnum(arg[len]) || arg[len] == '_'; ++len)
  462. X            ;
  463. X        nextchar = arg[len];
  464. X        arg[len] = 0;                                /* name ends with 0 */
  465. X        i = findparam(arg);
  466. X        arg[len] = nextchar;                        /* restore nextchar */
  467. X
  468. X        if (i == -1)        /* found a mismatch: skip the rest */
  469. X        {
  470. X            errmsg = (char_u *)"Unknown option";
  471. X            goto skip;
  472. X        }
  473. X
  474. X        if (!params[i].var)            /* hidden option */
  475. X            goto skip;
  476. X
  477. X        flags = params[i].flags;
  478. X        varp = get_varp(&(params[i]));
  479. X
  480. X        /*
  481. X         * allow '=' and ':' as MSDOS command.com allows only one
  482. X         * '=' character per "set" command line. grrr. (jw)
  483. X         */
  484. X        if (nextchar == '?' || 
  485. X            (prefix == 1 && nextchar != '=' &&
  486. X             nextchar != ':' && !(flags & P_BOOL)))
  487. X        {                                        /* print value */
  488. X            if (did_show)
  489. X                msg_outchar('\n');        /* cursor below last one */
  490. X            else
  491. X            {
  492. X                gotocmdline(TRUE, NUL);    /* cursor at status line */
  493. X                did_show = TRUE;        /* remember that we did a line */
  494. X            }
  495. X            showonep(¶ms[i]);
  496. X        }
  497. X        else
  498. X        {
  499. X            if (nextchar != NUL && strchr("=: \t", nextchar) == NULL)
  500. X            {
  501. X                errmsg = e_invarg;
  502. X                goto skip;
  503. X            }
  504. X            else if (flags & P_BOOL)                    /* boolean */
  505. X            {
  506. X                if (nextchar == '=' || nextchar == ':')
  507. X                {
  508. X                    errmsg = e_invarg;
  509. X                    goto skip;
  510. X                }
  511. X                /*
  512. X                 * in secure mode, setting of the secure option is not allowed
  513. X                 */
  514. X                if (secure && (int *)varp == &p_secure)
  515. X                {
  516. X                    errmsg = (char_u *)"not allowed here";
  517. X                    goto skip;
  518. X                }
  519. X                if (prefix == 2)
  520. X                    *(int *)(varp) ^= 1;    /* invert it */
  521. X                else
  522. X                    *(int *)(varp) = prefix;
  523. X                    /* handle compatible option here */
  524. X                if ((int *)varp == &p_cp && p_cp)
  525. X                {
  526. X                    p_bs = 0;        /* normal backspace */
  527. X                    p_ww = 0;        /* backspace and space do not wrap */
  528. X                    p_bk = 0;        /* no backup file */
  529. X#ifdef DIGRAPHS
  530. X                    p_dg = 0;        /* no digraphs */
  531. X#endif /* DIGRAPHS */
  532. X                    p_ek = 0;        /* no ESC keys in insert mode */
  533. X                    curbuf->b_p_et = 0;        /* no expansion of tabs */
  534. X                    p_gd = 0;        /* /g is not default for :s */
  535. X                    p_hi = 0;         /* no history */
  536. X                    p_im = 0;        /* do not start in insert mode */
  537. X                    p_js = 1;        /* insert 2 spaces after period */
  538. X                    curbuf->b_p_ml = 0;        /* no modelines */
  539. X                    p_more = 0;        /* no -- more -- for listings */
  540. X                    p_ru = 0;        /* no ruler */
  541. X                    p_ri = 0;        /* no reverse insert */
  542. X                    p_sj = 1;        /* no scrolljump */
  543. X                    p_sr = 0;        /* do not round indent to shiftwidth */
  544. X                    p_sc = 0;        /* no showcommand */
  545. X                    p_smd = 0;        /* no showmode */
  546. X                    curbuf->b_p_si = 0;        /* no smartindent */
  547. X                    p_sta = 0;        /* no smarttab */
  548. X                    p_ta = 0;        /* no automatic textmode detection */
  549. X                    curbuf->b_p_tw = 0;        /* no automatic line wrap */
  550. X                    p_to = 0;        /* no tilde operator */
  551. X                    p_ttimeout = 0;    /* no terminal timeout */
  552. X                    p_tr = 0;        /* tag file names not relative */
  553. X                    p_ul = 0;        /* no multilevel undo */
  554. X                    p_uc = 0;        /* no autoscript file */
  555. X                    p_wb = 0;        /* no backup file */
  556. X                    if (p_wc == TAB)
  557. X                        p_wc = Ctrl('E');    /* normal use for TAB */
  558. X                    p_ye = 0;        /* no yank to end of line */
  559. X                }
  560. X                if ((int *)varp == &curbuf->b_p_bin && curbuf->b_p_bin)    /* handle bin */
  561. X                {
  562. X                    curbuf->b_p_tw = 0;        /* no automatic line wrap */
  563. X                    curbuf->b_p_wm = 0;        /* no automatic line wrap */
  564. X                    curbuf->b_p_tx = 0;        /* no text mode */
  565. X                    p_ta = 0;                /* no text auto */
  566. X                    curbuf->b_p_ml = 0;        /* no modelines */
  567. X                    curbuf->b_p_et = 0;        /* no expandtab */
  568. X                }
  569. X                if ((int *)varp == &p_paste)    /* handle paste here */
  570. X                {
  571. X                    BUF        *buf;
  572. X
  573. X                    if (p_paste && !oldpaste)    /* paste switched on */
  574. X                    {
  575. X                            /* save and set options for all buffers */
  576. X                        for (buf = firstbuf; buf != NULL; buf = buf->b_next)
  577. X                        {
  578. X                            buf->b_p_tw_save = buf->b_p_tw;
  579. X                            buf->b_p_wm_save = buf->b_p_wm;
  580. X                            buf->b_p_ai_save = buf->b_p_ai;
  581. X                            buf->b_p_si_save = buf->b_p_si;
  582. X                            buf->b_p_tw = 0;        /* textwidth is 0 */
  583. X                            buf->b_p_wm = 0;        /* wrapmargin is 0 */
  584. X                            buf->b_p_ai = 0;        /* no auto-indent */
  585. X                            buf->b_p_si = 0;        /* no smart-indent */
  586. X                        }
  587. X                            /* save and set global options */
  588. X                        save_sm = p_sm;
  589. X                        save_ru = p_ru;
  590. X                        save_ri = p_ri;
  591. X                        p_sm = 0;                /* no showmatch */
  592. X                        p_ru = 0;                /* no ruler */
  593. X                        p_ri = 0;                /* no reverse insert */
  594. X                    }
  595. X                    else if (!p_paste && oldpaste)    /* paste switched off */
  596. X                    {
  597. X                            /* restore options for all buffers */
  598. X                        for (buf = firstbuf; buf != NULL; buf = buf->b_next)
  599. X                        {
  600. X                            buf->b_p_tw = buf->b_p_tw_save;
  601. X                            buf->b_p_ai = buf->b_p_ai_save;
  602. X                            buf->b_p_si = buf->b_p_si_save;
  603. X                        }
  604. X                            /* restore global options */
  605. X                        p_sm = save_sm;
  606. X                        p_ru = save_ru;
  607. X                        p_ri = save_ri;
  608. X                    }
  609. X                }
  610. X                if (!starting && ((int *)varp == &p_title ||
  611. X                                        (int *)varp == &p_icon))
  612. X                {
  613. X                    if (*(int *)varp)            /* Set window title NOW */
  614. X                        maketitle();
  615. X                    else                        /* Reset window title NOW */
  616. X                        mch_restore_title((int *)varp == &p_title ? 1 : 2);
  617. X                }
  618. X            }
  619. X            else                                /* numeric or string */
  620. X            {
  621. X                if ((nextchar != '=' && nextchar != ':') || prefix != 1)
  622. X                {
  623. X                    errmsg = e_invarg;
  624. X                    goto skip;
  625. X                }
  626. X                if (flags & P_NUM)                /* numeric */
  627. X                {
  628. X                    *(long *)(varp) = atol((char *)arg + len + 1);
  629. X
  630. X                    if ((long *)varp == &p_wh)
  631. X                    {
  632. X                        if (p_wh < 0)
  633. X                        {
  634. X                            errmsg = e_positive;
  635. X                            p_wh = 0;
  636. X                        }
  637. X                            /* Change window height NOW */
  638. X                        if (p_wh && lastwin != firstwin)
  639. X                        {
  640. X                            win_equal(curwin, FALSE);
  641. X                            must_redraw = CLEAR;
  642. X                        }
  643. X                    }
  644. X                    if ((long *)varp == &p_ls)
  645. X                        last_status();        /* (re)set last window status line */
  646. X                }
  647. X                else                            /* string */
  648. X                {
  649. X                    arg += len + 1;        /* jump to after the '=' */
  650. X                    s = alloc((unsigned)(STRLEN(arg) + 1)); /* get a bit too much */
  651. X                    if (s == NULL)
  652. X                        break;
  653. X                    if (flags & P_CHANGED)
  654. X                        free(*(char **)(varp));
  655. X                    *(char_u **)(varp) = s;
  656. X                                /* copy the string */
  657. X                    while (*arg && *arg != ' ')
  658. X                    {
  659. X                        if (*arg == '\\' && *(arg + 1)) /* skip over escaped chars */
  660. X                                ++arg;
  661. X                        *s++ = *arg++;
  662. X                    }
  663. X                    *s = NUL;
  664. X                    param_expand(i, TRUE);    /* expand environment variables and ~ */
  665. X                    /*
  666. X                     * options that need some action
  667. X                     * to perform when changed (jw)
  668. X                     */
  669. X                    if (varp == (char_u *)&term_strings.t_name)
  670. X                        set_term(term_strings.t_name);
  671. X                    else if (istermparam(¶ms[i]))
  672. X                    {
  673. X                        ttest(FALSE);
  674. X                        if (varp == (char_u *)&term_strings.t_tp)
  675. X                        {
  676. X                            outstr(T_TP);
  677. X                            updateScreen(CLEAR);
  678. X                        }
  679. X                    }
  680. X                }
  681. X            }
  682. X            params[i].flags |= P_CHANGED;
  683. X        }
  684. X
  685. Xskip:
  686. X        /*
  687. X         * Check the bounds for numeric parameters here
  688. X         */
  689. X        if (Rows < 2)
  690. X        {
  691. X            Rows = 2;
  692. X            errmsg = (char_u *)"Need at least 2 lines";
  693. X        }
  694. X        /*
  695. X         * If the screenheight has been changed, assume it is the physical
  696. X         * screenheight.
  697. X         */
  698. X        if (oldRows != Rows)
  699. X        {
  700. X            screen_new_rows();
  701. X#ifdef MSDOS
  702. X            set_window();        /* active window may have changed */
  703. X#endif
  704. X        }
  705. X
  706. X        if (curbuf->b_p_ts <= 0)
  707. X        {
  708. X            errmsg = e_positive;
  709. X            curbuf->b_p_ts = 8;
  710. X        }
  711. X        if (p_tm < 0)
  712. X        {
  713. X            errmsg = e_positive;
  714. X            p_tm = 0;
  715. X        }
  716. X        if (curwin->w_p_scroll <= 0 || curwin->w_p_scroll > curwin->w_height)
  717. X        {
  718. X            if (curwin->w_p_scroll != 0)
  719. X                errmsg = e_scroll;
  720. X            win_comp_scroll(curwin);
  721. X        }
  722. X        if (p_report < 0)
  723. X        {
  724. X            errmsg = e_positive;
  725. X            p_report = 1;
  726. X        }
  727. X        if (p_sj < 0 || p_sj >= Rows)
  728. X        {
  729. X            errmsg = e_scroll;
  730. X            p_sj = 1;
  731. X        }
  732. X        if (p_uc < 0)
  733. X        {
  734. X            errmsg = e_positive;
  735. X            p_uc = 100;
  736. X        }
  737. X        if (p_ch < 1)
  738. X        {
  739. X            errmsg = e_positive;
  740. X            p_ch = 1;
  741. X        }
  742. X        if (p_ut < 0)
  743. X        {
  744. X            errmsg = e_positive;
  745. X            p_ut = 2000;
  746. X        }
  747. X        if (p_ss < 0)
  748. X        {
  749. X            errmsg = e_positive;
  750. X            p_ss = 0;
  751. X        }
  752. X        if (errmsg)
  753. X        {
  754. X            STRCPY(IObuff, errmsg);
  755. X            STRCAT(IObuff, ": ");
  756. X            s = IObuff + STRLEN(IObuff);
  757. X            while (*startarg && !isspace(*startarg))
  758. X                *s++ = *startarg++;
  759. X            *s = NUL;
  760. X            did_show = TRUE;    /* error message counts as show */
  761. X            ++no_wait_return;    /* wait_return done below */
  762. X            emsg(IObuff);
  763. X            --no_wait_return;
  764. X            arg = startarg;        /* skip to next argument */
  765. X            ++errcnt;            /* count number of errors */
  766. X        }
  767. X        skiptospace(&arg);                /* skip to next white space */
  768. X        skipspace(&arg);                /* skip spaces */
  769. X    }
  770. X
  771. X    /*
  772. X     * when 'updatecount' changes from zero to non-zero, open swap files
  773. X     */
  774. X    if (p_uc && !olduc)
  775. X        ml_open_files();
  776. X
  777. X    if (p_ch != oldch)                    /* p_ch changed value */
  778. X        command_height();
  779. X    comp_col();
  780. X
  781. X    /*
  782. X     * Update the screen in case we changed something like "tabstop" or
  783. X     * "lines" or "list" that will change its appearance.
  784. X     * If we messed up the screen by showing more than one line of param
  785. X     * values or an error message, call wait_return(), which will also
  786. X     * update the screen.
  787. X     */
  788. X    for (wp = firstwin; wp; wp = wp->w_next)
  789. X        wp->w_redr_status = TRUE;        /* mark all status lines dirty */
  790. X    if (p_ea && !oldea)
  791. X        win_equal(curwin, FALSE);
  792. X    if (did_show && msg_check())
  793. X    {
  794. X        msg_outchar('\n');
  795. X        wait_return(TRUE);
  796. X    }
  797. X    else
  798. X        updateScreen(NOT_VALID);
  799. X    return (errcnt == 0 ? OK : FAIL);
  800. X}
  801. X
  802. X/*
  803. X * expand environment variable at the start of some string options
  804. X */
  805. X    static void
  806. Xparam_expand(i, dofree)
  807. X    int        i;
  808. X    int        dofree;
  809. X{
  810. X    char_u *p;
  811. X
  812. X    if ((params[i].flags & P_EXPAND) &&
  813. X                (p = *(char_u **)(params[i].var)) != NULL &&
  814. X                (*p == '$' || *p == '~'))
  815. X    {
  816. X        expand_env(*(char_u **)(params[i].var), IObuff, IOSIZE);
  817. X        p = strsave(IObuff);
  818. X        if (p)
  819. X        {
  820. X            if (dofree)
  821. X                free(*(char_u **)(params[i].var));
  822. X            *(char_u **)(params[i].var) = p;
  823. X        }
  824. X    }
  825. X}
  826. X
  827. X/*
  828. X * find index for option 'arg'
  829. X * return -1 if not found
  830. X */
  831. X    static int
  832. Xfindparam(arg)
  833. X    char_u *arg;
  834. X{
  835. X    int        i;
  836. X    char    *s;
  837. X
  838. X    for (i = 0; (s = params[i].fullname) != NULL; i++)
  839. X    {
  840. X        if (STRCMP(arg, s) == 0) /* match full name */
  841. X            break;
  842. X    }
  843. X    if (s == NULL)
  844. X    {
  845. X        for (i = 0; params[i].fullname != NULL; i++)
  846. X        {
  847. X            s = params[i].shortname;
  848. X            if (s != NULL && STRCMP(arg, s) == 0) /* match short name */
  849. X                break;
  850. X            s = NULL;
  851. X        }
  852. X    }
  853. X    if (s == NULL)
  854. X        i = -1;
  855. X    return i;
  856. X}
  857. X
  858. X/*
  859. X * mark option 'arg' changed
  860. X */
  861. X    void
  862. Xparamchanged(arg)
  863. X    char_u *arg;
  864. X{
  865. X    int i;
  866. X
  867. X    i = findparam(arg);
  868. X    if (i >= 0)
  869. X        params[i].flags |= P_CHANGED;
  870. X}
  871. X
  872. X/*
  873. X * if 'all' == 0: show changed parameters
  874. X * if 'all' == 1: show all normal parameters
  875. X * if 'all' == 2: show all terminal parameters
  876. X */
  877. X    static void
  878. Xshowparams(all)
  879. X    int            all;
  880. X{
  881. X    struct param   *p;
  882. X    int                col;
  883. X    int                isterm;
  884. X    char_u            *varp;
  885. X    struct param    *(items[PARAM_COUNT]);
  886. X    int                item_count;
  887. X    int                run;
  888. X    int                row, rows;
  889. X    int                cols;
  890. X    int                i;
  891. X    int                len;
  892. X
  893. X#define INC    19
  894. X
  895. X    gotocmdline(TRUE, NUL);
  896. X    msg_outstr((char_u *)"--- Parameters ---\n");
  897. X
  898. X    /*
  899. X     * do the loop two times:
  900. X     * 1. display the short items (non-strings and short strings)
  901. X     * 2. display the long items (strings)
  902. X     */
  903. X    for (run = 1; run <= 2 && !got_int; ++run)
  904. X    {
  905. X        /*
  906. X         * collect the items in items[]
  907. X         */
  908. X        item_count = 0;
  909. X        for (p = ¶ms[0]; p->fullname != NULL && !got_int; p++)
  910. X        {
  911. X            isterm = istermparam(p);
  912. X            varp = get_varp(p);
  913. X            if (varp && (
  914. X                (all == 2 && isterm) ||
  915. X                (all == 1 && !isterm) ||
  916. X                (all == 0 && (p->flags & P_CHANGED))))
  917. X            {
  918. X                if ((p->flags & P_STRING) && *(char_u **)(varp) != NULL)
  919. X                    len = STRLEN(p->fullname) + strsize(*(char_u **)(varp));
  920. X                else
  921. X                    len = 1;        /* a non-string is assumed to fit always */
  922. X                if ((len <= INC - 4 && run == 1) || (len > INC - 4 && run == 2))
  923. X                    items[item_count++] = p;
  924. X            }
  925. X            breakcheck();
  926. X        }
  927. X        /*
  928. X         * display the items
  929. X         */
  930. X        if (run == 1)
  931. X        {
  932. X            cols = Columns / INC;
  933. X            if (cols == 0)
  934. X                cols = 1;
  935. X            rows = (item_count + cols - 1) / cols;
  936. X        }
  937. X        else    /* run == 2 */
  938. X            rows = item_count;
  939. X        for (row = 0; row < rows && !got_int; ++row)
  940. X        {
  941. X            col = 0;
  942. X            for (i = row; i < item_count; i += rows)
  943. X            {
  944. X                msg_pos(-1, col);                    /* make columns */
  945. X                showonep(items[i]);
  946. X                col += INC;
  947. X            }
  948. X            msg_outchar('\n');                /* scroll screen one line up */
  949. X            flushbuf();
  950. X            breakcheck();
  951. X        }
  952. X    }
  953. X
  954. X    wait_return(FALSE);
  955. X}
  956. X
  957. X/*
  958. X * showonep: show the value of one option
  959. X * must not be called with a hidden option!
  960. X */
  961. X    static void
  962. Xshowonep(p)
  963. X        struct param *p;
  964. X{
  965. X    char_u            buf[64];
  966. X    char_u            *varp;
  967. X
  968. X    varp = get_varp(p);
  969. X
  970. X    if ((p->flags & P_BOOL) && !*(int *)(varp))
  971. X        msg_outstr((char_u *)"no");
  972. X    else
  973. X        msg_outstr((char_u *)"  ");
  974. X    msg_outstr((char_u *)p->fullname);
  975. X    if (!(p->flags & P_BOOL))
  976. X    {
  977. X        msg_outchar('=');
  978. X        if (p->flags & P_NUM)
  979. X        {
  980. X            sprintf((char *)buf, "%ld", *(long *)(varp));
  981. X            msg_outstr(buf);
  982. X        }
  983. X        else if (*(char_u **)(varp) != NULL)
  984. X        {
  985. X            if (p->flags & P_EXPAND)
  986. X            {
  987. X                home_replace(*(char_u **)(varp), NameBuff, MAXPATHL);
  988. X                msg_outtrans(NameBuff, -1);
  989. X            }
  990. X            else
  991. X                msg_outtrans(*(char_u **)(varp), -1);
  992. X        }
  993. X    }
  994. X}
  995. X
  996. X/*
  997. X * Write modified parameters as set command to a file.
  998. X * Return FAIL on error, OK otherwise.
  999. X */
  1000. X    int
  1001. Xmakeset(fd)
  1002. X    FILE *fd;
  1003. X{
  1004. X    struct param    *p;
  1005. X    char_u            *s;
  1006. X    int                e;
  1007. X    char_u            *varp;
  1008. X
  1009. X    for (p = ¶ms[0]; p->fullname != NULL; p++)
  1010. X        if ((p->flags & P_CHANGED) && p->var)
  1011. X        {
  1012. X            varp = get_varp(p);
  1013. X            if (p->flags & P_BOOL)
  1014. X                fprintf(fd, "set %s%s", *(int *)(varp) ? "" : "no", p->fullname);
  1015. X            else if (p->flags & P_NUM)
  1016. X                fprintf(fd, "set %s=%ld", p->fullname, *(long *)(varp));
  1017. X            else
  1018. X            {
  1019. X                fprintf(fd, "set %s=", p->fullname);
  1020. X                s = *(char_u **)(varp);
  1021. X                    /* some characters hav to be escaped with CTRL-V or backslash */
  1022. X                if (s != NULL && putescstr(fd, s, TRUE) == FAIL)
  1023. X                    return FAIL;
  1024. X            }
  1025. X#ifdef MSDOS
  1026. X            putc('\r', fd);
  1027. X#endif
  1028. X                /*
  1029. X                 * Only check error for this putc, should catch at least
  1030. X                 * the "disk full" situation.
  1031. X                 */
  1032. X            e = putc('\n', fd);
  1033. X            if (e < 0)
  1034. X                return FAIL;
  1035. X        }
  1036. X    return OK;
  1037. X}
  1038. X
  1039. X/*
  1040. X * Clear all the terminal parameters.
  1041. X * If the parameter has been changed, free the allocated memory.
  1042. X * Reset the "changed" flag, so the new value will not be freed.
  1043. X */
  1044. X    void
  1045. Xclear_termparam()
  1046. X{
  1047. X    struct param   *p;
  1048. X
  1049. X    for (p = ¶ms[0]; p->fullname != NULL; p++)
  1050. X        if (istermparam(p))            /* terminal parameters must never be hidden */
  1051. X        {
  1052. X            if (p->flags & P_CHANGED)
  1053. X                free(*(char_u **)(p->var));
  1054. X            *(char_u **)(p->var) = NULL;
  1055. X            p->flags &= ~P_CHANGED;
  1056. X        }
  1057. X}
  1058. X
  1059. X/*
  1060. X * return TRUE if 'p' starts with 't_'
  1061. X */
  1062. X    static int
  1063. Xistermparam(p)
  1064. X    struct param *p;
  1065. X{
  1066. X    return (p->fullname[0] == 't' && p->fullname[1] == '_');
  1067. X}
  1068. X
  1069. X/*
  1070. X * Compute columns for ruler and shown command. 'sc_col' is also used to
  1071. X * decide what the maximum length of a message on the status line can be.
  1072. X * If there is a status line for the last window, 'sc_col' is independent
  1073. X * of 'ru_col'.
  1074. X */
  1075. X
  1076. X#define COL_SHOWCMD 10        /* columns needed by shown command */
  1077. X#define COL_RULER 17        /* columns needed by ruler */
  1078. X
  1079. X    void
  1080. Xcomp_col()
  1081. X{
  1082. X    int last_status = (p_ls == 2 || (p_ls == 1 && firstwin != lastwin));
  1083. X
  1084. X    sc_col = 0;
  1085. X    ru_col = 0;
  1086. X    if (p_ru)
  1087. X    {
  1088. X        ru_col = COL_RULER + 1;
  1089. X                            /* no last status line, adjust sc_col */
  1090. X        if (!last_status)
  1091. X            sc_col = ru_col;
  1092. X    }
  1093. X    if (p_sc)
  1094. X    {
  1095. X        sc_col += COL_SHOWCMD;
  1096. X        if (!p_ru || last_status)        /* no need for separating space */
  1097. X            ++sc_col;
  1098. X    }
  1099. X    sc_col = Columns - sc_col;
  1100. X    ru_col = Columns - ru_col;
  1101. X    if (sc_col <= 0)            /* screen too narrow, will become a mess */
  1102. X        sc_col = 1;
  1103. X    if (ru_col <= 0)
  1104. X        ru_col = 1;
  1105. X}
  1106. X
  1107. X    static char_u *
  1108. Xget_varp(p)
  1109. X    struct param    *p;
  1110. X{
  1111. X    if (!(p->flags & P_IND))
  1112. X        return p->var;
  1113. X
  1114. X    switch ((long)(p->var))
  1115. X    {
  1116. X        case PV_LIST:    return (char_u *)&(curwin->w_p_list);
  1117. X        case PV_NU:        return (char_u *)&(curwin->w_p_nu);
  1118. X        case PV_SCROLL:    return (char_u *)&(curwin->w_p_scroll);
  1119. X        case PV_WRAP:    return (char_u *)&(curwin->w_p_wrap);
  1120. X
  1121. X        case PV_AI:        return (char_u *)&(curbuf->b_p_ai);
  1122. X        case PV_BIN:    return (char_u *)&(curbuf->b_p_bin);
  1123. X        case PV_EOL:    return (char_u *)&(curbuf->b_p_eol);
  1124. X        case PV_ET:        return (char_u *)&(curbuf->b_p_et);
  1125. X        case PV_ML:        return (char_u *)&(curbuf->b_p_ml);
  1126. X        case PV_RO:        return (char_u *)&(curbuf->b_p_ro);
  1127. X        case PV_SI:        return (char_u *)&(curbuf->b_p_si);
  1128. X        case PV_SN:        return (char_u *)&(curbuf->b_p_sn);
  1129. X        case PV_SW:        return (char_u *)&(curbuf->b_p_sw);
  1130. X        case PV_TS:        return (char_u *)&(curbuf->b_p_ts);
  1131. X        case PV_TW:        return (char_u *)&(curbuf->b_p_tw);
  1132. X        case PV_TX:        return (char_u *)&(curbuf->b_p_tx);
  1133. X        case PV_WM:        return (char_u *)&(curbuf->b_p_wm);
  1134. X        default:        EMSG("get_varp ERROR");
  1135. X    }
  1136. X    /* always return a valid pointer to avoid a crash! */
  1137. X    return (char_u *)&(curbuf->b_p_wm);
  1138. X}
  1139. X
  1140. X/*
  1141. X * Copy options from one window to another.
  1142. X * Used when creating a new window.
  1143. X */
  1144. X    void
  1145. Xwin_copy_options(wp_from, wp_to)
  1146. X    WIN        *wp_from;
  1147. X    WIN        *wp_to;
  1148. X{
  1149. X    wp_to->w_p_list = wp_from->w_p_list;
  1150. X    wp_to->w_p_nu = wp_from->w_p_nu;
  1151. X    wp_to->w_p_scroll = wp_from->w_p_scroll;
  1152. X    wp_to->w_p_wrap = wp_from->w_p_wrap;
  1153. X}
  1154. X
  1155. X/*
  1156. X * Copy options from one buffer to another.
  1157. X * Used when creating a new buffer.
  1158. X */
  1159. X    void
  1160. Xbuf_copy_options(bp_from, bp_to)
  1161. X    BUF        *bp_from;
  1162. X    BUF        *bp_to;
  1163. X{
  1164. X    bp_to->b_p_ai = bp_from->b_p_ai;
  1165. X    bp_to->b_p_si = bp_from->b_p_si;
  1166. X    bp_to->b_p_ro = bp_from->b_p_ro;
  1167. X    bp_to->b_p_sw = bp_from->b_p_sw;
  1168. X    bp_to->b_p_ts = bp_from->b_p_ts;
  1169. X    bp_to->b_p_tw = bp_from->b_p_tw;
  1170. X    bp_to->b_p_wm = bp_from->b_p_wm;
  1171. X    bp_to->b_p_bin = bp_from->b_p_bin;
  1172. X    bp_to->b_p_et = bp_from->b_p_et;
  1173. X    bp_to->b_p_ml = bp_from->b_p_ml;
  1174. X    bp_to->b_p_sn = bp_from->b_p_sn;
  1175. X    bp_to->b_p_tx = bp_from->b_p_tx;
  1176. X}
  1177. X
  1178. X#ifdef WEBB_COMPLETE
  1179. X    void
  1180. Xset_context_in_set_cmd(arg)
  1181. X    char_u *arg;
  1182. X{
  1183. X    int         nextchar;
  1184. X    int         flags;
  1185. X    int            i;
  1186. X    char_u        *p;
  1187. X    char_u        *after_blank = NULL;
  1188. X
  1189. X    expand_context = EXPAND_SETTINGS;
  1190. X    if (*arg == NUL)
  1191. X    {
  1192. X        expand_pattern = arg;
  1193. X        return;
  1194. X    }
  1195. X    p = arg + STRLEN(arg) - 1;
  1196. X    if (*p == ' ' && *(p - 1) != '\\')
  1197. X    {
  1198. X        expand_pattern = p + 1;
  1199. X        return;
  1200. X    }
  1201. X    while (p != arg && (*p != ' ' || *(p - 1) == '\\'))
  1202. X    {
  1203. X        if (*p == ' ' && after_blank == NULL)
  1204. X            after_blank = p + 1;
  1205. X        p--;
  1206. X    }
  1207. X    if (p != arg)
  1208. X        p++;
  1209. X    if (STRNCMP(p, "no", (size_t) 2) == 0)
  1210. X    {
  1211. X        expand_context = EXPAND_BOOL_SETTINGS;
  1212. X        p += 2;
  1213. X    }
  1214. X    if (STRNCMP(p, "inv", (size_t) 3) == 0)
  1215. X    {
  1216. X        expand_context = EXPAND_BOOL_SETTINGS;
  1217. X        p += 3;
  1218. X    }
  1219. X    expand_pattern = arg = p;
  1220. X    while (isalnum(*p) || *p == '_' || *p == '*')    /* Allow * as wildcard */
  1221. X        p++;
  1222. X    if (*p == NUL)
  1223. X        return;
  1224. X    nextchar = *p;
  1225. X    *p = NUL;
  1226. X    i = findparam(arg);
  1227. X    *p = nextchar;
  1228. X    if (i == -1 || params[i].var == NULL)
  1229. X    {
  1230. X        expand_context = EXPAND_NOTHING;
  1231. X        return;
  1232. X    }
  1233. X    flags = params[i].flags;
  1234. X    if (flags & P_BOOL)
  1235. X    {
  1236. X        expand_context = EXPAND_NOTHING;
  1237. X        return;
  1238. X    }
  1239. X    if ((nextchar != '=' && nextchar != ':')
  1240. X      || expand_context == EXPAND_BOOL_SETTINGS)
  1241. X    {
  1242. X        expand_context = EXPAND_UNSUCCESSFUL;
  1243. X        return;
  1244. X    }
  1245. X    expand_context = EXPAND_NOTHING;
  1246. X    if (flags & P_NUM)
  1247. X        return;
  1248. X    if (after_blank != NULL)
  1249. X        expand_pattern = after_blank;
  1250. X    else
  1251. X        expand_pattern = p + 1;
  1252. X    if (flags & P_EXPAND)
  1253. X    {
  1254. X        p = params[i].var;
  1255. X        if (
  1256. X#ifdef UNIX
  1257. X            p == (char_u *)&p_bdir ||
  1258. X#endif
  1259. X            p == (char_u *)&p_dir || p == (char_u *)&p_path)
  1260. X            expand_context = EXPAND_DIRECTORIES;
  1261. X        else
  1262. X            expand_context = EXPAND_FILES;
  1263. X    }
  1264. X    return;
  1265. X}
  1266. X
  1267. X    int
  1268. XExpandSettings(prog, num_file, file)
  1269. X    regexp *prog;
  1270. X    int *num_file;
  1271. X    char_u ***file;
  1272. X{
  1273. X    int num_normal = 0;        /* Number of matching non-term-code settings */
  1274. X    int num_term = 0;        /* Number of matching terminal code settings */
  1275. X    int i;
  1276. X    int match;
  1277. X    int count;
  1278. X    char_u *str;
  1279. X
  1280. X    if (expand_context != EXPAND_BOOL_SETTINGS)
  1281. X    {
  1282. X        if (regexec(prog, (char_u *)"all", TRUE))
  1283. X            num_normal++;
  1284. X        if (regexec(prog, (char_u *)"termcap", TRUE))
  1285. X            num_normal++;
  1286. X    }
  1287. X    for (i = 0; (str = (char_u *)params[i].fullname) != NULL; i++)
  1288. X    {
  1289. X        if (params[i].var == NULL)
  1290. X            continue;
  1291. X        if (expand_context == EXPAND_BOOL_SETTINGS
  1292. X          && !(params[i].flags & P_BOOL))
  1293. X            continue;
  1294. X        if (istermparam(¶ms[i]) && num_normal > 0)
  1295. X            continue;
  1296. X        match = FALSE;
  1297. X        if (regexec(prog, str, TRUE))
  1298. X            match = TRUE;
  1299. X        else if (params[i].shortname != NULL
  1300. X          && regexec(prog, (char_u *)params[i].shortname, TRUE))
  1301. X            match = TRUE;
  1302. X        if (match)
  1303. X        {
  1304. X            if (istermparam(¶ms[i]))
  1305. X                num_term++;
  1306. X            else
  1307. X                num_normal++;
  1308. X        }
  1309. X    }
  1310. X    if (num_normal > 0)
  1311. X        *num_file = num_normal;
  1312. X    else if (num_term > 0)
  1313. X        *num_file = num_term;
  1314. X    else
  1315. X        return OK;
  1316. X    *file = (char_u **) alloc((unsigned)(*num_file * sizeof(char_u *)));
  1317. X    if (*file == NULL)
  1318. X    {
  1319. X        *file = (char_u **)"";
  1320. X        return FAIL;
  1321. X    }
  1322. X    count = 0;
  1323. X    if (expand_context != EXPAND_BOOL_SETTINGS)
  1324. X    {
  1325. X        if (regexec(prog, (char_u *)"all", TRUE))
  1326. X            (*file)[count++] = strsave((char_u *)"all");
  1327. X        if (regexec(prog, (char_u *)"termcap", TRUE))
  1328. X            (*file)[count++] = strsave((char_u *)"termcap");
  1329. X    }
  1330. X    for (i = 0; (str = (char_u *)params[i].fullname) != NULL; i++)
  1331. X    {
  1332. X        if (params[i].var == NULL)
  1333. X            continue;
  1334. X        if (expand_context == EXPAND_BOOL_SETTINGS
  1335. X          && !(params[i].flags & P_BOOL))
  1336. X            continue;
  1337. X        if (istermparam(¶ms[i]) && num_normal > 0)
  1338. X            continue;
  1339. X        match = FALSE;
  1340. X        if (regexec(prog, str, TRUE))
  1341. X            match = TRUE;
  1342. X        else if (params[i].shortname != NULL
  1343. X          && regexec(prog, (char_u *)params[i].shortname, TRUE))
  1344. X            match = TRUE;
  1345. X        if (match)
  1346. X            (*file)[count++] = strsave(str);
  1347. X    }
  1348. X    return OK;
  1349. X}
  1350. X#endif /* WEBB_COMPLETE */
  1351. END_OF_FILE
  1352.   if test 35665 -ne `wc -c <'vim/src/param.c'`; then
  1353.     echo shar: \"'vim/src/param.c'\" unpacked with wrong size!
  1354.   fi
  1355.   # end of 'vim/src/param.c'
  1356. fi
  1357. if test -f 'vim/src/tags' -a "${1}" != "-c" ; then 
  1358.   echo shar: Will not clobber existing file \"'vim/src/tags'\"
  1359. else
  1360.   echo shar: Extracting \"'vim/src/tags'\" \(29029 characters\)
  1361.   sed "s/^X//" >'vim/src/tags' <<'END_OF_FILE'
  1362. XAppendCharToRedobuff    getchar.c    /^AppendCharToRedobuff(c)$/
  1363. XAppendNumberToRedobuff    getchar.c    /^AppendNumberToRedobuff(n)$/
  1364. XAppendToRedobuff    getchar.c    /^AppendToRedobuff(s)$/
  1365. XCHECK    memfile.c    /^#define CHECK(c, s)    if (c) printf(s)$/
  1366. XChk_Abort    amiga.c    /^Chk_Abort()$/
  1367. XCtrl    ascii.h    /^#define Ctrl(x) ((x) & 0x1f)$/
  1368. XDoOneCmd    cmdline.c    /^DoOneCmd(buff)$/
  1369. XEMSG    vim.h    /^#define EMSG(s)                emsg((char_u *)(s))$/
  1370. XEMSG2    vim.h    /^#define EMSG2(s, p)            emsg2((char_u *)(s), (char_u/
  1371. XEMSG_RETURN    regexp.c    /^#define EMSG_RETURN(m) { emsg(m); return NULL; }$/
  1372. XEXTERN    param.h    /^EXTERN char_u *p_ep    INIT(= (char_u *)"indent");    \/*/
  1373. XExpandFromContext    cmdline.c    /^ExpandFromContext(pat, num_file, file, files_only,/
  1374. XExpandOne    cmdline.c    /^ExpandOne(str, list_notfound, mode)$/
  1375. XExpandSettings    param.c    /^ExpandSettings(prog, num_file, file)$/
  1376. XExpandTags    tag.c    /^ExpandTags(prog, num_file, file)$/
  1377. XExpandWildCards    amiga.c    /^ExpandWildCards(num_pat, pat, num_file, file, file/
  1378. XFreeWild    amiga.c    /^FreeWild(num, file)$/
  1379. XFullName    amiga.c    /^FullName(fname, buf, len)$/
  1380. XGetChars    amiga.c    /^GetChars(buf, maxlen, time)$/
  1381. XINIT    normal.c    /^#define INIT(x) x$/
  1382. XISSPECIAL    edit.c    /^#define ISSPECIAL(c)    ((c) < ' ' || (c) >= DEL)$/
  1383. XMEMHASH    structs.h    /^#define MEMHASH(nr)        ((nr) & (MEMHASHSIZE - 1))$/
  1384. XML_SIMPLE    memline.c    /^#define ML_SIMPLE(x)    (x & 0x10)    \/* DEL, INS or FIN/
  1385. XMP    amiga.c    /^#define MP(xx)    ((struct MsgPort *)((struct FileHan/
  1386. XMSG    vim.h    /^#define MSG(s)                msg((char_u *)(s))$/
  1387. XMaddcr    addcr.c    /^main(argc, argv)$/
  1388. XMagic    regexp.c    /^#define Magic(x)    ((x)|('\\\\'<<8))$/
  1389. XMeta    ascii.h    /^#define Meta(x) ((x) | 0x80)$/
  1390. XMmain    main.c    /^main(argc, argv)$/
  1391. XMmkcmdtab    mkcmdtab.c    /^main(argc, argv)$/
  1392. XNEXT    regexp.c    /^#define NEXT(p) (((*((p)+1)&0377)<<8) + (*((p)+2)&/
  1393. XOP    regexp.c    /^#define OP(p)    (*(p))$/
  1394. XOPERAND    regexp.c    /^#define OPERAND(p)        ((p) + 3)$/
  1395. XOUTSTR    vim.h    /^#define OUTSTR(s)            outstr((char_u *)(s))$/
  1396. XOUTSTRN    vim.h    /^#define OUTSTRN(s)            outstrn((char_u *)(s))$/
  1397. XOpencmd    misccmds.c    /^Opencmd(dir, redraw, delspaces)$/
  1398. XPERR    winnt.c    /^#define PERR(bSuccess, api) {if (!(bSuccess)) perr/
  1399. XPeekChr    regexp.c    /^#define PeekChr() curchr    \/* shortcut only when las/
  1400. XRead    archie.c    /^Read(buf, maxlen)$/
  1401. XRealWaitForChar    archie.c    /^RealWaitForChar(ticks)$/
  1402. XResetRedobuff    getchar.c    /^ResetRedobuff()$/
  1403. XSTRCAT    vim.h    /^#define STRCAT(d, s)        strcat((char *)(d), (char *)/
  1404. XSTRCHR    vim.h    /^#define STRCHR(s, c)        (char_u *)strchr((char *)(s)/
  1405. XSTRCMP    vim.h    /^#define STRCMP(d, s)        strcmp((char *)(d), (char *)/
  1406. XSTRCPY    vim.h    /^#define STRCPY(d, s)        strcpy((char *)(d), (char *)/
  1407. XSTRLEN    vim.h    /^#define STRLEN(s)            strlen((char *)(s))$/
  1408. XSTRNCMP    vim.h    /^#define STRNCMP(d, s, n)    strncmp((char *)(d), (cha/
  1409. XSTRNCPY    vim.h    /^#define STRNCPY(d, s, n)    strncpy((char *)(d), (cha/
  1410. XSTRRCHR    vim.h    /^#define STRRCHR(s, c)        (char_u *)strrchr((char *)(/
  1411. XTGETSTR    term.c    /^# define TGETSTR(s, p)    (char_u *)tgetstr((s), (cha/
  1412. XTO_LOWER    macros.h    /^# define TO_LOWER(c)    (isupper(c) ? tolower(c) : (c/
  1413. XTO_UPPER    macros.h    /^# define TO_UPPER(c)    (islower(c) ? toupper(c) : (c/
  1414. XUCHARAT    regexp.c    /^#define UCHARAT(p)        ((int)*(unsigned char *)(p))$/
  1415. XUNCHANGED    vim.h    /^#define UNCHANGED(buf)    unset_Changed(buf)$/
  1416. XWaitForChar    archie.c    /^WaitForChar(ticks)$/
  1417. X__ARGS    regsub.c    /^# define __ARGS(a)    a$/
  1418. X__PARMS    vim.h    /^# define __PARMS(x)    x$/
  1419. X_addfmt    termlib.c    /^_addfmt(buf, fmt, val)             \/* add val to b/
  1420. X_find    termlib.c    /^_find(s, set)   \/* finds next c in s that's a memb/
  1421. X_match    termlib.c    /^_match(s1, s2)                 \/* returns length o/
  1422. Xadd_buff    getchar.c    /^add_buff(buf, s)$/
  1423. Xadd_char_buff    getchar.c    /^add_char_buff(buf, c)$/
  1424. Xadd_num_buff    getchar.c    /^add_num_buff(buf, n)$/
  1425. Xaddfile    msdos.c    /^addfile(fl, f, isdir)$/
  1426. Xaddstar    cmdline.c    /^addstar(fname, len)$/
  1427. Xadjust_cursor    linefunc.c    /^adjust_cursor()$/
  1428. Xalloc    alloc.c    /^alloc(size)$/
  1429. Xask_yesno    misccmds.c    /^ask_yesno(str)$/
  1430. Xautowrite    cmdline.c    /^autowrite(buf)$/
  1431. Xautowrite_all    cmdline.c    /^autowrite_all()$/
  1432. Xbck_word    search.c    /^bck_word(count, type)$/
  1433. Xbeep    misccmds.c    /^beep()$/
  1434. Xbeginline    edit.c    /^beginline(flag)$/
  1435. Xblock_prep    ops.c    /^block_prep(lnum, delete)$/
  1436. Xbreakcheck    amiga.c    /^breakcheck()$/
  1437. Xbsdmemset    alloc.c    /^bsdmemset(ptr, c, size)$/
  1438. Xbuf_clear    buffer.c    /^buf_clear(buf)$/
  1439. Xbuf_copy_options    param.c    /^buf_copy_options(bp_from, bp_to)$/
  1440. Xbuf_freeall    buffer.c    /^buf_freeall(buf)$/
  1441. Xbuf_modname    fileio.c    /^buf_modname(buf, fname, ext)$/
  1442. Xbuf_write    fileio.c    /^buf_write(buf, fname, sfname, start, end, append, /
  1443. Xbuf_write_all    cmdline.c    /^buf_write_all(buf)$/
  1444. Xbufempty    macros.h    /^#define bufempty() (curbuf->b_ml.ml_flags & ML_EMP/
  1445. Xbuflist_add    buffer.c    /^buflist_add(fname)$/
  1446. Xbuflist_altlnum    buffer.c    /^buflist_altlnum()$/
  1447. Xbuflist_findlnum    buffer.c    /^buflist_findlnum(buf)$/
  1448. Xbuflist_findname    buffer.c    /^buflist_findname(fname)$/
  1449. Xbuflist_findnr    buffer.c    /^buflist_findnr(nr)$/
  1450. Xbuflist_getfile    buffer.c    /^buflist_getfile(n, lnum, setpm)$/
  1451. Xbuflist_getlnum    buffer.c    /^buflist_getlnum()$/
  1452. Xbuflist_list    buffer.c    /^buflist_list()$/
  1453. Xbuflist_name_nr    buffer.c    /^buflist_name_nr(fnum, fname, lnum)$/
  1454. Xbuflist_new    buffer.c    /^buflist_new(fname, sfname, lnum, use_curbuf)$/
  1455. Xbuflist_nr2name    buffer.c    /^buflist_nr2name(n)$/
  1456. Xbuflist_setlnum    buffer.c    /^buflist_setlnum(buf, lnum)$/
  1457. Xbzero    unix.c    /^#  define bzero(a, b)    memset((a), 0, (b))$/
  1458. Xcall_shell    amiga.c    /^call_shell(cmd, filter, cooked)$/
  1459. Xcatch_cbrk    msdos.c    /^catch_cbrk()$/
  1460. Xcatch_cint    msdos.c    /^catch_cint(bp, di, si, ds, es, dx, cx, bx, ax)$/
  1461. Xcbrk_handler    msdos.c    /^cbrk_handler()$/
  1462. Xccheck_abbr    cmdline.c    /^ccheck_abbr(c)$/
  1463. Xchange_drive    msdos.c    /^change_drive(drive)$/
  1464. Xchange_warning    misccmds.c    /^change_warning()$/
  1465. Xcharsize    charset.c    /^charsize(c)$/
  1466. Xchartabsize    charset.c    /^chartabsize(c, col)$/
  1467. Xcheck_abbr    getchar.c    /^check_abbr(c, ptr, col, mincol)$/
  1468. Xcheck_changed    cmdline.c    /^check_changed(buf, checkaw, mult_win)$/
  1469. Xcheck_changed_any    cmdline.c    /^check_changed_any(checkaw)$/
  1470. Xcheck_cursor    screen.c    /^check_cursor()$/
  1471. Xcheck_fname    cmdline.c    /^check_fname()$/
  1472. Xcheck_more    cmdline.c    /^check_more(message)$/
  1473. Xcheck_readonly    cmdline.c    /^check_readonly()$/
  1474. Xcheck_status    misccmds.c    /^check_status(buf)$/
  1475. Xcheck_termcode    term.c    /^check_termcode(buf)$/
  1476. Xcheck_win    amiga.c    /^check_win(argc, argv)$/
  1477. Xcheck_winsize    term.c    /^check_winsize()$/
  1478. Xcheckclearop    normal.c    /^checkclearop()$/
  1479. Xcheckclearopq    normal.c    /^checkclearopq()$/
  1480. Xchecknextcomm    cmdline.c    /^checknextcomm(arg)$/
  1481. Xcheckpcmark    mark.c    /^checkpcmark()$/
  1482. Xchk_mline    fileio.c    /^chk_mline(lnum)$/
  1483. Xclear_termparam    param.c    /^clear_termparam()$/
  1484. Xclearopbeep    normal.c    /^clearopbeep()$/
  1485. Xclose_buffer    buffer.c    /^close_buffer(buf, free_buf, remove)$/
  1486. Xclose_others    window.c    /^close_others(message)$/
  1487. Xclose_window    window.c    /^close_window(free_buf)$/
  1488. Xclrallmarks    mark.c    /^clrallmarks(buf)$/
  1489. Xclreol    winnt.c    /^clreol()$/
  1490. Xclrscr    winnt.c    /^clrscr()$/
  1491. Xcls    search.c    /^cls()$/
  1492. Xcoladvance    linefunc.c    /^coladvance(wcol)$/
  1493. Xcommand_height    window.c    /^command_height()$/
  1494. Xcomp_Botline    screen.c    /^comp_Botline(wp)$/
  1495. Xcomp_Botline_all    screen.c    /^comp_Botline_all()$/
  1496. Xcomp_col    param.c    /^comp_col()$/
  1497. Xcompute_cmdrow    cmdline.c    /^compute_cmdrow()$/
  1498. Xcopy_redo    getchar.c    /^copy_redo()$/
  1499. Xcopy_spaces    alloc.c    /^copy_spaces(ptr, count)$/
  1500. Xcstrchr    regexp.c    /^cstrchr(s, c)$/
  1501. Xcstrncmp    regexp.c    /^cstrncmp(s1, s2, n)$/
  1502. Xcurs_columns    screen.c    /^curs_columns(scroll)$/
  1503. Xcursor_off    term.c    /^cursor_off()$/
  1504. Xcursor_on    term.c    /^cursor_on()$/
  1505. Xcursor_visible    winnt.c    /^cursor_visible(int visible)$/
  1506. Xcursorcmd    cmdline.c    /^cursorcmd()$/
  1507. Xcursupdate    screen.c    /^cursupdate()$/
  1508. Xdec    linefunc.c    /^dec(lp)$/
  1509. Xdec_cursor    linefunc.c    /^dec_cursor()$/
  1510. Xdecl    linefunc.c    /^decl(lp)$/
  1511. Xdel_spaces    alloc.c    /^del_spaces(ptr)$/
  1512. Xdel_typestr    getchar.c    /^del_typestr(len)$/
  1513. Xdelay    winnt.c    /^delay(x)$/
  1514. Xdelchar    misccmds.c    /^delchar(fixpos)$/
  1515. Xdelline    winnt.c    /^delline(int count)$/
  1516. Xdellines    misccmds.c    /^dellines(nlines, dowindow, undo)$/
  1517. Xdelmode    screen.c    /^delmode()$/
  1518. Xdirname    archie.c    /^dirname(buf, len)$/
  1519. Xdis_msg    ops.c    /^dis_msg(p, skip_esc)$/
  1520. Xdo_Copy    regsub.c    /^do_Copy(d, c)$/
  1521. Xdo_Lower    regsub.c    /^do_Lower(d, c)$/
  1522. Xdo_Upper    regsub.c    /^do_Upper(d, c)$/
  1523. Xdo_align    cmdcmds.c    /^do_align(start, end, width, type)$/
  1524. Xdo_arg_all    buffer.c    /^do_arg_all()$/
  1525. Xdo_buffer    buffer.c    /^do_buffer(action, start, dir, count, forceit)$/
  1526. Xdo_buffer_all    buffer.c    /^do_buffer_all(all)$/
  1527. Xdo_copy    cmdcmds.c    /^do_copy(line1, line2, n)$/
  1528. Xdo_lower    regsub.c    /^do_lower(d, c)$/
  1529. Xdo_mlines    fileio.c    /^do_mlines()$/
  1530. Xdo_move    cmdcmds.c    /^do_move(line1, line2, n)$/
  1531. Xdo_upper    regsub.c    /^do_upper(d, c)$/
  1532. Xdo_window    window.c    /^do_window(nchar, Prenum)$/
  1533. Xdoaddsub    ops.c    /^doaddsub(command, Prenum1)$/
  1534. Xdoarglist    cmdline.c    /^doarglist(str)$/
  1535. Xdobang    cmdcmds.c    /^dobang(addr_count, line1, line2, forceit, arg)$/
  1536. Xdochange    ops.c    /^dochange()$/
  1537. Xdocmdline    cmdline.c    /^docmdline(cmdline)$/
  1538. Xdodelete    ops.c    /^dodelete()$/
  1539. Xdodigraph    digraph.c    /^dodigraph(c)$/
  1540. Xdodis    ops.c    /^dodis()$/
  1541. Xdodojoin    ops.c    /^dodojoin(count, insert_space, redraw)$/
  1542. Xdoecmd    cmdline.c    /^doecmd(fname, sfname, command, hide, newlnum)$/
  1543. Xdoexecbuf    ops.c    /^doexecbuf(c)$/
  1544. Xdofilter    cmdcmds.c    /^dofilter(line1, line2, buff, do_in, do_out)$/
  1545. Xdoformat    ops.c    /^doformat()$/
  1546. Xdoglob    csearch.c    /^doglob(type, lp, up, cmd)$/
  1547. Xdojoin    ops.c    /^dojoin(insert_space, redraw)$/
  1548. Xdojumps    mark.c    /^dojumps()$/
  1549. Xdomake    cmdline.c    /^domake(arg)$/
  1550. Xdomap    getchar.c    /^domap(maptype, keys, mode)$/
  1551. Xdomarks    mark.c    /^domarks()$/
  1552. Xdoput    ops.c    /^doput(dir, count, fix_indent)$/
  1553. Xdorecord    ops.c    /^dorecord(c)$/
  1554. Xdos_packet    amiga.c    /^dos_packet(pid, action, arg)$/
  1555. Xdosearch    search.c    /^dosearch(dirc, str, reverse, count, echo, message)/
  1556. Xdoset    param.c    /^doset(arg)$/
  1557. Xdoshell    cmdcmds.c    /^doshell(cmd)$/
  1558. Xdoshift    ops.c    /^doshift(op, curs_top, amount)$/
  1559. Xdosource    cmdline.c    /^dosource(fname)$/
  1560. Xdosub    csearch.c    /^dosub(lp, up, cmd, nextcommand, use_old)$/
  1561. Xdotag    tag.c    /^dotag(tag, type, count)$/
  1562. Xdotags    tag.c    /^dotags()$/
  1563. Xdotilde    ops.c    /^dotilde()$/
  1564. Xdowrite    cmdline.c    /^dowrite(fname, append)$/
  1565. Xdoyank    ops.c    /^doyank(deleting)$/
  1566. Xecheck_abbr    edit.c    /^echeck_abbr(c)$/
  1567. Xedit    edit.c    /^edit(count)$/
  1568. Xemsg    message.c    /^emsg(s)$/
  1569. Xemsg2    message.c    /^emsg2(s, a1)$/
  1570. Xend_word    search.c    /^end_word(count, type, stop)$/
  1571. Xenter_buffer    buffer.c    /^enter_buffer(buf)$/
  1572. Xequal    macros.h    /^#define equal(a, b) (((a).lnum == (b).lnum) && ((a/
  1573. Xexpand_env    misccmds.c    /^expand_env(src, dst, dstlen)$/
  1574. Xexpandpath    msdos.c    /^expandpath(fl, path, fonly, donly, notf)$/
  1575. Xfile_name_at_cursor    window.c    /^file_name_at_cursor()$/
  1576. Xfileinfo    buffer.c    /^fileinfo(fullname)$/
  1577. Xfilemess    fileio.c    /^filemess(name, s)$/
  1578. Xfill_inbuf    archie.c    /^fill_inbuf()$/
  1579. Xfindfunc    search.c    /^findfunc(dir, what, count)$/
  1580. Xfindpar    search.c    /^findpar(dir, count, what, both)$/
  1581. Xfindparam    param.c    /^findparam(arg)$/
  1582. Xfindsent    search.c    /^findsent(dir, count)$/
  1583. Xfindswapname    memline.c    /^findswapname(buf, second_try)$/
  1584. Xfindtag    tag.c    /^findtag(tag)$/
  1585. Xfix_fname    buffer.c    /^fix_fname(fname)$/
  1586. Xflush_buffers    getchar.c    /^flush_buffers(typeahead)$/
  1587. Xflushbuf    term.c    /^flushbuf()$/
  1588. Xfm_getname    mark.c    /^fm_getname(fmark)$/
  1589. Xfname_case    amiga.c    /^fname_case(name)$/
  1590. Xfname_expand    buffer.c    /^fname_expand(fname, sfname)$/
  1591. Xfnamecmp    vim.h    /^# define fnamecmp(x, y) stricmp((char *)(x), (char/
  1592. Xfree    vim.h    /^# define free(x)    nofreeNULL(x)$/
  1593. Xfree_buff    getchar.c    /^free_buff(buf)$/
  1594. Xfree_yank    ops.c    /^free_yank(n)$/
  1595. Xfree_yank_all    ops.c    /^free_yank_all()$/
  1596. Xfreefiles    amiga.c    /^freefiles()$/
  1597. Xfstatfs    memfile.c    /^# define fstatfs(fd, buf, len, nul) fstat((fd), (b/
  1598. Xfullpathcmp    misccmds.c    /^fullpathcmp(s1, s2)$/
  1599. Xfwd_word    search.c    /^fwd_word(count, type, eol)$/
  1600. Xgchar    misccmds.c    /^gchar(pos)$/
  1601. Xgchar_cursor    misccmds.c    /^gchar_cursor()$/
  1602. Xget_address    cmdline.c    /^get_address(ptr)$/
  1603. Xget_bufcont    getchar.c    /^get_bufcont(buffer, dozero)$/
  1604. Xget_fib    amiga.c    /^get_fib(fname)$/
  1605. Xget_indent    misccmds.c    /^get_indent()$/
  1606. Xget_inserted    getchar.c    /^get_inserted()$/
  1607. Xget_last_insert    edit.c    /^get_last_insert()$/
  1608. Xget_literal    edit.c    /^get_literal(nextc)$/
  1609. Xget_recorded    getchar.c    /^get_recorded()$/
  1610. Xget_varp    param.c    /^get_varp(p)$/
  1611. Xget_x11_icon    unix.c    /^get_x11_icon()$/
  1612. Xget_x11_title    unix.c    /^get_x11_title()$/
  1613. Xget_x11_windis    unix.c    /^get_x11_windis()$/
  1614. Xget_yank_buffer    ops.c    /^get_yank_buffer(writing)$/
  1615. Xgetargcmd    cmdline.c    /^getargcmd(argp)$/
  1616. Xgetchr    regexp.c    /^getchr()$/
  1617. Xgetcmdline    cmdline.c    /^getcmdline(firstc, buff)$/
  1618. Xgetdigits    misccmds.c    /^getdigits(pp)$/
  1619. Xgetdigraph    digraph.c    /^getdigraph(char1, char2, meta)$/
  1620. Xgetent    termlib.c    /^getent(tbuf, term, termcap, buflen)$/
  1621. Xgetfile    cmdline.c    /^getfile(fname, sfname, setpm, lnum)$/
  1622. Xgetlinecol    term.c    /^getlinecol()$/
  1623. Xgetmark    mark.c    /^getmark(c, changefile)$/
  1624. Xgetout    main.c    /^getout(r)$/
  1625. Xgetperm    amiga.c    /^getperm(name)$/
  1626. Xgettail    misccmds.c    /^gettail(fname)$/
  1627. Xgetvcol    screen.c    /^getvcol(wp, pos, type)$/
  1628. Xgotchars    getchar.c    /^gotchars(s, len)$/
  1629. Xgotocmdend    cmdline.c    /^gotocmdend()$/
  1630. Xgotocmdline    cmdline.c    /^gotocmdline(clr, firstc)$/
  1631. Xgotoxy    winnt.c    /^gotoxy(x, y)$/
  1632. Xhandler_routine    winnt.c    /^BOOL WINAPI     handler_routine(DWORD dwCtrlType)$/
  1633. Xhas_wildcard    amiga.c    /^has_wildcard(p)$/
  1634. Xhave_wildcard    archie.c    /^have_wildcard(num, file)$/
  1635. Xhelp    help.c    /^help()$/
  1636. Xhome_replace    misccmds.c    /^home_replace(src, dst, dstlen)$/
  1637. Xinc    linefunc.c    /^inc(lp)$/
  1638. Xinc_cursor    linefunc.c    /^inc_cursor()$/
  1639. Xinchar    term.c    /^inchar(buf, maxlen, time)$/
  1640. Xincl    linefunc.c    /^incl(lp)$/
  1641. Xinindent    misccmds.c    /^inindent()$/
  1642. Xinit_typestr    getchar.c    /^init_typestr()$/
  1643. Xinit_yank    ops.c    /^init_yank()$/
  1644. Xinitchr    regexp.c    /^initchr(str)$/
  1645. Xinmacro    search.c    /^inmacro(opt, s)$/
  1646. Xins_typestr    getchar.c    /^ins_typestr(str, noremap)$/
  1647. Xinschar    misccmds.c    /^inschar(c)$/
  1648. Xinsertbuf    ops.c    /^insertbuf(c)$/
  1649. Xinsertchar    edit.c    /^insertchar(c)$/
  1650. Xinsfile    amiga.c    /^insfile(name, isdir)$/
  1651. Xinsline    winnt.c    /^insline(int count)$/
  1652. Xinsstr    misccmds.c    /^insstr(s)$/
  1653. XisFullName    amiga.c    /^isFullName(fname)$/
  1654. Xis_yank_buffer    ops.c    /^is_yank_buffer(c, write)$/
  1655. Xisdir    amiga.c    /^isdir(name)$/
  1656. Xisidchar    charset.c    /^isidchar(c)$/
  1657. Xiskeypad    winnt.c    /^#define iskeypad(x)    (KEYPADLO <= (x) && (x) <= KEY/
  1658. Xismult    regexp.c    /^ismult(c)$/
  1659. Xispathsep    misccmds.c    /^ispathsep(c)$/
  1660. Xisspace    vim.h    /^# define isspace(x)  (((x) >= 9 && (x) <= 13) || (/
  1661. Xistermparam    param.c    /^istermparam(p)$/
  1662. Xiswhite    vim.h    /^#define iswhite(x)    ((x) == ' ' || (x) == '\\t')$/
  1663. Xkbhit    winnt.c    /^int             kbhit()$/
  1664. Xlalloc    alloc.c    /^lalloc(size, message)$/
  1665. Xlast_status    window.c    /^last_status()$/
  1666. Xlineempty    macros.h    /^#define lineempty(p) (*ml_get(p) == NUL)$/
  1667. Xlistdigraphs    digraph.c    /^listdigraphs()$/
  1668. Xlock2name    amiga.c    /^lock2name(lock, buf, len)$/
  1669. Xlt    macros.h    /^#define lt(a, b) (((a).lnum != (b).lnum) \\$/
  1670. Xltoreq    macros.h    /^#define ltoreq(a, b) (((a).lnum != (b).lnum) \\$/
  1671. Xmake_windows    window.c    /^make_windows(count)$/
  1672. Xmakemap    getchar.c    /^makemap(fd)$/
  1673. Xmakeset    param.c    /^makeset(fd)$/
  1674. Xmakeswapname    memline.c    /^makeswapname(buf, second_try)$/
  1675. Xmaketitle    buffer.c    /^maketitle()$/
  1676. Xmark_adjust    mark.c    /^mark_adjust(line1, line2, inc)$/
  1677. Xmch_avail_mem    amiga.c    /^mch_avail_mem(special)$/
  1678. Xmch_char_avail    amiga.c    /^mch_char_avail()$/
  1679. Xmch_get_winsize    amiga.c    /^mch_get_winsize()$/
  1680. Xmch_restore_title    amiga.c    /^mch_restore_title(which)$/
  1681. Xmch_screenmode    amiga.c    /^mch_screenmode(arg)$/
  1682. Xmch_set_winsize    amiga.c    /^mch_set_winsize()$/
  1683. Xmch_settitle    amiga.c    /^mch_settitle(title, icon)$/
  1684. Xmch_settmode    amiga.c    /^mch_settmode(raw)$/
  1685. Xmch_suspend    amiga.c    /^mch_suspend()$/
  1686. Xmch_windexit    amiga.c    /^mch_windexit(r)$/
  1687. Xmch_windinit    amiga.c    /^mch_windinit()$/
  1688. Xmch_write    amiga.c    /^mch_write(p, len)$/
  1689. Xmemmove    alloc.c    /^memmove(desti, source, len)$/
  1690. Xmemset    unix.h    /^# define memset(ptr, c, size)    bsdmemset((ptr), (c)/
  1691. Xmf_alloc_bhdr    memfile.c    /^mf_alloc_bhdr(mfp, page_count)$/
  1692. Xmf_close    memfile.c    /^mf_close(mfp, delete)$/
  1693. Xmf_do_open    memfile.c    /^mf_do_open(mfp, fname, new)$/
  1694. Xmf_find_hash    memfile.c    /^mf_find_hash(mfp, nr)$/
  1695. Xmf_free    memfile.c    /^mf_free(mfp, hp)$/
  1696. Xmf_free_bhdr    memfile.c    /^mf_free_bhdr(hp)$/
  1697. Xmf_fullname    memfile.c    /^mf_fullname(mfp)$/
  1698. Xmf_get    memfile.c    /^mf_get(mfp, nr, page_count)$/
  1699. Xmf_ins_free    memfile.c    /^mf_ins_free(mfp, hp)$/
  1700. Xmf_ins_hash    memfile.c    /^mf_ins_hash(mfp, hp)$/
  1701. Xmf_ins_used    memfile.c    /^mf_ins_used(mfp, hp)$/
  1702. Xmf_need_trans    memfile.c    /^mf_need_trans(mfp)$/
  1703. Xmf_new    memfile.c    /^mf_new(mfp, negative, page_count)$/
  1704. Xmf_open    memfile.c    /^mf_open(fname, new, fail_nofile)$/
  1705. Xmf_open_file    memfile.c    /^mf_open_file(mfp, fname)$/
  1706. Xmf_put    memfile.c    /^mf_put(mfp, hp, dirty, infile)$/
  1707. Xmf_read    memfile.c    /^mf_read(mfp, hp)$/
  1708. Xmf_release    memfile.c    /^mf_release(mfp, page_count)$/
  1709. Xmf_release_all    memfile.c    /^mf_release_all()$/
  1710. Xmf_rem_free    memfile.c    /^mf_rem_free(mfp)$/
  1711. Xmf_rem_hash    memfile.c    /^mf_rem_hash(mfp, hp)$/
  1712. Xmf_rem_used    memfile.c    /^mf_rem_used(mfp, hp)$/
  1713. Xmf_statistics    memfile.c    /^mf_statistics()$/
  1714. Xmf_sync    memfile.c    /^mf_sync(mfp, all, check_char)$/
  1715. Xmf_trans_add    memfile.c    /^mf_trans_add(mfp, hp)$/
  1716. Xmf_trans_del    memfile.c    /^mf_trans_del(mfp, old)$/
  1717. Xmf_write    memfile.c    /^mf_write(mfp, hp)$/
  1718. Xmktemp    cmdcmds.c    /^# define mktemp(a)    tmpnam(a)$/
  1719. Xml_add_stack    memline.c    /^ml_add_stack(buf)$/
  1720. Xml_append    memline.c    /^ml_append(lnum, line, len, newfile)$/
  1721. Xml_append_int    memline.c    /^ml_append_int(buf, lnum, line, len, newfile)$/
  1722. Xml_clearmarked    memline.c    /^ml_clearmarked()$/
  1723. Xml_close    memline.c    /^ml_close(buf)$/
  1724. Xml_close_all    memline.c    /^ml_close_all()$/
  1725. Xml_delete    memline.c    /^ml_delete(lnum)$/
  1726. Xml_delete_int    memline.c    /^ml_delete_int(buf, lnum)$/
  1727. Xml_find_line    memline.c    /^ml_find_line(buf, lnum, action)$/
  1728. Xml_firstmarked    memline.c    /^ml_firstmarked()$/
  1729. Xml_flush_line    memline.c    /^ml_flush_line(buf)$/
  1730. Xml_get    memline.c    /^ml_get(lnum)$/
  1731. Xml_get_buf    memline.c    /^ml_get_buf(buf, lnum, will_change)$/
  1732. Xml_get_cursor    memline.c    /^ml_get_cursor()$/
  1733. Xml_get_pos    memline.c    /^ml_get_pos(pos)$/
  1734. Xml_has_mark    memline.c    /^ml_has_mark(lnum)$/
  1735. Xml_line_alloced    memline.c    /^ml_line_alloced()$/
  1736. Xml_lineadd    memline.c    /^ml_lineadd(buf, count)$/
  1737. Xml_new_data    memline.c    /^ml_new_data(mfp, negative, page_count)$/
  1738. Xml_new_ptr    memline.c    /^ml_new_ptr(mfp)$/
  1739. Xml_open    memline.c    /^ml_open()$/
  1740. Xml_open_files    memline.c    /^ml_open_files()$/
  1741. Xml_preserve    memline.c    /^ml_preserve(buf, message)$/
  1742. Xml_recover    memline.c    /^ml_recover()$/
  1743. Xml_replace    memline.c    /^ml_replace(lnum, line, copy)$/
  1744. Xml_setmarked    memline.c    /^ml_setmarked(lnum)$/
  1745. Xml_sync_all    memline.c    /^ml_sync_all(check_file)$/
  1746. Xml_timestamp    memline.c    /^ml_timestamp(buf)$/
  1747. Xmodname    fileio.c    /^modname(fname, ext)$/
  1748. Xmovemark    mark.c    /^movemark(count)$/
  1749. Xmsg    message.c    /^msg(s)$/
  1750. Xmsg_ceol    message.c    /^msg_ceol()$/
  1751. Xmsg_check    message.c    /^msg_check()$/
  1752. Xmsg_check_screen    message.c    /^msg_check_screen()$/
  1753. Xmsg_end    message.c    /^msg_end()$/
  1754. Xmsg_outchar    message.c    /^msg_outchar(c)$/
  1755. Xmsg_outnum    message.c    /^msg_outnum(n)$/
  1756. Xmsg_outstr    message.c    /^msg_outstr(s)$/
  1757. Xmsg_outtrans    message.c    /^msg_outtrans(str, len)$/
  1758. Xmsg_pos    message.c    /^msg_pos(row, col)$/
  1759. Xmsg_prt_line    message.c    /^msg_prt_line(s)$/
  1760. Xmsg_start    message.c    /^msg_start()$/
  1761. Xmsgmore    misccmds.c    /^msgmore(n)$/
  1762. Xmyregcomp    search.c    /^myregcomp(pat, sub_cmd, which_pat)$/
  1763. Xnextent    termlib.c    /^nextent(tbuf, termcap, buflen)         \/* Read 1 e/
  1764. Xnextwild    cmdline.c    /^nextwild(buff, type)$/
  1765. XnofreeNULL    alloc.c    /^nofreeNULL(x)$/
  1766. Xnormal    normal.c    /^normal()$/
  1767. Xnormvideo    winnt.c    /^normvideo()$/
  1768. Xonedown    edit.c    /^onedown(n)$/
  1769. Xoneleft    edit.c    /^oneleft()$/
  1770. Xonepage    edit.c    /^onepage(dir, count)$/
  1771. Xoneright    edit.c    /^oneright()$/
  1772. Xoneup    edit.c    /^oneup(n)$/
  1773. Xopen_buffer    buffer.c    /^open_buffer()$/
  1774. Xopenscript    getchar.c    /^openscript(name)$/
  1775. Xotherfile    buffer.c    /^otherfile(fname)$/
  1776. Xoutchar    term.c    /^outchar(c)$/
  1777. Xoutnum    term.c    /^outnum(n)$/
  1778. Xoutstr    term.c    /^outstr(s)$/
  1779. Xoutstrn    term.c    /^outstrn(s)$/
  1780. Xparam_expand    param.c    /^param_expand(i, dofree)$/
  1781. Xparamchanged    param.c    /^paramchanged(arg)$/
  1782. Xparse_builtin_tcap    term.c    /^parse_builtin_tcap(tc, s)$/
  1783. Xpchar    macros.h    /^#define pchar(lp, c) (*(ml_get_buf(curbuf, (lp).ln/
  1784. Xpchar_cursor    misccmds.c    /^pchar_cursor(c)$/
  1785. Xpeekchr    regexp.c    /^peekchr()$/
  1786. Xperr    winnt.c    /^void            perr(PCHAR szFileName, int line, P/
  1787. Xplines    misccmds.c    /^plines(p)$/
  1788. Xplines_m    misccmds.c    /^plines_m(first, last)$/
  1789. Xplines_m_win    misccmds.c    /^plines_m_win(wp, first, last)$/
  1790. Xplines_win    misccmds.c    /^plines_win(wp, p)$/
  1791. Xplural    misccmds.c    /^plural(n)$/
  1792. Xpremsg    normal.c    /^premsg(c1, c2)$/
  1793. Xprep_redo    normal.c    /^prep_redo(num, cmd, c, nchar)$/
  1794. Xprintdigraph    digraph.c    /^printdigraph(p)$/
  1795. Xpstrcmp    msdos.c    /^pstrcmp(a, b)$/
  1796. Xputch    winnt.c    /^putch(char c)$/
  1797. Xputcmdline    cmdline.c    /^putcmdline(c, buff)$/
  1798. Xputdigraph    digraph.c    /^putdigraph(str)$/
  1799. Xputescstr    getchar.c    /^putescstr(fd, str, set)$/
  1800. Xqf_free    quickfix.c    /^qf_free()$/
  1801. Xqf_init    quickfix.c    /^qf_init()$/
  1802. Xqf_jump    quickfix.c    /^qf_jump(dir, errornr)$/
  1803. Xqf_list    quickfix.c    /^qf_list()$/
  1804. Xqf_mark_adjust    quickfix.c    /^qf_mark_adjust(line1, line2, inc)$/
  1805. Xqf_types    quickfix.c    /^qf_types(c, nr)$/
  1806. Xread_redo    getchar.c    /^read_redo(init)$/
  1807. Xread_stuff    getchar.c    /^read_stuff(advance)$/
  1808. Xreadfile    fileio.c    /^readfile(fname, sfname, from, newfile, skip_lnum, /
  1809. Xredrawcmd    cmdline.c    /^redrawcmd()$/
  1810. Xredrawcmdline    cmdline.c    /^redrawcmdline()$/
  1811. Xredrawhelp    help.c    /^redrawhelp()$/
  1812. Xreg    regexp.c    /^reg(paren, flagp)$/
  1813. Xregatom    regexp.c    /^regatom(flagp)$/
  1814. Xregbranch    regexp.c    /^regbranch(flagp)$/
  1815. Xregc    regexp.c    /^regc(b)$/
  1816. Xregcomp    regexp.c    /^regcomp(exp)$/
  1817. Xregdump    regexp.c    /^regdump(r)$/
  1818. Xregexec    regexp.c    /^regexec(prog, string, at_bol)$/
  1819. Xreginsert    regexp.c    /^reginsert(op, opnd)$/
  1820. Xregmatch    regexp.c    /^regmatch(prog)$/
  1821. Xregnext    regexp.c    /^regnext(p)$/
  1822. Xregnode    regexp.c    /^regnode(op)$/
  1823. Xregoptail    regexp.c    /^regoptail(p, val)$/
  1824. Xregpiece    regexp.c    /^regpiece(flagp)$/
  1825. Xregprop    regexp.c    /^regprop(op)$/
  1826. Xregrepeat    regexp.c    /^regrepeat(p)$/
  1827. Xregsub    regsub.c    /^regsub(prog, source, dest, copy, magic)$/
  1828. Xregtail    regexp.c    /^regtail(p, val)$/
  1829. Xregtilde    regsub.c    /^regtilde(source, magic)$/
  1830. Xregtry    regexp.c    /^regtry(prog, string)$/
  1831. Xremove    unix.c    /^remove(buf)$/
  1832. Xrename    unix.c    /^rename(src, dest)$/
  1833. Xresettitle    archie.c    /^resettitle()$/
  1834. XresizeConBufAndWindow    winnt.c    /^void            resizeConBufAndWindow(HANDLE hCons/
  1835. Xscreen_char    screen.c    /^screen_char(p, row, col)$/
  1836. Xscreen_del_lines    screen.c    /^screen_del_lines(off, row, nlines, end)$/
  1837. Xscreen_fill    screen.c    /^screen_fill(start_row, end_row, start_col, end_col/
  1838. Xscreen_ins_lines    screen.c    /^screen_ins_lines(off, row, nlines, end)$/
  1839. Xscreen_msg    screen.c    /^screen_msg(msg, row, col)$/
  1840. Xscreen_new_rows    window.c    /^screen_new_rows()$/
  1841. Xscreen_outchar    screen.c    /^screen_outchar(c, row, col)$/
  1842. Xscreen_start    screen.c    /^screen_start()$/
  1843. Xscreen_valid    screen.c    /^screen_valid()$/
  1844. Xscreenalloc    screen.c    /^screenalloc(clear)$/
  1845. Xscreenclear    screen.c    /^screenclear()$/
  1846. Xscreenclear2    screen.c    /^screenclear2()$/
  1847. Xscroll    winnt.c    /^scroll()$/
  1848. Xscroll_region_reset    term.c    /^scroll_region_reset()$/
  1849. Xscroll_region_set    term.c    /^scroll_region_set(wp)$/
  1850. Xscrolldown    screen.c    /^scrolldown(nlines)$/
  1851. Xscrollup    screen.c    /^scrollup(nlines)$/
  1852. Xsearchc    search.c    /^searchc(c, dir, type, count)$/
  1853. Xsearchit    search.c    /^searchit(pos, dir, str, count, end, message)$/
  1854. Xset_Changed    misccmds.c    /^set_Changed()$/
  1855. Xset_context_in_set_cmd    param.c    /^set_context_in_set_cmd(arg)$/
  1856. Xset_expand_context    cmdline.c    /^set_expand_context(firstc, buff)$/
  1857. Xset_highlight    screen.c    /^set_highlight(context)$/
  1858. Xset_indent    misccmds.c    /^set_indent(size, delete)$/
  1859. Xset_init    param.c    /^set_init()$/
  1860. Xset_keymap    amiga.c    /^set_keymap(name)$/
  1861. Xset_one_cmd_context    cmdline.c    /^set_one_cmd_context(firstc, buff)$/
  1862. Xset_redo_ins    getchar.c    /^set_redo_ins()$/
  1863. Xset_term    term.c    /^set_term(term)$/
  1864. Xset_window    msdos.c    /^set_window()$/
  1865. Xset_winsize    term.c    /^set_winsize(width, height, mustset)$/
  1866. Xset_x11_icon    unix.c    /^set_x11_icon(icon)$/
  1867. Xset_x11_title    unix.c    /^set_x11_title(title)$/
  1868. Xsetaltfname    buffer.c    /^setaltfname(fname, sfname, lnum)$/
  1869. Xsetcursor    term.c    /^setcursor()$/
  1870. Xsetfname    buffer.c    /^setfname(fname, sfname, message)$/
  1871. Xsetmark    mark.c    /^setmark(c)$/
  1872. Xsetpcmark    mark.c    /^setpcmark()$/
  1873. Xsetperm    amiga.c    /^setperm(name, perm)$/
  1874. Xsettitle    archie.c    /^settitle(str)$/
  1875. Xsettmode    term.c    /^settmode(raw)$/
  1876. Xshift_line    ops.c    /^shift_line(left, round, amount)$/
  1877. Xshowmap    getchar.c    /^showmap(mp)$/
  1878. Xshowmatch    search.c    /^showmatch(initc)$/
  1879. Xshowmatches    cmdline.c    /^showmatches(buff)$/
  1880. Xshowmode    screen.c    /^showmode()$/
  1881. Xshowonep    param.c    /^showonep(p)$/
  1882. Xshowparams    param.c    /^showparams(all)$/
  1883. Xshowruler    screen.c    /^showruler(always)$/
  1884. Xsig_winch    unix.c    /^sig_winch()$/
  1885. Xskip_chars    search.c    /^skip_chars(class, dir)$/
  1886. Xskip_regexp    regexp.c    /^skip_regexp(p, dirc)$/
  1887. Xskipchr    regexp.c    /^skipchr()$/
  1888. Xskipspace    misccmds.c    /^skipspace(pp)$/
  1889. Xskiptodigit    misccmds.c    /^skiptodigit(pp)$/
  1890. Xskiptospace    misccmds.c    /^skiptospace(pp)$/
  1891. Xsleep    amiga.c    /^sleep(n)$/
  1892. Xsmsg    message.c    /^smsg(s, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10)$/
  1893. Xsortcmp    amiga.c    /^sortcmp(a, b)$/
  1894. XstartPS    search.c    /^startPS(lnum, para, both)$/
  1895. Xstart_arrow    edit.c    /^start_arrow()$/
  1896. Xstart_highlight    screen.c    /^start_highlight()$/
  1897. Xstart_redo    getchar.c    /^start_redo(count)$/
  1898. Xstart_redo_ins    getchar.c    /^start_redo_ins()$/
  1899. Xstart_stuff    getchar.c    /^start_stuff()$/
  1900. Xstartinsert    ops.c    /^startinsert(initstr, startln, count)$/
  1901. Xstarttermcap    term.c    /^starttermcap()$/
  1902. Xstatus_redraw_all    screen.c    /^status_redraw_all()$/
  1903. Xstop_arrow    edit.c    /^stop_arrow()$/
  1904. Xstop_highlight    screen.c    /^stop_highlight()$/
  1905. Xstop_insert    edit.c    /^stop_insert()$/
  1906. Xstop_redo_ins    getchar.c    /^stop_redo_ins()$/
  1907. Xstoptermcap    term.c    /^stoptermcap()$/
  1908. Xstrchr    unix.h    /^# define strchr(ptr, c)            index((ptr), (c))$/
  1909. Xstrcspn    regexp.c    /^strcspn(s1, s2)$/
  1910. Xstrlowcpy    msdos.c    /^strlowcpy(d, s)$/
  1911. Xstrnfcpy    regsub.c    /^strnfcpy(f, d, s, n)$/
  1912. Xstrnsave    alloc.c    /^strnsave(string, len)$/
  1913. Xstrrchr    unix.h    /^# define strrchr(ptr, c)        rindex((ptr), (c))$/
  1914. Xstrsave    alloc.c    /^strsave(string)$/
  1915. Xstrsize    charset.c    /^strsize(s)$/
  1916. XstuffReadbuff    getchar.c    /^stuffReadbuff(s)$/
  1917. Xstuff_empty    getchar.c    /^stuff_empty()$/
  1918. Xstuff_inserted    edit.c    /^stuff_inserted(c, count, no_esc)$/
  1919. Xstuff_yank    ops.c    /^stuff_yank(bufname, p)$/
  1920. XstuffcharReadbuff    getchar.c    /^stuffcharReadbuff(c)$/
  1921. XstuffnumReadbuff    getchar.c    /^stuffnumReadbuff(n)$/
  1922. Xswapchar    ops.c    /^swapchar(pos)$/
  1923. Xtermcapinit    term.c    /^termcapinit(term)$/
  1924. Xtextattr    winnt.c    /^textattr(int attr)$/
  1925. Xtgetch    winnt.c    /^int             tgetch()$/
  1926. Xtgetent    termlib.c    /^tgetent(tbuf, term)$/
  1927. Xtgetflag    termlib.c    /^tgetflag(id)$/
  1928. Xtgetnum    termlib.c    /^tgetnum(id)$/
  1929. Xtgetstr    termlib.c    /^tgetstr(id, buf)$/
  1930. Xtgoto    term.c    /^tgoto(cm, x, y)$/
  1931. Xtinit    termlib.c    /^tinit(name)$/
  1932. Xtltoa    term.c    /^tltoa(i)$/
  1933. Xtputs    termlib.c    /^tputs(cp, affcnt, outc)$/
  1934. Xtranschar    charset.c    /^transchar(c)$/
  1935. Xttest    term.c    /^ttest(pairs)$/
  1936. Xu_alloc_line    undo.c    /^u_alloc_line(size)$/
  1937. Xu_blockalloc    undo.c    /^u_blockalloc(size)$/
  1938. Xu_blockfree    undo.c    /^u_blockfree(buf)$/
  1939. Xu_clearall    undo.c    /^u_clearall(buf)$/
  1940. Xu_clearline    undo.c    /^u_clearline()$/
  1941. Xu_free_line    undo.c    /^u_free_line(ptr)$/
  1942. Xu_freeentry    undo.c    /^u_freeentry(uep, n)$/
  1943. Xu_freelist    undo.c    /^u_freelist(uhp)$/
  1944. Xu_getbot    undo.c    /^u_getbot()$/
  1945. Xu_inssub    undo.c    /^u_inssub(lnum)$/
  1946. Xu_redo    undo.c    /^u_redo(count)$/
  1947. Xu_save    undo.c    /^u_save(top, bot)$/
  1948. Xu_save_cursor    undo.c    /^u_save_cursor()$/
  1949. Xu_save_line    undo.c    /^u_save_line(lnum)$/
  1950. Xu_savecommon    undo.c    /^u_savecommon(top, bot, newbot)$/
  1951. Xu_savedel    undo.c    /^u_savedel(lnum, nlines)$/
  1952. Xu_saveline    undo.c    /^u_saveline(lnum)$/
  1953. Xu_savesub    undo.c    /^u_savesub(lnum)$/
  1954. Xu_sync    undo.c    /^u_sync()$/
  1955. Xu_unchanged    undo.c    /^u_unchanged(buf)$/
  1956. Xu_undo    undo.c    /^u_undo(count)$/
  1957. Xu_undo_end    undo.c    /^u_undo_end()$/
  1958. Xu_undoline    undo.c    /^u_undoline()$/
  1959. Xu_undoredo    undo.c    /^u_undoredo()$/
  1960. Xungetchr    regexp.c    /^ungetchr()$/
  1961. Xunregc    regexp.c    /^unregc()$/
  1962. Xunset_Changed    misccmds.c    /^unset_Changed(buf)$/
  1963. XupdateScreen    screen.c    /^updateScreen(type)$/
  1964. Xupdateline    screen.c    /^updateline()$/
  1965. Xupdatescript    getchar.c    /^updatescript(c)$/
  1966. Xusage    main.c    /^usage(n)$/
  1967. Xvbell    winnt.c    /^vbell()$/
  1968. Xvgetc    getchar.c    /^vgetc()$/
  1969. Xvgetorpeek    getchar.c    /^vgetorpeek(advance)$/
  1970. Xvim_chdir    msdos.c    /^vim_chdir(path)$/
  1971. Xvim_delay    amiga.c    /^vim_delay()$/
  1972. Xvim_dirname    amiga.c    /^vim_dirname(buf, len)$/
  1973. Xvim_fgets    fileio.c    /^vim_fgets(buf, size, fp, lnum)$/
  1974. Xvim_remove    msdos.c    /^vim_remove(name)$/
  1975. Xvim_strncpy    cmdline.c    /^vim_strncpy(to, from, len)$/
  1976. Xvim_strnicmp    alloc.c    /^vim_strnicmp(s1, s2, len)$/
  1977. Xvimgetenv    amiga.c    /^vimgetenv(var)$/
  1978. Xvpeekc    getchar.c    /^vpeekc()$/
  1979. Xwait_return    message.c    /^wait_return(redraw)$/
  1980. Xwin_alloc    window.c    /^win_alloc(after)$/
  1981. Xwin_alloc_lsize    window.c    /^win_alloc_lsize(wp)$/
  1982. Xwin_append    window.c    /^win_append(after, wp)$/
  1983. Xwin_comp_pos    window.c    /^win_comp_pos()$/
  1984. Xwin_comp_scroll    window.c    /^win_comp_scroll(wp)$/
  1985. Xwin_copy_options    param.c    /^win_copy_options(wp_from, wp_to)$/
  1986. Xwin_del_lines    screen.c    /^win_del_lines(wp, row, nlines, invalid, mayclear)$/
  1987. Xwin_enter    window.c    /^win_enter(wp, undo_sync)$/
  1988. Xwin_equal    window.c    /^win_equal(next_curwin, redraw)$/
  1989. Xwin_exchange    window.c    /^win_exchange(Prenum)$/
  1990. Xwin_free    window.c    /^win_free(wp)$/
  1991. Xwin_free_lsize    window.c    /^win_free_lsize(wp)$/
  1992. Xwin_init    window.c    /^win_init(wp)$/
  1993. Xwin_ins_lines    screen.c    /^win_ins_lines(wp, row, nlines, invalid, mayclear)$/
  1994. Xwin_line    screen.c    /^win_line(wp, lnum, startrow, endrow)$/
  1995. Xwin_redr_ruler    screen.c    /^win_redr_ruler(wp, always)$/
  1996. Xwin_redr_status    screen.c    /^win_redr_status(wp)$/
  1997. Xwin_remove    window.c    /^win_remove(wp)$/
  1998. Xwin_resize_off    amiga.c    /^win_resize_off()$/
  1999. Xwin_resize_on    amiga.c    /^win_resize_on()$/
  2000. Xwin_rest_invalid    screen.c    /^win_rest_invalid(wp)$/
  2001. Xwin_rotate    window.c    /^win_rotate(upwards, count)$/
  2002. Xwin_setheight    window.c    /^win_setheight(height)$/
  2003. Xwin_split    window.c    /^win_split(new_height, redraw)$/
  2004. Xwin_update    screen.c    /^win_update(wp)$/
  2005. Xwindgoto    term.c    /^windgoto(row, col)$/
  2006. Xwrite_buf    fileio.c    /^write_buf(fd, buf, len)$/
  2007. END_OF_FILE
  2008.   if test 29029 -ne `wc -c <'vim/src/tags'`; then
  2009.     echo shar: \"'vim/src/tags'\" unpacked with wrong size!
  2010.   fi
  2011.   # end of 'vim/src/tags'
  2012. fi
  2013. echo shar: End of archive 14 \(of 26\).
  2014. cp /dev/null ark14isdone
  2015. MISSING=""
  2016. for I in 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 ; do
  2017.     if test ! -f ark${I}isdone ; then
  2018.     MISSING="${MISSING} ${I}"
  2019.     fi
  2020. done
  2021. if test "${MISSING}" = "" ; then
  2022.     echo You have unpacked all 26 archives.
  2023.     rm -f ark[1-9]isdone ark[1-9][0-9]isdone
  2024. else
  2025.     echo You still must unpack the following archives:
  2026.     echo "        " ${MISSING}
  2027. fi
  2028. exit 0
  2029. exit 0 # Just in case...
  2030.