开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 编辑器/阅读器 > 查看源码
option.c
资源名称：vim53src.zip　[点击查看]
上传用户：gddssl
上传日期：2007-01-06
资源大小：1003k
文件大小：133k
源码类别：

编辑器/阅读器

开发平台：

DOS

option.c：源码内容
  2.     /* 'term' */
  3.     if (varp == &T_NAME)
  4.     {
  5. if (T_NAME[0] == NUL)
  6.     errmsg = (char_u *)"Cannot set 'term' to empty string";
  7. #ifdef USE_GUI
  8. if (gui.in_use)
  9.     errmsg = (char_u *)"Cannot change term in GUI";
  10. else if (term_is_gui(T_NAME))
  11.     errmsg = (char_u *)"Use ":gui" to start the GUI";
  12. #endif
  13. else if (set_termname(T_NAME) == FAIL)
  14.     errmsg = (char_u *)"Not found in termcap";
  15. else
  16. {
  17.     /* Screen colors may have changed. */
  18.     out_str(T_ME);
  19.     update_screen(CLEAR);
  20. }
  21.     }
  23.     /* 'backupext' and 'patchmode' */
  24.     else if ((varp == &p_bex || varp == &p_pm))
  25.     {
  26. if (STRCMP(*p_bex == '.' ? p_bex + 1 : p_bex,
  27.      *p_pm == '.' ? p_pm + 1 : p_pm) == 0)
  28.     errmsg = (char_u *)"'backupext' and 'patchmode' are equal";
  29.     }
  31.     /*
  32.      * 'isident', 'iskeyword', 'isprint or 'isfname' option: refill chartab[]
  33.      * If the new option is invalid, use old value.  'lisp' option: refill
  34.      * chartab[] for '-' char
  35.      */
  36.     else if (  varp == &p_isi
  37.     || varp == &(curbuf->b_p_isk)
  38.     || varp == &p_isp
  39.     || varp == &p_isf)
  40.     {
  41. if (init_chartab() == FAIL)
  42. {
  43.     did_chartab = TRUE;     /* need to restore it below */
  44.     errmsg = e_invarg;     /* error in value */
  45. }
  46.     }
  48.     /* 'highlight' */
  49.     else if (varp == &p_hl)
  50.     {
  51. if (highlight_changed() == FAIL)
  52.     errmsg = e_invarg; /* invalid flags */
  53.     }
  55.     /* 'nrformats' */
  56.     else if (varp == &(curbuf->b_p_nf))
  57.     {
  58. if (check_opt_strings(curbuf->b_p_nf, p_nf_values, TRUE) != OK)
  59.     errmsg = e_invarg;
  60.     }
  62.     /* 'sessionoptions' */
  63.     else if (varp == &(p_sessopt))
  64.     {
  65. if (check_opt_strings(p_sessopt, p_sessopt_values, TRUE) != OK)
  66.     errmsg = e_invarg;
  67.     }
  69.     /* 'background' */
  70.     else if (varp == &p_bg)
  71.     {
  72. if (check_opt_strings(p_bg, p_bg_values, FALSE) == OK)
  73. {
  74.     if (full_screen)
  75. init_highlight(FALSE);
  76. }
  77. else
  78.     errmsg = e_invarg;
  79.     }
  81.     /* 'wildmode' */
  82.     else if (varp == &p_wim)
  83.     {
  84. if (check_opt_wim() == FAIL)
  85.     errmsg = e_invarg;
  86.     }
  88. #if defined(USE_GUI_WIN32) || defined(USE_GUI_MOTIF)
  89.     /* 'winaltkeys' */
  90.     else if (varp == &p_wak)
  91.     {
  92. if (check_opt_strings(p_wak, p_wak_values, FALSE) != OK)
  93.     errmsg = e_invarg;
  94. # ifdef USE_GUI_MOTIF
  95. else if (gui.in_use)
  96.     gui_motif_set_mnemonics(p_wak[0] == 'y' || p_wak[0] == 'm');
  97. # endif
  98.     }
  99. #endif
  101. #ifdef AUTOCMD
  102.     /* 'eventignore' */
  103.     else if (varp == &p_ei)
  104.     {
  105. if (check_ei() == FAIL)
  106.     errmsg = e_invarg;
  107.     }
  108. #endif
  110. #ifdef MULTI_BYTE
  111.     /* 'fileencoding' */
  112.     else if (varp == &(curbuf->b_p_fe))
  113.     {
  114. if (check_opt_strings(curbuf->b_p_fe, p_fe_values, FALSE) != OK)
  115.     errmsg = e_invarg;
  116. else
  117. {
  118.     int is_dbcs_new;
  120.    /* set flags for various items */
  121.     is_dbcs_new = 0;
  122.     is_unicode = 0;
  123.     if (STRCMP(curbuf->b_p_fe, FE_DBJPN) == 0)
  124. is_dbcs_new = DBCS_JPN;
  125.     else if (STRCMP(curbuf->b_p_fe, FE_DBKOR) == 0)
  126. is_dbcs_new = DBCS_KOR;
  127.     else if (STRCMP(curbuf->b_p_fe, FE_DBCHT) == 0)
  128. is_dbcs_new = DBCS_CHT;
  129.     else if (STRCMP(curbuf->b_p_fe, FE_DBCHS) == 0)
  130. is_dbcs_new = DBCS_CHS;
  131.     else if (STRCMP(curbuf->b_p_fe, FE_UNICODE) == 0)
  132.     {
  133. is_unicode = 1;
  134.     }
  135.     /* if a DBCS locale, make sure it is valid */
  136. # ifdef USE_GUI_WIN32
  137.     if (is_dbcs_new)
  138.     {
  139. if (!IsValidCodePage(is_dbcs_new))
  140. {
  141.     errmsg = (char_u *)"Not a valid codepage";
  142. }
  143. else
  144. {
  145.     /* ok code page, so let's set is_dbcs and set pgm
  146.      * language
  147.      * */
  148.     is_dbcs = is_dbcs_new;
  149. }
  150.     }
  151.     else
  152. # endif
  153. is_dbcs = is_dbcs_new;
  154. # ifdef USE_GUI_WIN32
  155.     is_funky_dbcs = is_dbcs && ((int)GetACP() != is_dbcs);
  156. # endif
  157. # ifdef AUTOCMD
  158.     /* fire off an autocommand to let people do custom font setup,
  159.      * whatever */
  160.     if (errmsg == NULL)
  161. apply_autocmds(EVENT_FILEENCODING, NULL, (char_u *)"",
  162.        FALSE, curbuf);
  163. # endif
  164. }
  165.     }
  166. #endif /* MULTI_BYTE */
  168.     /* 'fileformat' */
  169.     else if (varp == &(curbuf->b_p_ff))
  170.     {
  171. if (check_opt_strings(curbuf->b_p_ff, p_ff_values, FALSE) != OK)
  172.     errmsg = e_invarg;
  173. else
  174. {
  175.     /* also change 'textmode' */
  176.     if (get_fileformat(curbuf) == EOL_DOS)
  177. curbuf->b_p_tx = TRUE;
  178.     else
  179. curbuf->b_p_tx = FALSE;
  180. }
  181.     }
  183.     /* 'fileformats' */
  184.     else if (varp == &p_ffs)
  185.     {
  186. if (check_opt_strings(p_ffs, p_ff_values, TRUE) != OK)
  187.     errmsg = e_invarg;
  188. else
  189. {
  190.     /* also change 'textauto' */
  191.     if (*p_ffs == NUL)
  192. p_ta = FALSE;
  193.     else
  194. p_ta = TRUE;
  195. }
  196.     }
  198.     /* 'matchpairs' */
  199.     else if (varp == &(curbuf->b_p_mps))
  200.     {
  201. /* Check for "x:y,x:y" */
  202. for (p = curbuf->b_p_mps; *p; p += 4)
  203. {
  204.     if (!p[0] || p[1] != ':' || !p[2] || (p[3] && p[3] != ','))
  205.     {
  206. errmsg = e_invarg;
  207. break;
  208.     }
  209.     if (!p[3])
  210. break;
  211. }
  212.     }
  214.     /* 'comments' */
  215.     else if (varp == &(curbuf->b_p_com))
  216.     {
  217. for (s = curbuf->b_p_com; *s; )
  218. {
  219.     while (*s && *s != ':')
  220.     {
  221. if (vim_strchr((char_u *)COM_ALL, *s) == NULL)
  222. {
  223.     errmsg = (char_u *)"Illegal flag";
  224.     break;
  225. }
  226. ++s;
  227.     }
  228.     if (*s++ == NUL)
  229. errmsg = (char_u *)"Missing colon";
  230.     else if (*s == ',' || *s == NUL)
  231. errmsg = (char_u *)"Zero length string";
  232.     if (errmsg != NULL)
  233. break;
  234.     while (*s && *s != ',')
  235.     {
  236. if (*s == '\' && s[1] != NUL)
  237.     ++s;
  238. ++s;
  239.     }
  240.     s = skip_to_option_part(s);
  241. }
  242.     }
  244.     /* 'listtabstring' */
  245.     else if (varp == &p_lcs)
  246.     {
  247. int round, i, len;
  249. /* first round: check for valid value, second round: assign values */
  250. for (round = 0; round <= 1 && errmsg == NULL; ++round)
  251. {
  252.     static struct lcstab
  253.     {
  254. int *lcsp;
  255. char *name;
  256.     } lcstab[] =
  257.     {
  258. {&lcs_eol, "eol"},
  259. {&lcs_ext, "extends"},
  260. {&lcs_tab2, "tab"},
  261. {&lcs_trail, "trail"},
  262.     };
  264.     if (round)
  265.     {
  266. for (i = 0; i < sizeof(lcstab) / sizeof(struct lcstab); ++i)
  267.     *(lcstab[i].lcsp) = NUL;
  268. lcs_tab1 = NUL;
  269.     }
  270.     p = p_lcs;
  271.     while (*p)
  272.     {
  273. for (i = 0; i < sizeof(lcstab) / sizeof(struct lcstab); ++i)
  274. {
  275.     len = STRLEN(lcstab[i].name);
  276.     if (STRNCMP(p, lcstab[i].name, len) == 0
  277.     && p[len] == ':'
  278.     && p[len + 1] != NUL)
  279.     {
  280. if (lcstab[i].lcsp == &lcs_tab2)
  281.     ++len;
  282. if (p[len + 1] != NUL
  283.     && (p[len + 2] == ',' || p[len + 2] == NUL))
  284. {
  285.     if (round)
  286.     {
  287. *(lcstab[i].lcsp) = p[len + 1];
  288. if (lcstab[i].lcsp == &lcs_tab2)
  289.     lcs_tab1 = p[len];
  290.     }
  291.     p += len + 2;
  292.     break;
  293. }
  294.     }
  295. }
  297. if (i == sizeof(lcstab) / sizeof(struct lcstab))
  298. {
  299.     errmsg = e_invarg;
  300.     break;
  301. }
  302. if (*p == ',')
  303.     ++p;
  304.     }
  305. }
  306.     }
  308. #ifdef VIMINFO
  309.     /* 'viminfo' */
  310.     else if (varp == &(p_viminfo))
  311.     {
  312. for (s = p_viminfo; *s;)
  313. {
  314.     /* Check it's a valid character */
  315.     if (vim_strchr((char_u *)""'%frn:/", *s) == NULL)
  316.     {
  317. if (errbuf != NULL)
  318. {
  319.     illegal_char(errbuf, *s);
  320.     errmsg = errbuf;
  321. }
  322. else
  323.     errmsg = (char_u *)"";
  324. break;
  325.     }
  326.     if (*s == 'n') /* name is always last one */
  327.     {
  328. break;
  329.     }
  330.     else if (*s == 'r') /* skip until next ',' */
  331.     {
  332. while (*++s && *s != ',')
  333.     ;
  334.     }
  335.     else if (*s == '%') /* no extra chars */
  336. ++s;
  337.     else     /* must have a number */
  338.     {
  339. while (isdigit(*++s))
  340.     ;
  342. if (!isdigit(*(s - 1)))
  343. {
  344.     if (errbuf != NULL)
  345.     {
  346. sprintf((char *)errbuf, "Missing number after <%s>",
  347.  transchar(*(s - 1)));
  348. errmsg = errbuf;
  349.     }
  350.     else
  351. errmsg = (char_u *)"";
  352.     break;
  353. }
  354.     }
  355.     s = skip_to_option_part(s);
  356. }
  357. if (*p_viminfo && errmsg == NULL && get_viminfo_parameter(''') < 0)
  358.     errmsg = (char_u *)"Must specify a ' value";
  359.     }
  360. #endif /* VIMINFO */
  362.     /* terminal options */
  363.     else if (istermoption(&options[opt_idx]) && full_screen)
  364.     {
  365. /* ":set t_Co=0" does ":set t_Co=" */
  366. if (varp == &T_CCO && atoi((char *)T_CCO) == 0)
  367. {
  368.     if (new_value_alloced)
  369. vim_free(T_CCO);
  370.     T_CCO = empty_option;
  371. }
  372. ttest(FALSE);
  373. if (varp == &T_ME)
  374. {
  375.     out_str(T_ME);
  376.     update_screen(CLEAR);
  377. }
  378.     }
  380.     /* 'showbreak' */
  381.     else if (varp == &p_sbr)
  382.     {
  383. for (s = p_sbr; *s; ++s)
  384.     if (charsize(*s) != 1)
  385. errmsg = (char_u *)"contains unprintable character";
  386.     }
  388. #ifdef USE_GUI
  389.     /* 'guifont' */
  390.     else if (varp == &p_guifont)
  391.     {
  392. if (gui.in_use && gui_init_font(p_guifont) != OK)
  393.     errmsg = (char_u *)"Cannot set font(s)";
  394.     }
  395. #endif
  397. #ifdef CURSOR_SHAPE
  398.     /* 'guicursor' */
  399.     else if (varp == &p_guicursor)
  400. errmsg = parse_guicursor();
  401. #endif
  403. #ifdef HAVE_LANGMAP
  404.     /* 'langmap' */
  405.     else if (varp == &p_langmap)
  406. langmap_set();
  407. #endif
  409.     /* 'breakat' */
  410.     else if (varp == &p_breakat)
  411. fill_breakat_flags();
  413.     /* 'titlestring' and 'iconstring' */
  414.     else if (varp == &p_titlestring)
  415. did_set_title(FALSE);
  416.     else if (varp == &p_iconstring)
  417. did_set_title(TRUE);
  419. #ifdef USE_GUI
  420.     /* 'guioptions' */
  421.     else if (varp == &p_guioptions)
  422. gui_init_which_components(oldval);
  423. #endif
  425. #if defined(USE_MOUSE) && defined(UNIX)
  426.     /* 'ttymouse' */
  427.     else if (varp == &p_ttym)
  428.     {
  429. # ifdef XTERM_MOUSE
  430. if (use_xterm_mouse())
  431.     set_mouse_termcode(KS_MOUSE, (char_u *)"33[M");
  432. else
  433.     del_mouse_termcode(KS_MOUSE);
  434. # endif
  435. # ifdef NETTERM_MOUSE
  436. /* can be added always, there is no conflict */
  437. set_mouse_termcode(KS_NETTERM_MOUSE, (char_u *)"33}");
  438. # endif
  439. # ifdef DEC_MOUSE
  440. /* conflicts with xterm mouse: "33[" and "33[M" */
  441. if (!use_xterm_mouse())
  442.     set_mouse_termcode(KS_DEC_MOUSE, (char_u *)"33[");
  443. else
  444.     del_mouse_termcode(KS_DEC_MOUSE);
  445. # endif
  446.     }
  447. #endif
  449.     /* 'selection' */
  450.     else if (varp == &p_sel)
  451.     {
  452. if (*p_sel == NUL
  453. || check_opt_strings(p_sel, p_sel_values, FALSE) != OK)
  454.     errmsg = e_invarg;
  455.     }
  457.     /* 'selectmode' */
  458.     else if (varp == &p_slm)
  459.     {
  460. if (check_opt_strings(p_slm, p_slm_values, TRUE) != OK)
  461.     errmsg = e_invarg;
  462.     }
  464.     /* 'browsedir' */
  465.     else if (varp == &p_bsdir)
  466.     {
  467. if (check_opt_strings(p_bsdir, p_bsdir_values, FALSE) != OK)
  468.     errmsg = e_invarg;
  469.     }
  471.     /* 'keymodel' */
  472.     else if (varp == &p_km)
  473.     {
  474. if (check_opt_strings(p_km, p_km_values, TRUE) != OK)
  475.     errmsg = e_invarg;
  476.     }
  478.     /* 'mousemodel' */
  479.     else if (varp == &p_mousem)
  480.     {
  481. if (check_opt_strings(p_mousem, p_mousem_values, FALSE) != OK)
  482.     errmsg = e_invarg;
  483.     }
  485. #ifdef SYNTAX_HL
  486.     /* When 'syntax' is set, load the syntax of that name */
  487.     else if (varp == &(curbuf->b_p_syn))
  488.     {
  489. p = alloc((unsigned)(STRLEN(curbuf->b_p_syn) + sizeof(SYNTAX_FNAME)));
  490. if (p != NULL)
  491. {
  492.     sprintf((char *)p, SYNTAX_FNAME, curbuf->b_p_syn);
  493.     if (do_source(p, FALSE, FALSE) == FAIL)
  494. errmsg = (char_u *)"syntax file not found";
  495.     vim_free(p);
  496. }
  497.     }
  498. #endif
  500.     /* Options that are a list of flags. */
  501.     else
  502.     {
  503. p = NULL;
  504. if (varp == &p_ww)
  505.     p = (char_u *)WW_ALL;
  506. if (varp == &p_shm)
  507.     p = (char_u *)SHM_ALL;
  508. else if (varp == &(p_cpo))
  509.     p = (char_u *)CPO_ALL;
  510. else if (varp == &(curbuf->b_p_fo))
  511.     p = (char_u *)FO_ALL;
  512. else if (varp == &p_mouse)
  513. {
  514. #ifdef USE_MOUSE
  515.     p = (char_u *)MOUSE_ALL;
  516. #else
  517.     if (*p_mouse != NUL)
  518. errmsg = (char_u *)"No mouse support";
  519. #endif
  520. }
  521. #if defined(USE_GUI) || defined(USE_CLIPBOARD)
  522. else if (varp == &p_guioptions)
  523.     p = (char_u *)GO_ALL;
  524. #endif
  525. if (p != NULL)
  526. {
  527.     for (s = *varp; *s; ++s)
  528. if (vim_strchr(p, *s) == NULL)
  529. {
  530.     if (errbuf != NULL)
  531.     {
  532. illegal_char(errbuf, *s);
  533. errmsg = errbuf;
  534.     }
  535.     else
  536. errmsg = (char_u *)"";
  537.     break;
  538. }
  539. }
  540.     }
  542.     /*
  543.      * If error detected, restore the previous value.
  544.      */
  545.     if (errmsg != NULL)
  546.     {
  547. if (new_value_alloced)
  548.     vim_free(*varp);
  549. *varp = oldval;
  550. /*
  551.  * When resetting some values, need to act on it.
  552.  */
  553. if (did_chartab)
  554.     (void)init_chartab();
  555. if (varp == &p_hl)
  556.     (void)highlight_changed();
  557.     }
  558.     else
  559.     {
  560. /*
  561.  * Free string options that are in allocated memory.
  562.  */
  563. if (options[opt_idx].flags & P_ALLOCED)
  564.     free_string_option(oldval);
  565. if (new_value_alloced)
  566.     options[opt_idx].flags |= P_ALLOCED;
  567. else
  568.     options[opt_idx].flags &= ~P_ALLOCED;
  569.     }
  571. #ifdef USE_MOUSE
  572.     if (varp == &p_mouse)
  573.     {
  574. if (*p_mouse == NUL)
  575.     mch_setmouse(FALSE);    /* switch mouse off */
  576. else
  577.     setmouse();     /* in case 'mouse' changed */
  578.     }
  579. #endif
  581.     curwin->w_set_curswant = TRUE;  /* in case 'showbreak' changed */
  582.     check_redraw(options[opt_idx].flags);
  584.     return errmsg;
  585. }
  587. /*
  588.  * Set the value of a boolean option, and take care of side effects.
  589.  * Returns NULL for success, or an error message for an error.
  590.  */
  591.     static char_u *
  592. set_bool_option(opt_idx, varp, value)
  593.     int     opt_idx;     /* index in options[] table */
  594.     char_u  *varp;     /* pointer to the option variable */
  595.     int     value;     /* new value */
  596. {
  597.     int     old_p_bin = curbuf->b_p_bin;    /* remember old 'bin' */
  598.     int     old_p_ea = p_ea;     /* remember old 'equalalways' */
  599.     int     old_p_wiv = p_wiv;     /* remember old 'weirdinvert' */
  600. #ifdef FKMAP
  601.     int     old_akm = p_altkeymap;     /* previous value if p_altkeymap*/
  602. #endif
  604.     /*
  605.      * in secure mode, setting of the secure option is not
  606.      * allowed
  607.      */
  608.     if (secure && (int *)varp == &p_secure)
  609. return (char_u *)"not allowed here";
  611. #ifdef USE_GUI
  612.     need_mouse_correct = TRUE;
  613. #endif
  615.     *(int *)varp = value;     /* set the new value */
  617.     /* handle the setting of the compatible option */
  618.     if ((int *)varp == &p_cp)
  619.     {
  620. compatible_set();
  621.     }
  623.     /* when 'readonly' is reset, also reset readonlymode */
  624.     else if ((int *)varp == &curbuf->b_p_ro && !curbuf->b_p_ro)
  625. readonlymode = FALSE;
  627.     /* when 'bin' is set also set some other options */
  628.     else if ((int *)varp == &curbuf->b_p_bin)
  629.     {
  630. set_options_bin(old_p_bin, curbuf->b_p_bin);
  631.     }
  633.     /* when 'swf' is set create swapfile, when reset remove swapfile */
  634.     else if ((int *)varp == &curbuf->b_p_swf)
  635.     {
  636. if (curbuf->b_p_swf && p_uc)
  637.     ml_open_file(curbuf); /* create the swap file */
  638. else
  639.     mf_close_file(curbuf); /* remove the swap file */
  640.     }
  642.     /* when 'terse' is set change 'shortmess' */
  643.     else if ((int *)varp == &p_terse)
  644.     {
  645. char_u *p;
  647. p = vim_strchr(p_shm, SHM_SEARCH);
  649. /* insert 's' in p_shm */
  650. if (p_terse && p == NULL)
  651. {
  652.     STRCPY(IObuff, p_shm);
  653.     STRCAT(IObuff, "s");
  654.     set_string_option_direct((char_u *)"shm", -1, IObuff, TRUE);
  655. }
  656. /* remove 's' from p_shm */
  657. else if (!p_terse && p != NULL)
  658.     mch_memmove(p, p + 1, STRLEN(p));
  659.     }
  660.     /* when 'paste' is set or reset also change other options */
  661.     else if ((int *)varp == &p_paste)
  662.     {
  663. paste_option_changed();
  664.     }
  665.     /* when 'ignorecase' is set or reset and 'hlsearch' is set, redraw */
  666.     else if ((int *)varp == &p_ic && p_hls)
  667.     {
  668. redraw_all_later(NOT_VALID);
  669.     }
  670. #ifdef EXTRA_SEARCH
  671.     /* when 'hlsearch' is set or reset reset no_hlsearch */
  672.     else if ((int *)varp == &p_hls)
  673.     {
  674. no_hlsearch = FALSE;
  675.     }
  676. #endif
  677.     /* when 'textmode' is set or reset also change 'fileformat' */
  678.     else if ((int *)varp == &curbuf->b_p_tx)
  679.     {
  680. set_fileformat(curbuf->b_p_tx ? EOL_DOS : EOL_UNIX);
  681.     }
  682.     /* when 'textauto' is set or reset also change 'fileformats' */
  683.     else if ((int *)varp == &p_ta)
  684.     {
  685. set_string_option_direct((char_u *)"ffs", -1,
  686.       p_ta ? (char_u *)FFS_DFLT : (char_u *)"", TRUE);
  687.     }
  688.     /*
  689.      * When 'lisp' option changes include/exclude '-' in
  690.      * keyword characters.
  691.      */
  692. #ifdef LISPINDENT
  693.     else if (varp == (char_u *)&(curbuf->b_p_lisp))
  694. init_chartab();     /* ignore errors */
  695. #endif
  696.     /* when 'title' changed, may need to change the title; same for 'icon' */
  697.     else if ((int *)varp == &p_title)
  698. did_set_title(FALSE);
  699.     else if ((int *)varp == &p_icon)
  700. did_set_title(TRUE);
  701.     else if ((int *)varp == &curbuf->b_changed)
  702.     {
  703. if (!value)
  704.     curbuf->b_start_ffc = *curbuf->b_p_ff;    /* Buffer is unchanged */
  705. #ifdef AUTOCMD
  706. modified_was_set = value;
  707. #endif
  708.     }
  710.     if (p_ea && !old_p_ea)
  711. win_equal(curwin, FALSE);
  713.     /*
  714.      * When 'weirdinvert' changed, set/reset 't_xs'.
  715.      * Then set 'weirdinvert' according to value of 't_xs'.
  716.      */
  717.     if (p_wiv && !old_p_wiv)
  718. T_XS = (char_u *)"y";
  719.     else if (!p_wiv && old_p_wiv)
  720. T_XS = empty_option;
  721.     p_wiv = (*T_XS != NUL);
  723. #ifdef FKMAP
  724.     /*
  725.      * In case some second language keymapping options have changed, check
  726.      * and correct the setting in a consistent way.
  727.      */
  728.     if (old_akm != p_altkeymap)
  729.     {
  730. if (!p_altkeymap)
  731. {
  732.     p_hkmap = p_fkmap;
  733.     p_fkmap = 0;
  734.     init_chartab();
  735. }
  736. else
  737. {
  738.     p_fkmap = p_hkmap;
  739.     p_hkmap = 0;
  740.     init_chartab();
  741. }
  742.     }
  744.     /*
  745.      * If hkmap set, reset Farsi keymapping.
  746.      */
  747.     if (p_hkmap && p_altkeymap)
  748.     {
  749. p_altkeymap = 0;
  750. p_fkmap = 0;
  751. init_chartab();
  752.     }
  754.     /*
  755.      * If fkmap set, reset Hebrew keymapping.
  756.      */
  757.     if (p_fkmap && !p_altkeymap)
  758.     {
  759. p_altkeymap = 1;
  760. p_hkmap = 0;
  761. init_chartab();
  762.     }
  763. #endif
  765.     options[opt_idx].flags |= P_WAS_SET;
  767.     comp_col();     /* in case 'ruler' or 'showcmd' changed */
  768.     curwin->w_set_curswant = TRUE;  /* in case 'list' changed */
  769.     check_redraw(options[opt_idx].flags);
  771.     return NULL;
  772. }
  774. /*
  775.  * Set the value of a number option, and take care of side effects.
  776.  * Returns NULL for success, or an error message for an error.
  777.  */
  778.     static char_u *
  779. set_num_option(opt_idx, varp, value, errbuf)
  780.     int     opt_idx;     /* index in options[] table */
  781.     char_u  *varp;     /* pointer to the option variable */
  782.     long    value;     /* new value */
  783.     char_u  *errbuf;     /* buffer for error messages */
  784. {
  785.     char_u  *errmsg = NULL;
  786.     long    old_Rows = Rows; /* remember old Rows */
  787.     long    old_Columns = Columns; /* remember old Columns */
  788.     long    old_p_ch = p_ch; /* remember old command line height */
  789.     long    old_p_uc = p_uc; /* remember old 'updatecount' */
  790.     long    old_titlelen = p_titlelen; /* remember old 'titlelen' */
  792. #ifdef USE_GUI
  793.     need_mouse_correct = TRUE;
  794. #endif
  796.     *(long *)varp = value;
  798.     /*
  799.      * Number options that need some action when changed
  800.      */
  801.     if ((long *)varp == &p_wh || (long *)varp == &p_hh)
  802.     {
  803. if (p_wh < 1)
  804. {
  805.     errmsg = e_positive;
  806.     p_wh = 1;
  807. }
  808. if (p_wmh > p_wh)
  809. {
  810.     errmsg = (char_u *)"'winheight' cannot be smaller than 'winminheight'";
  811.     p_wh = p_wmh;
  812. }
  813. if (p_hh < 0)
  814. {
  815.     errmsg = e_positive;
  816.     p_hh = 0;
  817. }
  819. /* Change window height NOW */
  820. if (lastwin != firstwin)
  821. {
  822.     if ((long *)varp == &p_wh && curwin->w_height < p_wh)
  823. win_setheight((int)p_wh);
  824.     if ((long *)varp == &p_hh && curbuf->b_help
  825.    && curwin->w_height < p_hh)
  826. win_setheight((int)p_hh);
  827. }
  828.     }
  830.     /* 'winminheight' */
  831.     else if ((long *)varp == &p_wmh)
  832.     {
  833. if (p_wmh < 0)
  834. {
  835.     errmsg = e_positive;
  836.     p_wh = 0;
  837. }
  838. if (p_wmh > p_wh)
  839. {
  840.     errmsg = (char_u *)"'winheight' cannot be smaller than 'winminheight'";
  841.     p_wmh = p_wh;
  842. }
  843. win_setminheight();
  844.     }
  846.     /* (re)set last window status line */
  847.     else if ((long *)varp == &p_ls)
  848.     {
  849. last_status();
  850.     }
  852.     /*
  853.      * Check the bounds for numeric options here
  854.      */
  855.     if (Rows < min_rows() && full_screen)
  856.     {
  857. if (errbuf != NULL)
  858. {
  859.     sprintf((char *)errbuf, "Need at least %d lines", min_rows());
  860.     errmsg = errbuf;
  861. }
  862. Rows = min_rows();
  863.     }
  864.     if (Columns < MIN_COLUMNS && full_screen)
  865.     {
  866. if (errbuf != NULL)
  867. {
  868.     sprintf((char *)errbuf, "Need at least %d columns", MIN_COLUMNS);
  869.     errmsg = errbuf;
  870. }
  871. Columns = MIN_COLUMNS;
  872.     }
  873.     /*
  874.      * If the screenheight has been changed, assume it is the physical
  875.      * screenheight.
  876.      */
  877.     if ((old_Rows != Rows || old_Columns != Columns) && full_screen)
  878.     {
  879. ui_set_winsize();     /* try to change the window size */
  880. check_winsize();     /* in case 'columns' changed */
  881. #ifdef MSDOS
  882. set_window();     /* active window may have changed */
  883. #endif
  884.     }
  886.     if (curbuf->b_p_sts < 0)
  887.     {
  888. errmsg = e_positive;
  889. curbuf->b_p_sts = 0;
  890.     }
  891.     if (curbuf->b_p_ts <= 0)
  892.     {
  893. errmsg = e_positive;
  894. curbuf->b_p_ts = 8;
  895.     }
  896.     if (curbuf->b_p_tw < 0)
  897.     {
  898. errmsg = e_positive;
  899. curbuf->b_p_tw = 0;
  900.     }
  901.     if (p_tm < 0)
  902.     {
  903. errmsg = e_positive;
  904. p_tm = 0;
  905.     }
  906.     if (p_titlelen <= 0)
  907.     {
  908. errmsg = e_positive;
  909. p_titlelen = 85;
  910.     }
  911.     if ((curwin->w_p_scroll <= 0
  912. || (curwin->w_p_scroll > curwin->w_height
  913.     && curwin->w_height > 0))
  914.     && full_screen)
  915.     {
  916. if (curwin->w_p_scroll != 0)
  917.     errmsg = e_scroll;
  918. win_comp_scroll(curwin);
  919.     }
  920.     if (p_report < 0)
  921.     {
  922. errmsg = e_positive;
  923. p_report = 1;
  924.     }
  925.     if ((p_sj < 0 || p_sj >= Rows) && full_screen)
  926.     {
  927. if (Rows != old_Rows)     /* Rows changed, just adjust p_sj */
  928.     p_sj = Rows / 2;
  929. else
  930. {
  931.     errmsg = e_scroll;
  932.     p_sj = 1;
  933. }
  934.     }
  935.     if (p_so < 0 && full_screen)
  936.     {
  937. errmsg = e_scroll;
  938. p_so = 0;
  939.     }
  940.     if (p_uc < 0)
  941.     {
  942. errmsg = e_positive;
  943. p_uc = 100;
  944.     }
  945.     if (p_ch < 1)
  946.     {
  947. errmsg = e_positive;
  948. p_ch = 1;
  949.     }
  950.     if (p_ut < 0)
  951.     {
  952. errmsg = e_positive;
  953. p_ut = 2000;
  954.     }
  955.     if (p_ss < 0)
  956.     {
  957. errmsg = e_positive;
  958. p_ss = 0;
  959.     }
  961.     /* when 'updatecount' changes from zero to non-zero, open swap files */
  962.     if (p_uc && !old_p_uc)
  963. ml_open_files();
  965.     /* if p_ch changed value, change the command line height */
  966.     if (p_ch != old_p_ch)
  967. command_height(old_p_ch);
  969.     /* if 'titlelen' has changed, redraw the title */
  970.     if (old_titlelen != p_titlelen && !starting)
  971. maketitle();
  973.     options[opt_idx].flags |= P_WAS_SET;
  975.     comp_col();     /* in case 'columns' or 'ls' changed */
  976.     curwin->w_set_curswant = TRUE;  /* in case 'tabstop' changed */
  977.     check_redraw(options[opt_idx].flags);
  979.     return errmsg;
  980. }
  982. /*
  983.  * Called after an option changed: check if something needs to be redrawn.
  984.  */
  985.     static void
  986. check_redraw(flags)
  987.     int     flags;
  988. {
  989.     if (flags & (P_RSTAT | P_RALL)) /* mark all status lines dirty */
  990. status_redraw_all();
  992.     if (flags & (P_RBUF | P_RALL))
  993.     {
  994. /* Update cursor position and botline (wrapping my have changed). */
  995. changed_line_abv_curs();
  996. invalidate_botline();
  997. update_topline();
  998.     }
  1000.     if (flags & P_RBUF)
  1001. redraw_curbuf_later(NOT_VALID);
  1002.     if (flags & P_RALL)
  1003. redraw_all_later(NOT_VALID);
  1004. }
  1006. /*
  1007.  * Find index for option 'arg'.
  1008.  * Return -1 if not found.
  1009.  */
  1010.     static int
  1011. findoption(arg)
  1012.     char_u *arg;
  1013. {
  1014.     int     opt_idx;
  1015.     char     *s, *p;
  1016.     static short    quick_tab[27] = {0, 0}; /* quick access table */
  1017.     int     is_term_opt;
  1019.     /*
  1020.      * For first call: Initialize the quick-access table.
  1021.      * It contains the index for the first option that starts with a certain
  1022.      * letter.  There are 26 letters, plus the first "t_" option.
  1023.      */
  1024.     if (quick_tab[1] == 0)
  1025.     {
  1026. p = options[0].fullname;
  1027. for (opt_idx = 1; (s = options[opt_idx].fullname) != NULL; opt_idx++)
  1028. {
  1029.     if (s[0] != p[0])
  1030.     {
  1031. if (s[0] == 't' && s[1] == '_')
  1032.     quick_tab[26] = opt_idx;
  1033. else
  1034.     quick_tab[s[0] - 'a'] = opt_idx;
  1035.     }
  1036.     p = s;
  1037. }
  1038.     }
  1040.     /*
  1041.      * Check for name starting with an illegal character.
  1042.      */
  1043.     if (arg[0] < 'a' || arg[0] > 'z')
  1044. return -1;
  1046.     is_term_opt = (arg[0] == 't' && arg[1] == '_');
  1047.     if (is_term_opt)
  1048. opt_idx = quick_tab[26];
  1049.     else
  1050. opt_idx = quick_tab[arg[0] - 'a'];
  1051.     for ( ; (s = options[opt_idx].fullname) != NULL; opt_idx++)
  1052.     {
  1053. if (STRCMP(arg, s) == 0)     /* match full name */
  1054.     break;
  1055.     }
  1056.     if (s == NULL && !is_term_opt)
  1057.     {
  1058. opt_idx = quick_tab[arg[0] - 'a'];
  1059. for ( ; options[opt_idx].fullname != NULL; opt_idx++)
  1060. {
  1061.     s = options[opt_idx].shortname;
  1062.     if (s != NULL && STRCMP(arg, s) == 0)   /* match short name */
  1063. break;
  1064.     s = NULL;
  1065. }
  1066.     }
  1067.     if (s == NULL)
  1068. opt_idx = -1;
  1069.     return opt_idx;
  1070. }
  1072. /*
  1073.  * Get the value for an option.
  1074.  *
  1075.  * Returns:
  1076.  * Number or Toggle option: 1, *numval gets value.
  1077.  *      String option: 0, *stringval gets allocated string.
  1078.  *     unknown option: -1.
  1079.  */
  1080.     int
  1081. get_option_value(name, numval, stringval)
  1082.     char_u *name;
  1083.     long *numval;
  1084.     char_u **stringval;     /* NULL when only checking existance */
  1085. {
  1086.     int     opt_idx;
  1087.     char_u  *varp;
  1089.     opt_idx = findoption(name);
  1090.     if (opt_idx < 0)     /* unknown option */
  1091. return -1;
  1093.     varp = get_varp(&(options[opt_idx]));
  1094.     if (varp == NULL)     /* hidden option */
  1095. return -1;
  1097.     if (options[opt_idx].flags & P_STRING)
  1098.     {
  1099. if (stringval != NULL)
  1100.     *stringval = vim_strsave(*(char_u **)(varp));
  1101. return 0;
  1102.     }
  1103.     if (options[opt_idx].flags & P_NUM)
  1104. *numval = *(long *)varp;
  1105.     else
  1106. *numval = *(int *)varp;
  1107.     return 1;
  1108. }
  1110. /*
  1111.  * Set the value of option "name".
  1112.  * Use "string" for string options, use "number" for other options.
  1113.  */
  1114.     void
  1115. set_option_value(name, number, string)
  1116.     char_u *name;
  1117.     long number;
  1118.     char_u *string;
  1119. {
  1120.     int     opt_idx;
  1121.     char_u  *varp;
  1123.     opt_idx = findoption(name);
  1124.     if (opt_idx == -1)
  1125. EMSG2("Unknown option: %s", name);
  1126.     else if (options[opt_idx].flags & P_STRING)
  1127. set_string_option(opt_idx, string);
  1128.     else
  1129.     {
  1130. varp = get_varp(&options[opt_idx]);
  1131. if (varp != NULL) /* hidden option is not changed */
  1132. {
  1133.     if (options[opt_idx].flags & P_NUM)
  1134. (void)set_num_option(opt_idx, varp, number, NULL);
  1135.     else
  1136. (void)set_bool_option(opt_idx, varp, (int)number);
  1137. }
  1138.     }
  1139. }
  1141. /*
  1142.  * Get the terminal code for a terminal option.
  1143.  * Returns NULL when not found.
  1144.  */
  1145.     char_u *
  1146. get_term_code(tname)
  1147.     char_u *tname;
  1148. {
  1149.     int     opt_idx;
  1150.     char_u  *varp;
  1152.     if (tname[0] != 't' || tname[1] != '_' ||
  1153.     tname[2] == NUL || tname[3] == NUL)
  1154. return NULL;
  1155.     if ((opt_idx = findoption(tname)) >= 0)
  1156.     {
  1157. varp = get_varp(&(options[opt_idx]));
  1158. if (varp != NULL)
  1159.     varp = *(char_u **)(varp);
  1160. return varp;
  1161.     }
  1162.     return find_termcode(tname + 2);
  1163. }
  1165.     char_u *
  1166. get_highlight_default()
  1167. {
  1168.     int i;
  1170.     i = findoption((char_u *)"hl");
  1171.     if (i >= 0)
  1172. return options[i].def_val[VI_DEFAULT];
  1173.     return (char_u *)NULL;
  1174. }
  1176. /*
  1177.  * Translate a string like "t_xx", "<t_xx>" or "<S-Tab>" to a key number.
  1178.  */
  1179.     static int
  1180. find_key_option(arg)
  1181.     char_u *arg;
  1182. {
  1183.     int key;
  1184.     int modifiers;
  1186.     /*
  1187.      * Don't use get_special_key_code() for t_xx, we don't want it to call
  1188.      * add_termcap_entry().
  1189.      */
  1190.     if (arg[0] == 't' && arg[1] == '_' && arg[2] && arg[3])
  1191. key = TERMCAP2KEY(arg[2], arg[3]);
  1192.     else
  1193.     {
  1194. --arg;     /* put arg at the '<' */
  1195. key = find_special_key(&arg, &modifiers, TRUE);
  1196. if (modifiers)     /* can't handle modifiers here */
  1197.     key = 0;
  1198.     }
  1199.     return key;
  1200. }
  1202. /*
  1203.  * if 'all' == 0: show changed options
  1204.  * if 'all' == 1: show all normal options
  1205.  * if 'all' == 2: show all terminal options
  1206.  */
  1207.     static void
  1208. showoptions(all)
  1209.     int all;
  1210. {
  1211.     struct vimoption   *p;
  1212.     int     col;
  1213.     int     isterm;
  1214.     char_u     *varp;
  1215.     struct vimoption **items;
  1216.     int     item_count;
  1217.     int     run;
  1218.     int     row, rows;
  1219.     int     cols;
  1220.     int     i;
  1221.     int     len;
  1223. #define INC 20
  1224. #define GAP 3
  1226.     items = (struct vimoption **)alloc((unsigned)(sizeof(struct vimoption *) *
  1227. PARAM_COUNT));
  1228.     if (items == NULL)
  1229. return;
  1231.     /* Highlight title */
  1232.     if (all == 2)
  1233. MSG_PUTS_TITLE("n--- Terminal codes ---");
  1234.     else
  1235. MSG_PUTS_TITLE("n--- Options ---");
  1237.     /*
  1238.      * do the loop two times:
  1239.      * 1. display the short items
  1240.      * 2. display the long items (only strings and numbers)
  1241.      */
  1242.     for (run = 1; run <= 2 && !got_int; ++run)
  1243.     {
  1244. /*
  1245.  * collect the items in items[]
  1246.  */
  1247. item_count = 0;
  1248. for (p = &options[0]; p->fullname != NULL; p++)
  1249. {
  1250.     isterm = istermoption(p);
  1251.     varp = get_varp(p);
  1252.     if (varp != NULL && (
  1253. (all == 2 && isterm) ||
  1254. (all == 1 && !isterm) ||
  1255. (all == 0 && option_not_default(p))))
  1256.     {
  1257. if (p->flags & P_BOOL)
  1258.     len = 1; /* a toggle option fits always */
  1259. else
  1260. {
  1261.     option_value2string(p);
  1262.     len = STRLEN(p->fullname) + vim_strsize(NameBuff) + 1;
  1263. }
  1264. if ((len <= INC - GAP && run == 1) ||
  1265. (len > INC - GAP && run == 2))
  1266.     items[item_count++] = p;
  1267.     }
  1268. }
  1270. /*
  1271.  * display the items
  1272.  */
  1273. if (run == 1)
  1274. {
  1275.     cols = (Columns + GAP - 3) / INC;
  1276.     if (cols == 0)
  1277. cols = 1;
  1278.     rows = (item_count + cols - 1) / cols;
  1279. }
  1280. else /* run == 2 */
  1281.     rows = item_count;
  1282. for (row = 0; row < rows && !got_int; ++row)
  1283. {
  1284.     msg_putchar('n'); /* go to next line */
  1285.     if (got_int) /* 'q' typed in more */
  1286. break;
  1287.     col = 0;
  1288.     for (i = row; i < item_count; i += rows)
  1289.     {
  1290. msg_col = col; /* make columns */
  1291. showoneopt(items[i]);
  1292. col += INC;
  1293.     }
  1294.     out_flush();
  1295.     ui_breakcheck();
  1296. }
  1297.     }
  1298.     vim_free(items);
  1299. }
  1301. /*
  1302.  * Return TRUE if option is different from the default value
  1303.  */
  1304.     static int
  1305. option_not_default(p)
  1306.     struct vimoption *p;
  1307. {
  1308.     char_u  *varp;
  1309.     int     dvi;
  1311.     varp = get_varp(p);
  1312.     if (varp == NULL)
  1313. return FALSE; /* hidden option is never changed */
  1315.     if ((p->flags & P_VI_DEF) || p_cp)
  1316. dvi = VI_DEFAULT;
  1317.     else
  1318. dvi = VIM_DEFAULT;
  1319.     if (p->flags & P_NUM)
  1320. return (*(long *)varp != (long)p->def_val[dvi]);
  1321.     if (p->flags & P_BOOL)
  1322. /* the cast to long is required for Manx C */
  1323. return (*(int *)varp != (int)(long)p->def_val[dvi]);
  1324.     /* P_STRING */
  1325.     return STRCMP(*(char_u **)varp, p->def_val[dvi]);
  1326. }
  1328. /*
  1329.  * showoneopt: show the value of one option
  1330.  * must not be called with a hidden option!
  1331.  */
  1332.     static void
  1333. showoneopt(p)
  1334.     struct vimoption *p;
  1335. {
  1336.     char_u     *varp;
  1338.     varp = get_varp(p);
  1340.     if ((p->flags & P_BOOL) && !*(int *)varp)
  1341. MSG_PUTS("no");
  1342.     else
  1343. MSG_PUTS("  ");
  1344.     MSG_PUTS(p->fullname);
  1345.     if (!(p->flags & P_BOOL))
  1346.     {
  1347. msg_putchar('=');
  1348. option_value2string(p);     /* put string of option value in NameBuff */
  1349. msg_outtrans(NameBuff);
  1350.     }
  1351. }
  1353. /*
  1354.  * Write modified options as set command to a file.
  1355.  * Return FAIL on error, OK otherwise.
  1356.  */
  1357.     int
  1358. makeset(fd)
  1359.     FILE *fd;
  1360. {
  1361.     struct vimoption *p;
  1362.     char_u     *s;
  1363.     int     e;
  1364.     char_u     *varp;
  1366.     /*
  1367.      * The options that don't have a default (terminal name, columns, lines)
  1368.      * are never written. Terminal options are also not written.
  1369.      */
  1370.     for (p = &options[0]; !istermoption(p); p++)
  1371. if (!(p->flags & P_NO_MKRC) && !istermoption(p)
  1372.    && (option_not_default(p)))
  1373. {
  1374.     varp = get_varp(p);
  1375.     if (p->flags & P_BOOL)
  1376. fprintf(fd, "set %s%s", *(int *)(varp) ? "" : "no",
  1377.  p->fullname);
  1378.     else if (p->flags & P_NUM)
  1379. fprintf(fd, "set %s=%ld", p->fullname, *(long *)(varp));
  1380.     else    /* P_STRING */
  1381.     {
  1382. fprintf(fd, "set %s=", p->fullname);
  1383. s = *(char_u **)(varp);
  1384. /* some characters have to be escaped with CTRL-V or
  1385.  * backslash */
  1386. if (s != NULL && putescstr(fd, s, TRUE) == FAIL)
  1387.     return FAIL;
  1388.     }
  1389. #ifdef USE_CRNL
  1390.     putc('r', fd);
  1391. #endif
  1392. /*
  1393.  * Only check error for this putc, should catch at least
  1394.  * the "disk full" situation.
  1395.  */
  1396.     e = putc('n', fd);
  1397.     if (e < 0)
  1398. return FAIL;
  1399. }
  1400.     return OK;
  1401. }
  1403. /*
  1404.  * Clear all the terminal options.
  1405.  * If the option has been allocated, free the memory.
  1406.  * Terminal options are never hidden or indirect.
  1407.  */
  1408.     void
  1409. clear_termoptions()
  1410. {
  1411.     struct vimoption   *p;
  1413.     /*
  1414.      * Reset a few things before clearing the old options. This may cause
  1415.      * outputting a few things that the terminal doesn't understand, but the
  1416.      * screen will be cleared later, so this is OK.
  1417.      */
  1418. #ifdef USE_MOUSE
  1419.     mch_setmouse(FALSE);     /* switch mouse off */
  1420. #endif
  1421.     mch_restore_title(3);     /* restore window titles */
  1422. #ifdef WIN32
  1423.     /*
  1424.      * Check if this is allowed now.
  1425.      */
  1426.     if (can_end_termcap_mode(FALSE) == TRUE)
  1427. #endif
  1428. stoptermcap(); /* stop termcap mode */
  1430.     for (p = &options[0]; p->fullname != NULL; p++)
  1431. if (istermoption(p))
  1432. {
  1433.     if (p->flags & P_ALLOCED)
  1434. free_string_option(*(char_u **)(p->var));
  1435.     if (p->flags & P_DEF_ALLOCED)
  1436. free_string_option(p->def_val[VI_DEFAULT]);
  1437.     *(char_u **)(p->var) = empty_option;
  1438.     p->def_val[VI_DEFAULT] = empty_option;
  1439.     p->flags &= ~(P_ALLOCED|P_DEF_ALLOCED);
  1440. }
  1441.     clear_termcodes();
  1442. }
  1444. /*
  1445.  * Set the terminal option defaults to the current value.
  1446.  * Used after setting the terminal name.
  1447.  */
  1448.     void
  1449. set_term_defaults()
  1450. {
  1451.     struct vimoption   *p;
  1453.     for (p = &options[0]; p->fullname != NULL; p++)
  1454. if (istermoption(p) && p->def_val[VI_DEFAULT] != *(char_u **)(p->var))
  1455. {
  1456.     if (p->flags & P_DEF_ALLOCED)
  1457.     {
  1458. free_string_option(p->def_val[VI_DEFAULT]);
  1459. p->flags &= ~P_DEF_ALLOCED;
  1460.     }
  1461.     p->def_val[VI_DEFAULT] = *(char_u **)(p->var);
  1462.     if (p->flags & P_ALLOCED)
  1463.     {
  1464. p->flags |= P_DEF_ALLOCED;
  1465. p->flags &= ~P_ALLOCED;     /* don't free the value now */
  1466.     }
  1467. }
  1468. }
  1470. /*
  1471.  * return TRUE if 'p' starts with 't_'
  1472.  */
  1473.     static int
  1474. istermoption(p)
  1475.     struct vimoption *p;
  1476. {
  1477.     return (p->fullname[0] == 't' && p->fullname[1] == '_');
  1478. }
  1480. /*
  1481.  * Compute columns for ruler and shown command. 'sc_col' is also used to
  1482.  * decide what the maximum length of a message on the status line can be.
  1483.  * If there is a status line for the last window, 'sc_col' is independent
  1484.  * of 'ru_col'.
  1485.  */
  1487. #define COL_RULER 17     /* columns needed by ruler */
  1489.     void
  1490. comp_col()
  1491. {
  1492.     int last_has_status = (p_ls == 2 || (p_ls == 1 && firstwin != lastwin));
  1494.     sc_col = 0;
  1495.     ru_col = 0;
  1496.     if (p_ru)
  1497.     {
  1498. ru_col = COL_RULER + 1;
  1499. /* no last status line, adjust sc_col */
  1500. if (!last_has_status)
  1501.     sc_col = ru_col;
  1502.     }
  1503.     if (p_sc)
  1504.     {
  1505. sc_col += SHOWCMD_COLS;
  1506. if (!p_ru || last_has_status)     /* no need for separating space */
  1507.     ++sc_col;
  1508.     }
  1509.     sc_col = Columns - sc_col;
  1510.     ru_col = Columns - ru_col;
  1511.     if (sc_col <= 0) /* screen too narrow, will become a mess */
  1512. sc_col = 1;
  1513.     if (ru_col <= 0)
  1514. ru_col = 1;
  1515. }
  1517.     static char_u *
  1518. get_varp(p)
  1519.     struct vimoption *p;
  1520. {
  1521.     if (!(p->flags & P_IND) || p->var == NULL)
  1522. return p->var;
  1524.     switch ((long)(p->var))
  1525.     {
  1526. case PV_LIST: return (char_u *)&(curwin->w_p_list);
  1527. case PV_NU: return (char_u *)&(curwin->w_p_nu);
  1528. #ifdef RIGHTLEFT
  1529. case PV_RL: return (char_u *)&(curwin->w_p_rl);
  1530. #endif
  1531. case PV_SCROLL: return (char_u *)&(curwin->w_p_scroll);
  1532. case PV_WRAP: return (char_u *)&(curwin->w_p_wrap);
  1533. case PV_LBR: return (char_u *)&(curwin->w_p_lbr);
  1535. case PV_AI: return (char_u *)&(curbuf->b_p_ai);
  1536. case PV_BIN: return (char_u *)&(curbuf->b_p_bin);
  1537. #ifdef CINDENT
  1538. case PV_CIN: return (char_u *)&(curbuf->b_p_cin);
  1539. case PV_CINK: return (char_u *)&(curbuf->b_p_cink);
  1540. case PV_CINO: return (char_u *)&(curbuf->b_p_cino);
  1541. #endif
  1542. #if defined(SMARTINDENT) || defined(CINDENT)
  1543. case PV_CINW: return (char_u *)&(curbuf->b_p_cinw);
  1544. #endif
  1545. case PV_COM: return (char_u *)&(curbuf->b_p_com);
  1546. #ifdef INSERT_EXPAND
  1547. case PV_CPT: return (char_u *)&(curbuf->b_p_cpt);
  1548. #endif
  1549. case PV_EOL: return (char_u *)&(curbuf->b_p_eol);
  1550. case PV_ET: return (char_u *)&(curbuf->b_p_et);
  1551. #ifdef MULTI_BYTE
  1552. case PV_FE: return (char_u *)&(curbuf->b_p_fe);
  1553. #endif
  1554. case PV_FF: return (char_u *)&(curbuf->b_p_ff);
  1555. #ifdef WANT_FILETYPE
  1556. case PV_FT: return (char_u *)&(curbuf->b_p_ft);
  1557. #endif
  1558. case PV_FO: return (char_u *)&(curbuf->b_p_fo);
  1559. case PV_INF: return (char_u *)&(curbuf->b_p_inf);
  1560. case PV_ISK: return (char_u *)&(curbuf->b_p_isk);
  1561. case PV_LISP: return (char_u *)&(curbuf->b_p_lisp);
  1562. case PV_ML: return (char_u *)&(curbuf->b_p_ml);
  1563. case PV_MPS: return (char_u *)&(curbuf->b_p_mps);
  1564. case PV_MOD: return (char_u *)&(curbuf->b_changed);
  1565. case PV_NF: return (char_u *)&(curbuf->b_p_nf);
  1566. case PV_RO: return (char_u *)&(curbuf->b_p_ro);
  1567. #ifdef SMARTINDENT
  1568. case PV_SI: return (char_u *)&(curbuf->b_p_si);
  1569. #endif
  1570. #ifndef SHORT_FNAME
  1571. case PV_SN: return (char_u *)&(curbuf->b_p_sn);
  1572. #endif
  1573. case PV_STS: return (char_u *)&(curbuf->b_p_sts);
  1574. case PV_SWF: return (char_u *)&(curbuf->b_p_swf);
  1575. #ifdef SYNTAX_HL
  1576. case PV_SYN: return (char_u *)&(curbuf->b_p_syn);
  1577. #endif
  1578. case PV_SW: return (char_u *)&(curbuf->b_p_sw);
  1579. case PV_TS: return (char_u *)&(curbuf->b_p_ts);
  1580. case PV_TW: return (char_u *)&(curbuf->b_p_tw);
  1581. case PV_TX: return (char_u *)&(curbuf->b_p_tx);
  1582. case PV_WM: return (char_u *)&(curbuf->b_p_wm);
  1583. default: EMSG("get_varp ERROR");
  1584.     }
  1585.     /* always return a valid pointer to avoid a crash! */
  1586.     return (char_u *)&(curbuf->b_p_wm);
  1587. }
  1589. /*
  1590.  * Copy options from one window to another.
  1591.  * Used when creating a new window.
  1592.  * The 'scroll' option is not copied, because it depends on the window height.
  1593.  */
  1594.     void
  1595. win_copy_options(wp_from, wp_to)
  1596.     WIN     *wp_from;
  1597.     WIN     *wp_to;
  1598. {
  1599.     wp_to->w_p_list = wp_from->w_p_list;
  1600.     wp_to->w_p_nu = wp_from->w_p_nu;
  1601. #ifdef RIGHTLEFT
  1602.     wp_to->w_p_rl = wp_from->w_p_rl;
  1603. # ifdef FKMAP
  1604.     wp_to->w_p_pers = wp_from->w_p_pers;
  1605. # endif
  1606. #endif
  1607.     wp_to->w_p_wrap = wp_from->w_p_wrap;
  1608.     wp_to->w_p_lbr = wp_from->w_p_lbr;
  1609. }
  1611. /*
  1612.  * Copy options from one buffer to another.
  1613.  * Used when creating a new buffer and sometimes when entering a buffer.
  1614.  * flags:
  1615.  * BCO_ENTER We will enter the bp_to buffer.
  1616.  * BCO_ALWAYS Always copy the options, but only set b_p_initialized when
  1617.  * appropriate.
  1618.  * BCO_NOHELP Don't copy the help settings.
  1619.  */
  1620.     void
  1621. buf_copy_options(bp_from, bp_to, flags)
  1622.     BUF     *bp_from;
  1623.     BUF     *bp_to;
  1624.     int     flags;
  1625. {
  1626.     int     should_copy = TRUE;
  1627.     char_u  *save_p_isk = NULL;     /* init for GCC */
  1629.     /*
  1630.      * Don't do anything of the "to" buffer is invalid.
  1631.      */
  1632.     if (bp_to == NULL || !buf_valid(bp_to))
  1633. return;
  1635.     /*
  1636.      * Only copy if the "from" buffer is valid and "to" and "from" are
  1637.      * different.
  1638.      */
  1639.     if (bp_from != NULL && buf_valid(bp_from) && bp_from != bp_to)
  1640.     {
  1641. /*
  1642.  * Always copy when entering and 'cpo' contains 'S'.
  1643.  * Don't copy when already initialized.
  1644.  * Don't copy when 'cpo' contains 's' and not entering.
  1645.  * 'S' BCO_ENTER  initialized 's'  should_copy
  1646.  * yes   yes        X  X TRUE
  1647.  * yes   no       yes  X FALSE
  1648.  * no    X       yes  X FALSE
  1649.  *  X   no       no yes FALSE
  1650.  *  X   no       no no TRUE
  1651.  * no   yes       no  X TRUE
  1652.  */
  1653. if ((vim_strchr(p_cpo, CPO_BUFOPTGLOB) == NULL || !(flags & BCO_ENTER))
  1654. && (bp_to->b_p_initialized
  1655.     || (!(flags & BCO_ENTER)
  1656. && vim_strchr(p_cpo, CPO_BUFOPT) != NULL)))
  1657.     should_copy = FALSE;
  1659. if (should_copy || (flags & BCO_ALWAYS))
  1660. {
  1661.     if ((flags & BCO_NOHELP)) /* don't free b_p_isk */
  1662.     {
  1663. save_p_isk = bp_to->b_p_isk;
  1664. bp_to->b_p_isk = NULL;
  1665.     }
  1666.     /*
  1667.      * Always free the allocated strings.
  1668.      * If not already initialized, set 'readonly' and copy 'fileformat'.
  1669.      */
  1670.     if (!bp_to->b_p_initialized)
  1671.     {
  1672. free_buf_options(bp_to, TRUE);
  1673. bp_to->b_p_ro = FALSE; /* don't copy readonly */
  1674. bp_to->b_p_tx = bp_from->b_p_tx;
  1675. bp_to->b_p_ff = vim_strsave(bp_from->b_p_ff);
  1676. #ifdef MULTI_BYTE
  1677. bp_to->b_p_fe = vim_strsave(bp_from->b_p_fe);
  1678. #endif
  1679.     }
  1680.     else
  1681. free_buf_options(bp_to, FALSE);
  1683.     bp_to->b_p_ai = bp_from->b_p_ai;
  1684.     bp_to->b_p_ai_save = bp_from->b_p_ai_save;
  1685.     bp_to->b_p_sw = bp_from->b_p_sw;
  1686.     bp_to->b_p_tw = bp_from->b_p_tw;
  1687.     bp_to->b_p_tw_save = bp_from->b_p_tw_save;
  1688.     bp_to->b_p_tw_nobin = bp_from->b_p_tw_nobin;
  1689.     bp_to->b_p_wm = bp_from->b_p_wm;
  1690.     bp_to->b_p_wm_save = bp_from->b_p_wm_save;
  1691.     bp_to->b_p_wm_nobin = bp_from->b_p_wm_nobin;
  1692.     bp_to->b_p_bin = bp_from->b_p_bin;
  1693.     bp_to->b_p_et = bp_from->b_p_et;
  1694.     bp_to->b_p_et_nobin = bp_from->b_p_et_nobin;
  1695.     bp_to->b_p_ml = bp_from->b_p_ml;
  1696.     bp_to->b_p_ml_nobin = bp_from->b_p_ml_nobin;
  1697.     bp_to->b_p_inf = bp_from->b_p_inf;
  1698.     bp_to->b_p_swf = bp_from->b_p_swf;
  1699. #ifdef INSERT_EXPAND
  1700.     bp_to->b_p_cpt = vim_strsave(bp_from->b_p_cpt);
  1701. #endif
  1702.     bp_to->b_p_sts = bp_from->b_p_sts;
  1703. #ifndef SHORT_FNAME
  1704.     bp_to->b_p_sn = bp_from->b_p_sn;
  1705. #endif
  1706.     bp_to->b_p_com = vim_strsave(bp_from->b_p_com);
  1707.     bp_to->b_p_fo = vim_strsave(bp_from->b_p_fo);
  1708.     bp_to->b_p_nf = vim_strsave(bp_from->b_p_nf);
  1709.     bp_to->b_p_mps = vim_strsave(bp_from->b_p_mps);
  1710. #ifdef SMARTINDENT
  1711.     bp_to->b_p_si = bp_from->b_p_si;
  1712.     bp_to->b_p_si_save = bp_from->b_p_si_save;
  1713. #endif
  1714. #ifdef CINDENT
  1715.     bp_to->b_p_cin = bp_from->b_p_cin;
  1716.     bp_to->b_p_cin_save = bp_from->b_p_cin_save;
  1717.     bp_to->b_p_cink = vim_strsave(bp_from->b_p_cink);
  1718.     bp_to->b_p_cino = vim_strsave(bp_from->b_p_cino);
  1719. #endif
  1720. #ifdef WANT_FILETYPE
  1721.     bp_to->b_p_ft = vim_strsave(bp_from->b_p_ft);
  1722. #endif
  1723. #if defined(SMARTINDENT) || defined(CINDENT)
  1724.     bp_to->b_p_cinw = vim_strsave(bp_from->b_p_cinw);
  1725. #endif
  1726. #ifdef LISPINDENT
  1727.     bp_to->b_p_lisp = bp_from->b_p_lisp;
  1728.     bp_to->b_p_lisp_save = bp_from->b_p_lisp_save;
  1729. #endif
  1730. #ifdef SYNTAX_HL
  1731.     bp_to->b_p_syn = vim_strsave(bp_from->b_p_syn);
  1732. #endif
  1734.     /*
  1735.      * Don't copy the options set by do_help(), use the saved values
  1736.      * Don't touch these at all when BCO_NOHELP is used.
  1737.      */
  1738.     if ((flags & BCO_NOHELP))
  1739. bp_to->b_p_isk = save_p_isk;
  1740.     else
  1741.     {
  1742. if (!keep_help_flag && bp_from->b_help && !bp_to->b_help
  1743.      && help_save_isk != NULL)
  1744. {
  1745.     bp_to->b_p_isk = vim_strsave(help_save_isk);
  1746.     if (bp_to->b_p_isk != NULL)
  1747. init_chartab();
  1748.     bp_to->b_p_ts = help_save_ts;
  1749.     bp_to->b_help = FALSE;
  1750. }
  1751. else
  1752. {
  1753.     bp_to->b_p_isk = vim_strsave(bp_from->b_p_isk);
  1754.     mch_memmove(bp_to->b_chartab, bp_from->b_chartab,
  1755.  (size_t)256);
  1756.     bp_to->b_p_ts = bp_from->b_p_ts;
  1757.     bp_to->b_help = bp_from->b_help;
  1758. }
  1759.     }
  1760. }
  1762. /*
  1763.  * When the options should be copied (ignoring BCO_ALWAYS), set the
  1764.  * flag that indicates that the options have been initialized.
  1765.  */
  1766. if (should_copy)
  1767.     bp_to->b_p_initialized = TRUE;
  1768.     }
  1770.     check_buf_options(bp_to);     /* make sure we don't have NULLs */
  1771. }
  1774. static int expand_option_idx = -1;
  1775. static char_u expand_option_name[5] = {'t', '_', NUL, NUL, NUL};
  1777.     void
  1778. set_context_in_set_cmd(arg)
  1779.     char_u *arg;
  1780. {
  1781.     int nextchar;
  1782.     int flags = 0; /* init for GCC */
  1783.     int opt_idx = 0; /* init for GCC */
  1784.     char_u *p;
  1785.     char_u *s;
  1786.     char_u *after_blank = NULL;
  1787.     int is_term_option = FALSE;
  1788.     int key;
  1790.     expand_context = EXPAND_SETTINGS;
  1791.     if (*arg == NUL)
  1792.     {
  1793. expand_pattern = arg;
  1794. return;
  1795.     }
  1796.     p = arg + STRLEN(arg) - 1;
  1797.     if (*p == ' ' && *(p - 1) != '\')
  1798.     {
  1799. expand_pattern = p + 1;
  1800. return;
  1801.     }
  1802.     while (p > arg)
  1803.     {
  1804. s = p;
  1805. /* count number of backslashes before ' ' or ',' */
  1806. if (*p == ' ' || *p == ',')
  1807. {
  1808.     while (s > arg && *(s - 1) == '\')
  1809. --s;
  1810. }
  1811. /* break at a space with an even number of backslashes */
  1812. if (*p == ' ' && ((p - s) & 1) == 0)
  1813. {
  1814.     ++p;
  1815.     break;
  1816. }
  1817. /* remember possible start of file name to expand */
  1818. if (after_blank == NULL
  1819. && ((*p == ' ' && (p - s) < 2)
  1820.     || (*p == ',' && p == s)))
  1821.     after_blank = p + 1;
  1822. --p;
  1823.     }
  1824.     if (STRNCMP(p, "no", 2) == 0)
  1825.     {
  1826. expand_context = EXPAND_BOOL_SETTINGS;
  1827. p += 2;
  1828.     }
  1829.     if (STRNCMP(p, "inv", 3) == 0)
  1830.     {
  1831. expand_context = EXPAND_BOOL_SETTINGS;
  1832. p += 3;
  1833.     }
  1834.     expand_pattern = arg = p;
  1835.     if (*arg == '<')
  1836.     {
  1837. while (*p != '>')
  1838.     if (*p++ == NUL)     /* expand terminal option name */
  1839. return;
  1840. key = get_special_key_code(arg + 1);
  1841. if (key == 0)     /* unknown name */
  1842. {
  1843.     expand_context = EXPAND_NOTHING;
  1844.     return;
  1845. }
  1846. nextchar = *++p;
  1847. is_term_option = TRUE;
  1848. expand_option_name[2] = KEY2TERMCAP0(key);
  1849. expand_option_name[3] = KEY2TERMCAP1(key);
  1850.     }
  1851.     else
  1852.     {
  1853. if (p[0] == 't' && p[1] == '_')
  1854. {
  1855.     p += 2;
  1856.     if (*p != NUL)
  1857. ++p;
  1858.     if (*p == NUL)
  1859. return; /* expand option name */
  1860.     nextchar = *++p;
  1861.     is_term_option = TRUE;
  1862.     expand_option_name[2] = p[-2];
  1863.     expand_option_name[3] = p[-1];
  1864. }
  1865. else
  1866. {
  1867.     while (isalnum(*p) || *p == '_' || *p == '*')   /* Allow * wildcard */
  1868. p++;
  1869.     if (*p == NUL)
  1870. return;
  1871.     nextchar = *p;
  1872.     *p = NUL;
  1873.     opt_idx = findoption(arg);
  1874.     *p = nextchar;
  1875.     if (opt_idx == -1 || options[opt_idx].var == NULL)
  1876.     {
  1877. expand_context = EXPAND_NOTHING;
  1878. return;
  1879.     }
  1880.     flags = options[opt_idx].flags;
  1881.     if (flags & P_BOOL)
  1882.     {
  1883. expand_context = EXPAND_NOTHING;
  1884. return;
  1885.     }
  1886. }
  1887.     }
  1888.     if ((nextchar != '=' && nextchar != ':')
  1889.     || expand_context == EXPAND_BOOL_SETTINGS)
  1890.     {
  1891. expand_context = EXPAND_UNSUCCESSFUL;
  1892. return;
  1893.     }
  1894.     if (expand_context != EXPAND_BOOL_SETTINGS && p[1] == NUL)
  1895.     {
  1896. expand_context = EXPAND_OLD_SETTING;
  1897. if (is_term_option)
  1898.     expand_option_idx = -1;
  1899. else
  1900.     expand_option_idx = opt_idx;
  1901. expand_pattern = p + 1;
  1902. return;
  1903.     }
  1904.     expand_context = EXPAND_NOTHING;
  1905.     if (is_term_option || (flags & P_NUM))
  1906. return;
  1907.     if (after_blank != NULL)
  1908. expand_pattern = after_blank;
  1909.     else
  1910. expand_pattern = p + 1;
  1911.     if (flags & P_EXPAND)
  1912.     {
  1913. p = options[opt_idx].var;
  1914. if (p == (char_u *)&p_bdir || p == (char_u *)&p_dir ||
  1915.        p == (char_u *)&p_path)
  1916. {
  1917.     expand_context = EXPAND_DIRECTORIES;
  1918.     if (p == (char_u *)&p_path)
  1919. expand_set_path = TRUE;
  1920. }
  1921. else
  1922.     expand_context = EXPAND_FILES;
  1923.     }
  1924.     return;
  1925. }
  1927.     int
  1928. ExpandSettings(prog, num_file, file)
  1929.     vim_regexp *prog;
  1930.     int *num_file;
  1931.     char_u ***file;
  1932. {
  1933.     int num_normal = 0;     /* Number of matching non-term-code settings */
  1934.     int num_term = 0;     /* Number of matching terminal code settings */
  1935.     int opt_idx;
  1936.     int match;
  1937.     int count = 0;
  1938.     char_u *str;
  1939.     int loop;
  1940.     int is_term_opt;
  1941.     char_u  name_buf[MAX_KEY_NAME_LEN];
  1942.     int save_reg_ic;
  1944.     /* do this loop twice:
  1945.      * loop == 0: count the number of matching options
  1946.      * loop == 1: copy the matching options into allocated memory
  1947.      */
  1948.     for (loop = 0; loop <= 1; ++loop)
  1949.     {
  1950. if (expand_context != EXPAND_BOOL_SETTINGS)
  1951. {
  1952.     if (vim_regexec(prog, (char_u *)"all", TRUE))
  1953.     {
  1954. if (loop == 0)
  1955.     num_normal++;
  1956. else
  1957.     (*file)[count++] = vim_strsave((char_u *)"all");
  1958.     }
  1959.     if (vim_regexec(prog, (char_u *)"termcap", TRUE))
  1960.     {
  1961. if (loop == 0)
  1962.     num_normal++;
  1963. else
  1964.     (*file)[count++] = vim_strsave((char_u *)"termcap");
  1965.     }
  1966. }
  1967. for (opt_idx = 0; (str = (char_u *)options[opt_idx].fullname) != NULL;
  1968.     opt_idx++)
  1969. {
  1970.     if (options[opt_idx].var == NULL)
  1971. continue;
  1972.     if (expand_context == EXPAND_BOOL_SETTINGS
  1973.       && !(options[opt_idx].flags & P_BOOL))
  1974. continue;
  1975.     is_term_opt = istermoption(&options[opt_idx]);
  1976.     if (is_term_opt && num_normal > 0)
  1977. continue;
  1978.     match = FALSE;
  1979.     if (vim_regexec(prog, str, TRUE) ||
  1980. (options[opt_idx].shortname != NULL &&
  1981.  vim_regexec(prog,
  1982.  (char_u *)options[opt_idx].shortname, TRUE)))
  1983. match = TRUE;
  1984.     else if (is_term_opt)
  1985.     {
  1986. name_buf[0] = '<';
  1987. name_buf[1] = 't';
  1988. name_buf[2] = '_';
  1989. name_buf[3] = str[2];
  1990. name_buf[4] = str[3];
  1991. name_buf[5] = '>';
  1992. name_buf[6] = NUL;
  1993. if (vim_regexec(prog, name_buf, TRUE))
  1994. {
  1995.     match = TRUE;
  1996.     str = name_buf;
  1997. }
  1998.     }
  1999.     if (match)
  2000.     {
  2001. if (loop == 0)
  2002. {
  2003.     if (is_term_opt)
  2004. num_term++;
  2005.     else
  2006. num_normal++;
  2007. }
  2008. else
  2009.     (*file)[count++] = vim_strsave(str);
  2010.     }
  2011. }
  2012. /*
  2013.  * Check terminal key codes, these are not in the option table
  2014.  */
  2015. if (expand_context != EXPAND_BOOL_SETTINGS  && num_normal == 0)
  2016. {
  2017.     for (opt_idx = 0; (str = get_termcode(opt_idx)) != NULL; opt_idx++)
  2018.     {
  2019. if (!isprint(str[0]) || !isprint(str[1]))
  2020.     continue;
  2022. name_buf[0] = 't';
  2023. name_buf[1] = '_';
  2024. name_buf[2] = str[0];
  2025. name_buf[3] = str[1];
  2026. name_buf[4] = NUL;
  2028. match = FALSE;
  2029. if (vim_regexec(prog, name_buf, TRUE))
  2030.     match = TRUE;
  2031. else
  2032. {
  2033.     name_buf[0] = '<';
  2034.     name_buf[1] = 't';
  2035.     name_buf[2] = '_';
  2036.     name_buf[3] = str[0];
  2037.     name_buf[4] = str[1];
  2038.     name_buf[5] = '>';
  2039.     name_buf[6] = NUL;
  2041.     if (vim_regexec(prog, name_buf, TRUE))
  2042. match = TRUE;
  2043. }
  2044. if (match)
  2045. {
  2046.     if (loop == 0)
  2047. num_term++;
  2048.     else
  2049. (*file)[count++] = vim_strsave(name_buf);
  2050. }
  2051.     }
  2052.     /*
  2053.      * Check special key names.
  2054.      */
  2055.     for (opt_idx = 0; (str = get_key_name(opt_idx)) != NULL; opt_idx++)
  2056.     {
  2057. name_buf[0] = '<';
  2058. STRCPY(name_buf + 1, str);
  2059. STRCAT(name_buf, ">");
  2061. save_reg_ic = reg_ic;
  2062. reg_ic = TRUE; /* ignore case here */
  2063. if (vim_regexec(prog, name_buf, TRUE))
  2064. {
  2065.     if (loop == 0)
  2066. num_term++;
  2067.     else
  2068. (*file)[count++] = vim_strsave(name_buf);
  2069. }
  2070. reg_ic = save_reg_ic;
  2071.     }
  2072. }
  2073. if (loop == 0)
  2074. {
  2075.     if (num_normal > 0)
  2076. *num_file = num_normal;
  2077.     else if (num_term > 0)
  2078. *num_file = num_term;
  2079.     else
  2080. return OK;
  2081.     *file = (char_u **) alloc((unsigned)(*num_file * sizeof(char_u *)));
  2082.     if (*file == NULL)
  2083.     {
  2084. *file = (char_u **)"";
  2085. return FAIL;
  2086.     }
  2087. }
  2088.     }
  2089.     return OK;
  2090. }
  2092.     int
  2093. ExpandOldSetting(num_file, file)
  2094.     int     *num_file;
  2095.     char_u  ***file;
  2096. {
  2097.     char_u  *var = NULL; /* init for GCC */
  2098.     char_u  *buf;
  2100.     *num_file = 0;
  2101.     *file = (char_u **)alloc((unsigned)sizeof(char_u *));
  2102.     if (*file == NULL)
  2103. return FAIL;
  2105.     /*
  2106.      * For a terminal key code expand_option_idx is < 0.
  2107.      */
  2108.     if (expand_option_idx < 0)
  2109.     {
  2110. var = find_termcode(expand_option_name + 2);
  2111. if (var == NULL)
  2112.     expand_option_idx = findoption(expand_option_name);
  2113.     }
  2115.     if (expand_option_idx >= 0)
  2116.     {
  2117. /* put string of option value in NameBuff */
  2118. option_value2string(&options[expand_option_idx]);
  2119. var = NameBuff;
  2120.     }
  2121.     else if (var == NULL)
  2122. var = (char_u *)"";
  2124.     /* A backslash is required before some characters */
  2125.     buf = vim_strsave_escaped(var, escape_chars);
  2127.     if (buf == NULL)
  2128.     {
  2129. vim_free(*file);
  2130. *file = NULL;
  2131. return FAIL;
  2132.     }
  2134.     *file[0] = buf;
  2135.     *num_file = 1;
  2136.     return OK;
  2137. }
  2139. /*
  2140.  * Get the value for the numeric or string option *opp in a nice format into
  2141.  * NameBuff[].  Must not be called with a hidden option!
  2142.  */
  2143.     static void
  2144. option_value2string(opp)
  2145.     struct vimoption *opp;
  2146. {
  2147.     char_u  *varp;
  2149.     varp = get_varp(opp);
  2150.     if (opp->flags & P_NUM)
  2151.     {
  2152. if ((long *)varp == &p_wc)
  2153. {
  2154.     if (IS_SPECIAL(p_wc) || find_special_key_in_table((int)p_wc) >= 0)
  2155. STRCPY(NameBuff, get_special_key_name((int)p_wc, 0));
  2156.     else
  2157. STRCPY(NameBuff, transchar((int)p_wc));
  2158. }
  2159. else
  2160.     sprintf((char *)NameBuff, "%ld", *(long *)varp);
  2161.     }
  2162.     else    /* P_STRING */
  2163.     {
  2164. varp = *(char_u **)(varp);
  2165. if (varp == NULL)     /* just in case */
  2166.     NameBuff[0] = NUL;
  2167. else if (opp->flags & P_EXPAND)
  2168.     home_replace(NULL, varp, NameBuff, MAXPATHL, FALSE);
  2169. else
  2170.     STRNCPY(NameBuff, varp, MAXPATHL);
  2171.     }
  2172. }
  2174. #ifdef HAVE_LANGMAP
  2175. /*
  2176.  * Any character has an equivalent character.  This is used for keyboards that
  2177.  * have a special language mode that sends characters above 128 (although
  2178.  * other characters can be translated too).
  2179.  */
  2181. /*
  2182.  * char_u langmap_mapchar[256];
  2183.  * Normally maps each of the 128 upper chars to an <128 ascii char; used to
  2184.  * "translate" native lang chars in normal mode or some cases of
  2185.  * insert mode without having to tediously switch lang mode back&forth.
  2186.  */
  2188.     static void
  2189. langmap_init()
  2190. {
  2191.     int i;
  2193.     for (i = 0; i < 256; i++) /* we init with a-one-to one map */
  2194. langmap_mapchar[i] = i;
  2195. }
  2197. /*
  2198.  * Called when langmap option is set; the language map can be
  2199.  * changed at any time!
  2200.  */
  2201.     static void
  2202. langmap_set()
  2203. {
  2204.     char_u  *p;
  2205.     char_u  *p2;
  2206.     int     from, to;
  2208.     langmap_init();     /* back to one-to-one map first */
  2210.     for (p = p_langmap; p[0]; )
  2211.     {
  2212. for (p2 = p; p2[0] && p2[0] != ',' && p2[0] != ';'; ++p2)
  2213.     if (p2[0] == '\' && p2[1])
  2214. ++p2;
  2215. if (p2[0] == ';')
  2216.     ++p2;     /* abcd;ABCD form, p2 points to A */
  2217. else
  2218.     p2 = NULL;     /* aAbBcCdD form, p2 is NULL */
  2219. while (p[0])
  2220. {
  2221.     if (p[0] == '\' && p[1])
  2222. ++p;
  2223.     from = p[0];
  2224.     if (p2 == NULL)
  2225.     {
  2226. if (p[1] == '\')
  2227.     ++p;
  2228. to = p[1];
  2229.     }
  2230.     else
  2231.     {
  2232. if (p2[0] == '\')
  2233.     ++p2;
  2234. to = p2[0];
  2235.     }
  2236.     if (to == NUL)
  2237.     {
  2238. EMSG2("'langmap': Matching character missing for %s",
  2239.      transchar(from));
  2240. return;
  2241.     }
  2242.     langmap_mapchar[from] = to;
  2244.     /* Advance to next pair */
  2245.     if (p2 == NULL)
  2246.     {
  2247. p += 2;
  2248. if (p[0] == ',')
  2249. {
  2250.     ++p;
  2251.     break;
  2252. }
  2253.     }
  2254.     else
  2255.     {
  2256. ++p;
  2257. ++p2;
  2258. if (*p == ';')
  2259. {
  2260.     p = p2;
  2261.     if (p[0])
  2262.     {
  2263. if (p[0] != ',')
  2264. {
  2265.     EMSG2("'langmap': Extra characters after semicolon: %s", p);
  2266.     return;
  2267. }
  2268. ++p;
  2269.     }
  2270.     break;
  2271. }
  2272.     }
  2273. }
  2274.     }
  2275. }
  2276. #endif
  2278. /*
  2279.  * Return TRUE if format option 'x' is in effect.
  2280.  * Take care of no formatting when 'paste' is set.
  2281.  */
  2282.     int
  2283. has_format_option(x)
  2284.     int     x;
  2285. {
  2286.     if (p_paste)
  2287. return FALSE;
  2288.     return (vim_strchr(curbuf->b_p_fo, x) != NULL);
  2289. }
  2291. /*
  2292.  * Return TRUE if "x" is present in 'shortmess' option, or
  2293.  * 'shortmess' contains 'a' and "x" is present in SHM_A.
  2294.  */
  2295.     int
  2296. shortmess(x)
  2297.     int     x;
  2298. {
  2299.     return (   vim_strchr(p_shm, x) != NULL
  2300.     || (vim_strchr(p_shm, 'a') != NULL
  2301. && vim_strchr((char_u *)SHM_A, x) != NULL));
  2302. }
  2304. /*
  2305.  * set_paste_option() - Called after p_paste was set or reset.
  2306.  */
  2307.     static void
  2308. paste_option_changed()
  2309. {
  2310.     static int     old_p_paste = FALSE;
  2311.     static int     save_sm = 0;
  2312.     static int     save_ru = 0;
  2313. #ifdef RIGHTLEFT
  2314.     static int     save_ri = 0;
  2315.     static int     save_hkmap = 0;
  2316. #endif
  2317.     BUF     *buf;
  2319.     if (p_paste)
  2320.     {
  2321. /*
  2322.  * Paste switched from off to on.
  2323.  * Save the current values, so they can be restored later.
  2324.  */
  2325. if (!old_p_paste)
  2326. {
  2327.     /* save options for each buffer */
  2328.     for (buf = firstbuf; buf != NULL; buf = buf->b_next)
  2329.     {
  2330. buf->b_p_tw_save = buf->b_p_tw;
  2331. buf->b_p_wm_save = buf->b_p_wm;
  2332. buf->b_p_sts_save = buf->b_p_sts;
  2333. buf->b_p_ai_save = buf->b_p_ai;
  2334. #ifdef SMARTINDENT
  2335. buf->b_p_si_save = buf->b_p_si;
  2336. #endif
  2337. #ifdef CINDENT
  2338. buf->b_p_cin_save = buf->b_p_cin;
  2339. #endif
  2340. #ifdef LISPINDENT
  2341. buf->b_p_lisp_save = buf->b_p_lisp;
  2342. #endif
  2343.     }
  2345.     /* save global options */
  2346.     save_sm = p_sm;
  2347.     save_ru = p_ru;
  2348. #ifdef RIGHTLEFT
  2349.     save_ri = p_ri;
  2350.     save_hkmap = p_hkmap;
  2351. #endif
  2352. }
  2354. /*
  2355.  * Always set the option values, also when 'paste' is set when it is
  2356.  * already on.
  2357.  */
  2358. /* set options for each buffer */
  2359. for (buf = firstbuf; buf != NULL; buf = buf->b_next)
  2360. {
  2361.     buf->b_p_tw = 0;     /* textwidth is 0 */
  2362.     buf->b_p_wm = 0;     /* wrapmargin is 0 */
  2363.     buf->b_p_sts = 0;     /* softtabstop is 0 */
  2364.     buf->b_p_ai = 0;     /* no auto-indent */
  2365. #ifdef SMARTINDENT
  2366.     buf->b_p_si = 0;     /* no smart-indent */
  2367. #endif
  2368. #ifdef CINDENT
  2369.     buf->b_p_cin = 0;     /* no c indenting */
  2370. #endif
  2371. #ifdef LISPINDENT
  2372.     buf->b_p_lisp = 0;     /* no lisp indenting */
  2373. #endif
  2374. }
  2376. /* set global options */
  2377. p_sm = 0;     /* no showmatch */
  2378. p_ru = 0;     /* no ruler */
  2379. #ifdef RIGHTLEFT
  2380. p_ri = 0;     /* no reverse insert */
  2381. p_hkmap = 0;     /* no Hebrew keyboard */
  2382. #endif
  2383.     }
  2385.     /*
  2386.      * Paste switched from on to off: Restore saved values.
  2387.      */
  2388.     else if (old_p_paste)
  2389.     {
  2390. /* restore options for each buffer */
  2391. for (buf = firstbuf; buf != NULL; buf = buf->b_next)
  2392. {
  2393.     buf->b_p_tw = buf->b_p_tw_save;
  2394.     buf->b_p_wm = buf->b_p_wm_save;
  2395.     buf->b_p_sts = buf->b_p_sts_save;
  2396.     buf->b_p_ai = buf->b_p_ai_save;
  2397. #ifdef SMARTINDENT
  2398.     buf->b_p_si = buf->b_p_si_save;
  2399. #endif
  2400. #ifdef CINDENT
  2401.     buf->b_p_cin = buf->b_p_cin_save;
  2402. #endif
  2403. #ifdef LISPINDENT
  2404.     buf->b_p_lisp = buf->b_p_lisp_save;
  2405. #endif
  2406. }
  2408. /* restore global options */
  2409. p_sm = save_sm;
  2410. p_ru = save_ru;
  2411. #ifdef RIGHTLEFT
  2412. p_ri = save_ri;
  2413. p_hkmap = save_hkmap;
  2414. #endif
  2415.     }
  2417.     old_p_paste = p_paste;
  2418. }
  2420. /*
  2421.  * vimrc_found() - Called when a ".vimrc" or "VIMINIT" has been found.
  2422.  *
  2423.  * Reset 'compatible' and set the values for options that didn't get set yet
  2424.  * to the Vim defaults.
  2425.  * Don't do this if the 'compatible' option has been set or reset before.
  2426.  */
  2427.     void
  2428. vimrc_found()
  2429. {
  2430.     int     opt_idx;
  2432.     if (!option_was_set((char_u *)"cp"))
  2433.     {
  2434. p_cp = FALSE;
  2435. for (opt_idx = 0; !istermoption(&options[opt_idx]); opt_idx++)
  2436.     if (!(options[opt_idx].flags & (P_WAS_SET|P_VI_DEF)))
  2437. set_option_default(opt_idx, TRUE);
  2438. init_chartab();     /* make b_p_isk take effect */
  2439.     }
  2440. }
  2442. /*
  2443.  * Set 'compatible' on or off.  Called for "-C" and "-N" command line arg.
  2444.  */
  2445.     void
  2446. change_compatible(on)
  2447.     int     on;
  2448. {
  2449.     if (p_cp != on)
  2450.     {
  2451. p_cp = on;
  2452. compatible_set();
  2453.     }
  2454.     options[findoption((char_u *)"cp")].flags |= P_WAS_SET;
  2455. }
  2457. /*
  2458.  * Return TRUE when option "name" has been set.
  2459.  */
  2460.     int
  2461. option_was_set(name)
  2462.     char_u *name;
  2463. {
  2464.     int idx;
  2466.     idx = findoption(name);
  2467.     if (idx < 0) /* unknown option */
  2468. return FALSE;
  2469.     if (options[idx].flags & P_WAS_SET)
  2470. return TRUE;
  2471.     return FALSE;
  2472. }
  2474. /*
  2475.  * compatible_set() - Called when 'compatible' has been set or unset.
  2476.  *
  2477.  * When 'compatible' set: Set all relevant options (those that have the P_VIM)
  2478.  * flag) to a Vi compatible value.
  2479.  * When 'compatible' is unset: Set all options that have a different default
  2480.  * for Vim (without the P_VI_DEF flag) to that default.
  2481.  */
  2482.     static void
  2483. compatible_set()
  2484. {
  2485.     int     opt_idx;
  2487.     for (opt_idx = 0; !istermoption(&options[opt_idx]); opt_idx++)
  2488. if (    ((options[opt_idx].flags & P_VIM) && p_cp)
  2489. || (!(options[opt_idx].flags & P_VI_DEF) && !p_cp))
  2490.     set_option_default(opt_idx, TRUE);
  2491.     init_chartab();     /* make b_p_isk take effect */
  2492. }
  2494. /*
  2495.  * fill_breakat_flags() -- called when 'breakat' changes value.
  2496.  */
  2497.     static void
  2498. fill_breakat_flags()
  2499. {
  2500.     char_u *c;
  2501.     int i;
  2503.     for (i = 0; i < 256; i++)
  2504. breakat_flags[i] = FALSE;
  2506.     if (p_breakat != NULL)
  2507. for (c = p_breakat; *c; c++)
  2508.     breakat_flags[*c] = TRUE;
  2509. }
  2511. /*
  2512.  * Check an option that can be a range of string values.
  2513.  *
  2514.  * Return OK for correct value, FAIL otherwise.
  2515.  */
  2516.     static int
  2517. check_opt_strings(val, values, list)
  2518.     char_u  *val;
  2519.     char    **values;
  2520.     int     list;     /* when TRUE: accept a list of values */
  2521. {
  2522.     int     i;
  2523.     int     len;
  2525.     while (*val)
  2526.     {
  2527. for (i = 0; ; ++i)
  2528. {
  2529.     if (values[i] == NULL) /* val not found in values[] */
  2530. return FAIL;
  2532.     len = STRLEN(values[i]);
  2533.     if (STRNCMP(values[i], val, len) == 0)
  2534.     {
  2535. if (list && val[len] == ',')
  2536. {
  2537.     val += len + 1;
  2538.     break; /* check next item in val list */
  2539. }
  2540. else if (val[len] == NUL)
  2541.     return OK;
  2542.     }
  2543. }
  2544.     }
  2545.     return OK;
  2546. }
  2548. /*
  2549.  * Read the 'wildmode' option, fill wim_flags[].
  2550.  */
  2551.     static int
  2552. check_opt_wim()
  2553. {
  2554.     char_u new_wim_flags[4];
  2555.     char_u *p;
  2556.     int i;
  2557.     int idx = 0;
  2559.     for (i = 0; i < 4; ++i)
  2560. new_wim_flags[i] = 0;
  2562.     for (p = p_wim; *p; ++p)
  2563.     {
  2564. for (i = 0; isalpha(p[i]); ++i)
  2565.     ;
  2566. if (p[i] != NUL && p[i] != ',' && p[i] != ':')
  2567.     return FAIL;
  2568. if (i == 7 && STRNCMP(p, "longest", 7) == 0)
  2569.     new_wim_flags[idx] |= WIM_LONGEST;
  2570. else if (i == 4 && STRNCMP(p, "full", 4) == 0)
  2571.     new_wim_flags[idx] |= WIM_FULL;
  2572. else if (i == 4 && STRNCMP(p, "list", 4) == 0)
  2573.     new_wim_flags[idx] |= WIM_LIST;
  2574. else
  2575.     return FAIL;
  2576. p += i;
  2577. if (*p == NUL)
  2578.     break;
  2579. if (*p == ',')
  2580. {
  2581.     if (idx == 3)
  2582. return FAIL;
  2583.     ++idx;
  2584. }
  2585.     }
  2587.     /* fill remaining entries with last flag */
  2588.     while (idx < 3)
  2589.     {
  2590. new_wim_flags[idx + 1] = new_wim_flags[idx];
  2591. ++idx;
  2592.     }
  2594.     /* only when there are no errors, wim_flags[] is changed */
  2595.     for (i = 0; i < 4; ++i)
  2596. wim_flags[i] = new_wim_flags[i];
  2597.     return OK;
  2598. }