1 /* vi:set ts=8 sts=4 sw=4:
3 * VIM - Vi IMproved by Bram Moolenaar
5 * Do ":help uganda" in Vim to read copying and usage conditions.
6 * Do ":help credits" in Vim to see a list of people who contributed.
7 * See README.txt for an overview of the Vim source code.
11 * misc2.c: Various functions.
15 static char_u
*username
= NULL
; /* cached result of mch_get_user_name() */
17 static char_u
*ff_expand_buffer
= NULL
; /* used for expanding filenames */
19 #if defined(FEAT_VIRTUALEDIT) || defined(PROTO)
20 static int coladvance2
__ARGS((pos_T
*pos
, int addspaces
, int finetune
, colnr_T wcol
));
23 * Return TRUE if in the current mode we need to use virtual.
28 /* While an operator is being executed we return "virtual_op", because
29 * VIsual_active has already been reset, thus we can't check for "block"
31 if (virtual_op
!= MAYBE
)
33 return (ve_flags
== VE_ALL
35 || ((ve_flags
& VE_BLOCK
) && VIsual_active
&& VIsual_mode
== Ctrl_V
)
37 || ((ve_flags
& VE_INSERT
) && (State
& INSERT
)));
41 * Get the screen position of the cursor.
48 getvvcol(curwin
, &curwin
->w_cursor
, &x
, NULL
, NULL
);
53 * Get the screen position of character col with a coladd in the cursor line.
56 getviscol2(col
, coladd
)
63 pos
.lnum
= curwin
->w_cursor
.lnum
;
66 getvvcol(curwin
, &pos
, &x
, NULL
, NULL
);
71 * Go to column "wcol", and add/insert white space as necessary to get the
72 * cursor in that column.
73 * The caller must have saved the cursor line for undo!
76 coladvance_force(wcol
)
79 int rc
= coladvance2(&curwin
->w_cursor
, TRUE
, FALSE
, wcol
);
82 curwin
->w_valid
&= ~VALID_VIRTCOL
;
85 /* Virtcol is valid */
86 curwin
->w_valid
|= VALID_VIRTCOL
;
87 curwin
->w_virtcol
= wcol
;
94 * Try to advance the Cursor to the specified screen column.
95 * If virtual editing: fine tune the cursor position.
96 * Note that all virtual positions off the end of a line should share
97 * a curwin->w_cursor.col value (n.b. this is equal to STRLEN(line)),
98 * beginning at coladd 0.
100 * return OK if desired column is reached, FAIL if not
106 int rc
= getvpos(&curwin
->w_cursor
, wcol
);
108 if (wcol
== MAXCOL
|| rc
== FAIL
)
109 curwin
->w_valid
&= ~VALID_VIRTCOL
;
110 else if (*ml_get_cursor() != TAB
)
112 /* Virtcol is valid when not on a TAB */
113 curwin
->w_valid
|= VALID_VIRTCOL
;
114 curwin
->w_virtcol
= wcol
;
120 * Return in "pos" the position of the cursor advanced to screen column "wcol".
121 * return OK if desired column is reached, FAIL if not
128 #ifdef FEAT_VIRTUALEDIT
129 return coladvance2(pos
, FALSE
, virtual_active(), wcol
);
133 coladvance2(pos
, addspaces
, finetune
, wcol
)
135 int addspaces
; /* change the text to achieve our goal? */
136 int finetune
; /* change char offset for the exact column */
137 colnr_T wcol
; /* column to move to */
146 #ifdef FEAT_LINEBREAK
150 one_more
= (State
& INSERT
)
151 || restart_edit
!= NUL
153 || (VIsual_active
&& *p_sel
!= 'o')
155 #ifdef FEAT_VIRTUALEDIT
156 || ((ve_flags
& VE_ONEMORE
) && wcol
< MAXCOL
)
159 line
= ml_get_buf(curbuf
, pos
->lnum
, FALSE
);
163 idx
= (int)STRLEN(line
) - 1 + one_more
;
166 #ifdef FEAT_VIRTUALEDIT
167 if ((addspaces
|| finetune
) && !VIsual_active
)
169 curwin
->w_curswant
= linetabsize(line
) + one_more
;
170 if (curwin
->w_curswant
> 0)
171 --curwin
->w_curswant
;
177 #ifdef FEAT_VIRTUALEDIT
178 int width
= W_WIDTH(curwin
) - win_col_off(curwin
);
182 # ifdef FEAT_VERTSPLIT
183 && curwin
->w_width
!= 0
185 && wcol
>= (colnr_T
)width
)
187 csize
= linetabsize(line
);
191 if (wcol
/ width
> (colnr_T
)csize
/ width
192 && ((State
& INSERT
) == 0 || (int)wcol
> csize
+ 1))
194 /* In case of line wrapping don't move the cursor beyond the
195 * right screen edge. In Insert mode allow going just beyond
196 * the last character (like what happens when typing and
197 * reaching the right window edge). */
198 wcol
= (csize
/ width
+ 1) * width
- 1;
205 while (col
<= wcol
&& *ptr
!= NUL
)
207 /* Count a tab for what it's worth (if list mode not on) */
208 #ifdef FEAT_LINEBREAK
209 csize
= win_lbr_chartabsize(curwin
, ptr
, col
, &head
);
212 csize
= lbr_chartabsize_adv(&ptr
, col
);
216 idx
= (int)(ptr
- line
);
218 * Handle all the special cases. The virtual_active() check
219 * is needed to ensure that a virtual position off the end of
220 * a line has the correct indexing. The one_more comparison
221 * replaces an explicit add of one_more later on.
223 if (col
> wcol
|| (!virtual_active() && one_more
== 0))
226 # ifdef FEAT_LINEBREAK
227 /* Don't count the chars from 'showbreak'. */
233 #ifdef FEAT_VIRTUALEDIT
236 && ((col
!= wcol
&& col
!= wcol
+ 1) || csize
> 1))
238 /* 'virtualedit' is set: The difference between wcol and col is
239 * filled with spaces. */
241 if (line
[idx
] == NUL
)
244 int correct
= wcol
- col
;
245 char_u
*newline
= alloc(idx
+ correct
+ 1);
251 for (t
= 0; t
< idx
; ++t
)
252 newline
[t
] = line
[t
];
254 for (t
= 0; t
< correct
; ++t
)
255 newline
[t
+ idx
] = ' ';
257 newline
[idx
+ correct
] = NUL
;
259 ml_replace(pos
->lnum
, newline
, FALSE
);
260 changed_bytes(pos
->lnum
, (colnr_T
)idx
);
267 int linelen
= (int)STRLEN(line
);
268 int correct
= wcol
- col
- csize
+ 1; /* negative!! */
273 if (-correct
> csize
)
276 newline
= alloc(linelen
+ csize
);
280 for (t
= 0; t
< linelen
; t
++)
283 newline
[s
++] = line
[t
];
285 for (v
= 0; v
< csize
; v
++)
289 newline
[linelen
+ csize
- 1] = NUL
;
291 ml_replace(pos
->lnum
, newline
, FALSE
);
292 changed_bytes(pos
->lnum
, idx
);
293 idx
+= (csize
- 1 + correct
);
305 #ifdef FEAT_VIRTUALEDIT
312 /* The width of the last character is used to set coladd. */
317 getvcol(curwin
, pos
, &scol
, NULL
, &ecol
);
318 pos
->coladd
= ecol
- scol
;
323 int b
= (int)wcol
- (int)col
;
325 /* The difference between wcol and col is used to set coladd. */
326 if (b
> 0 && b
< (MAXCOL
- 2 * W_WIDTH(curwin
)))
335 /* prevent from moving onto a trail byte */
346 * Increment the cursor position. See inc() for return values.
351 return inc(&curwin
->w_cursor
);
355 * Increment the line pointer "lp" crossing line boundaries as necessary.
356 * Return 1 when going to the next line.
357 * Return 2 when moving forward onto a NUL at the end of the line).
358 * Return -1 when at the end of file.
359 * Return 0 otherwise.
365 char_u
*p
= ml_get_pos(lp
);
367 if (*p
!= NUL
) /* still within line, move to next char (may be NUL) */
372 int l
= (*mb_ptr2len
)(p
);
375 return ((p
[l
] != NUL
) ? 0 : 2);
379 #ifdef FEAT_VIRTUALEDIT
382 return ((p
[1] != NUL
) ? 0 : 2);
384 if (lp
->lnum
!= curbuf
->b_ml
.ml_line_count
) /* there is a next line */
388 #ifdef FEAT_VIRTUALEDIT
397 * incl(lp): same as inc(), but skip the NUL at the end of non-empty lines
405 if ((r
= inc(lp
)) >= 1 && lp
->col
)
413 * Decrement the line pointer 'p' crossing line boundaries as necessary.
414 * Return 1 when crossing a line, -1 when at start of file, 0 otherwise.
419 return dec(&curwin
->w_cursor
);
428 #ifdef FEAT_VIRTUALEDIT
431 if (lp
->col
> 0) /* still within line */
437 p
= ml_get(lp
->lnum
);
438 lp
->col
-= (*mb_head_off
)(p
, p
+ lp
->col
);
443 if (lp
->lnum
> 1) /* there is a prior line */
446 p
= ml_get(lp
->lnum
);
447 lp
->col
= (colnr_T
)STRLEN(p
);
450 lp
->col
-= (*mb_head_off
)(p
, p
+ lp
->col
);
454 return -1; /* at start of file */
458 * decl(lp): same as dec(), but skip the NUL at the end of non-empty lines
466 if ((r
= dec(lp
)) == 1 && lp
->col
)
472 * Make sure curwin->w_cursor.lnum is valid.
477 if (curwin
->w_cursor
.lnum
> curbuf
->b_ml
.ml_line_count
)
480 /* If there is a closed fold at the end of the file, put the cursor in
481 * its first line. Otherwise in the last line. */
482 if (!hasFolding(curbuf
->b_ml
.ml_line_count
,
483 &curwin
->w_cursor
.lnum
, NULL
))
485 curwin
->w_cursor
.lnum
= curbuf
->b_ml
.ml_line_count
;
487 if (curwin
->w_cursor
.lnum
<= 0)
488 curwin
->w_cursor
.lnum
= 1;
492 * Make sure curwin->w_cursor.col is valid.
498 #ifdef FEAT_VIRTUALEDIT
499 colnr_T oldcol
= curwin
->w_cursor
.col
;
500 colnr_T oldcoladd
= curwin
->w_cursor
.col
+ curwin
->w_cursor
.coladd
;
503 len
= (colnr_T
)STRLEN(ml_get_curline());
505 curwin
->w_cursor
.col
= 0;
506 else if (curwin
->w_cursor
.col
>= len
)
508 /* Allow cursor past end-of-line when:
509 * - in Insert mode or restarting Insert mode
510 * - in Visual mode and 'selection' isn't "old"
511 * - 'virtualedit' is set */
512 if ((State
& INSERT
) || restart_edit
514 || (VIsual_active
&& *p_sel
!= 'o')
516 #ifdef FEAT_VIRTUALEDIT
517 || (ve_flags
& VE_ONEMORE
)
520 curwin
->w_cursor
.col
= len
;
523 curwin
->w_cursor
.col
= len
- 1;
525 /* prevent cursor from moving on the trail byte */
531 else if (curwin
->w_cursor
.col
< 0)
532 curwin
->w_cursor
.col
= 0;
534 #ifdef FEAT_VIRTUALEDIT
535 /* If virtual editing is on, we can leave the cursor on the old position,
536 * only we must set it to virtual. But don't do it when at the end of the
538 if (oldcol
== MAXCOL
)
539 curwin
->w_cursor
.coladd
= 0;
540 else if (ve_flags
== VE_ALL
)
542 if (oldcoladd
> curwin
->w_cursor
.col
)
543 curwin
->w_cursor
.coladd
= oldcoladd
- curwin
->w_cursor
.col
;
545 /* avoid weird number when there is a miscalculation or overflow */
546 curwin
->w_cursor
.coladd
= 0;
552 * make sure curwin->w_cursor in on a valid character
561 #if defined(FEAT_TEXTOBJ) || defined(PROTO)
563 * Make sure curwin->w_cursor is not on the NUL at the end of the line.
564 * Allow it when in Visual mode and 'selection' is not "old".
569 if (curwin
->w_cursor
.col
> 0
571 && (!VIsual_active
|| *p_sel
== 'o')
573 && gchar_cursor() == NUL
)
574 --curwin
->w_cursor
.col
;
579 * When curwin->w_leftcol has changed, adjust the cursor position.
580 * Return TRUE if the cursor was moved.
589 changed_cline_bef_curs();
590 lastcol
= curwin
->w_leftcol
+ W_WIDTH(curwin
) - curwin_col_off() - 1;
594 * If the cursor is right or left of the screen, move it to last or first
597 if (curwin
->w_virtcol
> (colnr_T
)(lastcol
- p_siso
))
600 coladvance((colnr_T
)(lastcol
- p_siso
));
602 else if (curwin
->w_virtcol
< curwin
->w_leftcol
+ p_siso
)
605 (void)coladvance((colnr_T
)(curwin
->w_leftcol
+ p_siso
));
609 * If the start of the character under the cursor is not on the screen,
610 * advance the cursor one more char. If this fails (last char of the
611 * line) adjust the scrolling.
613 getvvcol(curwin
, &curwin
->w_cursor
, &s
, NULL
, &e
);
614 if (e
> (colnr_T
)lastcol
)
619 else if (s
< curwin
->w_leftcol
)
622 if (coladvance(e
+ 1) == FAIL
) /* there isn't another character */
624 curwin
->w_leftcol
= s
; /* adjust w_leftcol instead */
625 changed_cline_bef_curs();
630 curwin
->w_set_curswant
= TRUE
;
631 redraw_later(NOT_VALID
);
635 /**********************************************************************
636 * Various routines dealing with allocation and deallocation of memory.
639 #if defined(MEM_PROFILE) || defined(PROTO)
641 # define MEM_SIZES 8200
642 static long_u mem_allocs
[MEM_SIZES
];
643 static long_u mem_frees
[MEM_SIZES
];
644 static long_u mem_allocated
;
645 static long_u mem_freed
;
646 static long_u mem_peak
;
647 static long_u num_alloc
;
648 static long_u num_freed
;
650 static void mem_pre_alloc_s
__ARGS((size_t *sizep
));
651 static void mem_pre_alloc_l
__ARGS((long_u
*sizep
));
652 static void mem_post_alloc
__ARGS((void **pp
, size_t size
));
653 static void mem_pre_free
__ARGS((void **pp
));
656 mem_pre_alloc_s(sizep
)
659 *sizep
+= sizeof(size_t);
663 mem_pre_alloc_l(sizep
)
666 *sizep
+= sizeof(size_t);
670 mem_post_alloc(pp
, size
)
676 size
-= sizeof(size_t);
677 *(long_u
*)*pp
= size
;
678 if (size
<= MEM_SIZES
-1)
679 mem_allocs
[size
-1]++;
681 mem_allocs
[MEM_SIZES
-1]++;
682 mem_allocated
+= size
;
683 if (mem_allocated
- mem_freed
> mem_peak
)
684 mem_peak
= mem_allocated
- mem_freed
;
686 *pp
= (void *)((char *)*pp
+ sizeof(size_t));
695 *pp
= (void *)((char *)*pp
- sizeof(size_t));
696 size
= *(size_t *)*pp
;
697 if (size
<= MEM_SIZES
-1)
700 mem_frees
[MEM_SIZES
-1]++;
706 * called on exit via atexit()
709 vim_mem_profile_dump()
715 for (i
= 0; i
< MEM_SIZES
- 1; i
++)
717 if (mem_allocs
[i
] || mem_frees
[i
])
719 if (mem_frees
[i
] > mem_allocs
[i
])
720 printf("\r\n%s", _("ERROR: "));
721 printf("[%4d / %4lu-%-4lu] ", i
+ 1, mem_allocs
[i
], mem_frees
[i
]);
735 if (mem_frees
[i
] > mem_allocs
[i
])
736 printf(_("ERROR: "));
737 printf("[>%d / %4lu-%-4lu]", i
, mem_allocs
[i
], mem_frees
[i
]);
740 printf(_("\n[bytes] total alloc-freed %lu-%lu, in use %lu, peak use %lu\n"),
741 mem_allocated
, mem_freed
, mem_allocated
- mem_freed
, mem_peak
);
742 printf(_("[calls] total re/malloc()'s %lu, total free()'s %lu\n\n"),
743 num_alloc
, num_freed
);
746 #endif /* MEM_PROFILE */
749 * Some memory is reserved for error messages and for being able to
750 * call mf_release_all(), which needs some memory for mf_trans_add().
752 #if defined(MSDOS) && !defined(DJGPP)
754 # define KEEP_ROOM 8192L
756 # define KEEP_ROOM (2 * 8192L)
760 * Note: if unsigned is 16 bits we can only allocate up to 64K with alloc().
761 * Use lalloc for larger blocks.
767 return (lalloc((long_u
)size
, TRUE
));
771 * Allocate memory and set all bytes to zero.
779 p
= (lalloc((long_u
)size
, TRUE
));
781 (void)vim_memset(p
, 0, (size_t)size
);
786 * alloc() with check for maximum line length
792 #if !defined(UNIX) && !defined(__EMX__)
793 if (sizeof(int) == 2 && size
> 0x7fff)
795 /* Don't hide this message */
797 EMSG(_("E340: Line is becoming too long"));
801 return (lalloc((long_u
)size
, TRUE
));
805 * Allocate memory like lalloc() and set all bytes to zero.
808 lalloc_clear(size
, message
)
814 p
= (lalloc(size
, message
));
816 (void)vim_memset(p
, 0, (size_t)size
);
821 * Low level memory allocation function.
822 * This is used often, KEEP IT FAST!
825 lalloc(size
, message
)
829 char_u
*p
; /* pointer to new storage space */
830 static int releasing
= FALSE
; /* don't do mf_release_all() recursive */
832 #if defined(HAVE_AVAIL_MEM) && !defined(SMALL_MEM)
833 static long_u allocated
= 0; /* allocated since last avail check */
836 /* Safety check for allocating zero bytes */
839 /* Don't hide this message */
841 EMSGN(_("E341: Internal error: lalloc(%ld, )"), size
);
846 mem_pre_alloc_l(&size
);
849 #if defined(MSDOS) && !defined(DJGPP)
850 if (size
>= 0xfff0) /* in MSDOS we can't deal with >64K blocks */
856 * Loop when out of memory: Try to release some memfile blocks and
857 * if some blocks are released call malloc again.
862 * Handle three kind of systems:
863 * 1. No check for available memory: Just return.
864 * 2. Slow check for available memory: call mch_avail_mem() after
865 * allocating KEEP_ROOM amount of memory.
866 * 3. Strict check for available memory: call mch_avail_mem()
868 if ((p
= (char_u
*)malloc((size_t)size
)) != NULL
)
870 #ifndef HAVE_AVAIL_MEM
871 /* 1. No check for available memory: Just return. */
875 /* 2. Slow check for available memory: call mch_avail_mem() after
876 * allocating (KEEP_ROOM / 2) amount of memory. */
878 if (allocated
< KEEP_ROOM
/ 2)
882 /* 3. check for available memory: call mch_avail_mem() */
883 if (mch_avail_mem(TRUE
) < KEEP_ROOM
&& !releasing
)
885 free((char *)p
); /* System is low... no go! */
893 * Remember that mf_release_all() is being called to avoid an endless
894 * loop, because mf_release_all() may call alloc() recursively.
900 clear_sb_text(); /* free any scrollback text */
901 try_again
= mf_release_all(); /* release as many blocks as possible */
903 try_again
|= garbage_collect(); /* cleanup recursive lists/dicts */
911 if (message
&& p
== NULL
)
912 do_outofmem_msg(size
);
916 mem_post_alloc((void **)&p
, (size_t)size
);
921 #if defined(MEM_PROFILE) || defined(PROTO)
923 * realloc() with memory profiling.
926 mem_realloc(ptr
, size
)
933 mem_pre_alloc_s(&size
);
935 p
= realloc(ptr
, size
);
937 mem_post_alloc(&p
, size
);
944 * Avoid repeating the error message many times (they take 1 second each).
945 * Did_outofmem_msg is reset when a character is read.
948 do_outofmem_msg(size
)
951 if (!did_outofmem_msg
)
953 /* Don't hide this message */
955 EMSGN(_("E342: Out of memory! (allocating %lu bytes)"), size
);
956 did_outofmem_msg
= TRUE
;
960 #if defined(EXITFREE) || defined(PROTO)
962 # if defined(FEAT_SEARCHPATH)
963 static void free_findfile
__ARGS((void));
967 * Free everything that we allocated.
968 * Can be used to detect memory leaks, e.g., with ccmalloc.
969 * NOTE: This is tricky! Things are freed that functions depend on. Don't be
970 * surprised if Vim crashes...
971 * Some things can't be freed, esp. things local to a library function.
976 buf_T
*buf
, *nextbuf
;
977 static int entered
= FALSE
;
979 /* When we cause a crash here it is caught and Vim tries to exit cleanly.
980 * Don't try freeing everything again. */
986 block_autocmds(); /* don't want to trigger autocommands here */
990 /* close all tabs and windows */
991 if (first_tabpage
->tp_next
!= NULL
)
992 do_cmdline_cmd((char_u
*)"tabonly!");
993 if (firstwin
!= lastwin
)
994 do_cmdline_cmd((char_u
*)"only!");
997 # if defined(FEAT_SPELL)
998 /* Free all spell info. */
1002 # if defined(FEAT_USR_CMDS)
1003 /* Clear user commands (before deleting buffers). */
1009 do_cmdline_cmd((char_u
*)"aunmenu *");
1010 # ifdef FEAT_MULTI_LANG
1011 do_cmdline_cmd((char_u
*)"menutranslate clear");
1015 /* Clear mappings, abbreviations, breakpoints. */
1016 do_cmdline_cmd((char_u
*)"lmapclear");
1017 do_cmdline_cmd((char_u
*)"xmapclear");
1018 do_cmdline_cmd((char_u
*)"mapclear");
1019 do_cmdline_cmd((char_u
*)"mapclear!");
1020 do_cmdline_cmd((char_u
*)"abclear");
1021 # if defined(FEAT_EVAL)
1022 do_cmdline_cmd((char_u
*)"breakdel *");
1024 # if defined(FEAT_PROFILE)
1025 do_cmdline_cmd((char_u
*)"profdel *");
1027 # if defined(FEAT_KEYMAP)
1028 do_cmdline_cmd((char_u
*)"set keymap=");
1034 # if defined(FEAT_SEARCHPATH)
1038 /* Obviously named calls. */
1039 # if defined(FEAT_AUTOCMD)
1040 free_all_autocmds();
1045 alist_clear(&global_alist
);
1047 free_search_patterns();
1050 free_prev_shellcmd();
1051 free_regexp_stuff();
1058 set_expr_line(NULL
);
1063 clear_sb_text(); /* free any scrollback text */
1065 /* Free some global vars. */
1067 # ifdef FEAT_CLIPBOARD
1068 vim_free(clip_exclude_prog
);
1070 vim_free(last_cmdline
);
1071 # ifdef FEAT_CMDHIST
1072 vim_free(new_last_cmdline
);
1074 set_keep_msg(NULL
, 0);
1075 vim_free(ff_expand_buffer
);
1077 /* Clear cmdline history. */
1079 # ifdef FEAT_CMDHIST
1083 #ifdef FEAT_QUICKFIX
1089 /* Free all location lists */
1090 FOR_ALL_TAB_WINDOWS(tab
, win
)
1095 /* Close all script inputs. */
1096 close_all_scripts();
1098 #if defined(FEAT_WINDOWS)
1099 /* Destroy all windows. Must come before freeing buffers. */
1103 /* Free all buffers. Reset 'autochdir' to avoid accessing things that
1104 * were freed already. */
1105 #ifdef FEAT_AUTOCHDIR
1108 for (buf
= firstbuf
; buf
!= NULL
; )
1110 nextbuf
= buf
->b_next
;
1111 close_buffer(NULL
, buf
, DOBUF_WIPE
);
1113 buf
= nextbuf
; /* didn't work, try next one */
1122 /* Clear registers. */
1127 #if defined(FEAT_CLIENTSERVER) && defined(FEAT_X11)
1128 vim_free(serverDelayedStartName
);
1131 /* highlight info */
1134 reset_last_sourcing();
1137 free_tabpage(first_tabpage
);
1138 first_tabpage
= NULL
;
1142 /* Machine-specific free. */
1146 /* message history */
1148 if (delete_first_msg() == FAIL
)
1157 /* screenlines (can't display anything now!) */
1160 #if defined(USE_XSMP)
1174 * copy a string into newly allocated memory
1183 len
= (unsigned)STRLEN(string
) + 1;
1186 mch_memmove(p
, string
, (size_t)len
);
1191 vim_strnsave(string
, len
)
1197 p
= alloc((unsigned)(len
+ 1));
1200 STRNCPY(p
, string
, len
);
1207 * Same as vim_strsave(), but any characters found in esc_chars are preceded
1211 vim_strsave_escaped(string
, esc_chars
)
1215 return vim_strsave_escaped_ext(string
, esc_chars
, '\\', FALSE
);
1219 * Same as vim_strsave_escaped(), but when "bsl" is TRUE also escape
1220 * characters where rem_backslash() would remove the backslash.
1221 * Escape the characters with "cc".
1224 vim_strsave_escaped_ext(string
, esc_chars
, cc
, bsl
)
1232 char_u
*escaped_string
;
1239 * First count the number of backslashes required.
1240 * Then allocate the memory and insert them.
1242 length
= 1; /* count the trailing NUL */
1243 for (p
= string
; *p
; p
++)
1246 if (has_mbyte
&& (l
= (*mb_ptr2len
)(p
)) > 1)
1248 length
+= l
; /* count a multibyte char */
1253 if (vim_strchr(esc_chars
, *p
) != NULL
|| (bsl
&& rem_backslash(p
)))
1254 ++length
; /* count a backslash */
1255 ++length
; /* count an ordinary char */
1257 escaped_string
= alloc(length
);
1258 if (escaped_string
!= NULL
)
1260 p2
= escaped_string
;
1261 for (p
= string
; *p
; p
++)
1264 if (has_mbyte
&& (l
= (*mb_ptr2len
)(p
)) > 1)
1266 mch_memmove(p2
, p
, (size_t)l
);
1268 p
+= l
- 1; /* skip multibyte char */
1272 if (vim_strchr(esc_chars
, *p
) != NULL
|| (bsl
&& rem_backslash(p
)))
1278 return escaped_string
;
1282 * Return TRUE when 'shell' has "csh" in the tail.
1287 return (strstr((char *)gettail(p_sh
), "csh") != NULL
);
1291 * Escape "string" for use as a shell argument with system().
1292 * This uses single quotes, except when we know we need to use double quotes
1293 * (MS-DOS and MS-Windows without 'shellslash' set).
1294 * Escape a newline, depending on the 'shell' option.
1295 * When "do_special" is TRUE also replace "!", "%", "#" and things starting
1296 * with "<" like "<cfile>".
1297 * Returns the result in allocated memory, NULL if we have run out.
1300 vim_strsave_shellescape(string
, do_special
)
1307 char_u
*escaped_string
;
1311 /* Only csh and similar shells expand '!' within single quotes. For sh and
1312 * the like we must not put a backslash before it, it will be taken
1313 * literally. If do_special is set the '!' will be escaped twice.
1314 * Csh also needs to have "\n" escaped twice when do_special is set. */
1315 csh_like
= csh_like_shell();
1317 /* First count the number of extra bytes required. */
1318 length
= (unsigned)STRLEN(string
) + 3; /* two quotes and a trailing NUL */
1319 for (p
= string
; *p
!= NUL
; mb_ptr_adv(p
))
1321 # if defined(WIN32) || defined(WIN16) || defined(DOS)
1325 ++length
; /* " -> "" */
1330 length
+= 3; /* ' => '\'' */
1331 if (*p
== '\n' || (*p
== '!' && (csh_like
|| do_special
)))
1333 ++length
; /* insert backslash */
1334 if (csh_like
&& do_special
)
1335 ++length
; /* insert backslash */
1337 if (do_special
&& find_cmdline_var(p
, &l
) >= 0)
1339 ++length
; /* insert backslash */
1344 /* Allocate memory for the result and fill it. */
1345 escaped_string
= alloc(length
);
1346 if (escaped_string
!= NULL
)
1350 /* add opening quote */
1351 # if defined(WIN32) || defined(WIN16) || defined(DOS)
1358 for (p
= string
; *p
!= NUL
; )
1360 # if defined(WIN32) || defined(WIN16) || defined(DOS)
1382 if (*p
== '\n' || (*p
== '!' && (csh_like
|| do_special
)))
1385 if (csh_like
&& do_special
)
1390 if (do_special
&& find_cmdline_var(p
, &l
) >= 0)
1392 *d
++ = '\\'; /* insert backslash */
1393 while (--l
>= 0) /* copy the var */
1401 /* add terminating quote and finish with a NUL */
1402 # if defined(WIN32) || defined(WIN16) || defined(DOS)
1411 return escaped_string
;
1415 * Like vim_strsave(), but make all characters uppercase.
1416 * This uses ASCII lower-to-upper case translation, language independent.
1419 vim_strsave_up(string
)
1424 p1
= vim_strsave(string
);
1430 * Like vim_strnsave(), but make all characters uppercase.
1431 * This uses ASCII lower-to-upper case translation, language independent.
1434 vim_strnsave_up(string
, len
)
1440 p1
= vim_strnsave(string
, len
);
1446 * ASCII lower-to-upper case translation, language independent.
1458 while ((c
= *p2
) != NUL
)
1460 *p2
++ = isalpha(c
) ? toupper(c
) : c
;
1462 *p2
++ = (c
< 'a' || c
> 'z') ? c
: (c
- 0x20);
1467 #if defined(FEAT_EVAL) || defined(FEAT_SPELL) || defined(PROTO)
1469 * Make string "s" all upper-case and return it in allocated memory.
1470 * Handles multi-byte characters as well as possible.
1471 * Returns NULL when out of memory.
1480 res
= p
= vim_strsave(orig
);
1494 c
= utf_ptr2char(p
);
1495 uc
= utf_toupper(c
);
1497 /* Reallocate string when byte count changes. This is rare,
1498 * thus it's OK to do another malloc()/free(). */
1500 nl
= utf_char2len(uc
);
1503 s
= alloc((unsigned)STRLEN(res
) + 1 + nl
- l
);
1506 mch_memmove(s
, res
, p
- res
);
1507 STRCPY(s
+ (p
- res
) + nl
, p
+ l
);
1513 utf_char2bytes(uc
, p
);
1516 else if (has_mbyte
&& (l
= (*mb_ptr2len
)(p
)) > 1)
1517 p
+= l
; /* skip multi-byte character */
1521 *p
= TOUPPER_LOC(*p
); /* note that toupper() can be a macro */
1531 * copy a space a number of times
1534 copy_spaces(ptr
, count
)
1545 #if defined(FEAT_VISUALEXTRA) || defined(PROTO)
1547 * Copy a character a number of times.
1548 * Does not work for multi-byte characters!
1551 copy_chars(ptr
, count
, c
)
1565 * delete spaces at the end of a string
1568 del_trailing_spaces(ptr
)
1573 q
= ptr
+ STRLEN(ptr
);
1574 while (--q
> ptr
&& vim_iswhite(q
[0]) && q
[-1] != '\\' && q
[-1] != Ctrl_V
)
1579 * Like strncpy(), but always terminate the result with one NUL.
1580 * "to" must be "len + 1" long!
1583 vim_strncpy(to
, from
, len
)
1588 STRNCPY(to
, from
, len
);
1593 * Isolate one part of a string option where parts are separated with
1595 * The part is copied into "buf[maxlen]".
1596 * "*option" is advanced to the next part.
1597 * The length is returned.
1600 copy_option_part(option
, buf
, maxlen
, sep_chars
)
1607 char_u
*p
= *option
;
1609 /* skip '.' at start of option part, for 'suffixes' */
1612 while (*p
!= NUL
&& vim_strchr((char_u
*)sep_chars
, *p
) == NULL
)
1615 * Skip backslash before a separator character and space.
1617 if (p
[0] == '\\' && vim_strchr((char_u
*)sep_chars
, p
[1]) != NULL
)
1619 if (len
< maxlen
- 1)
1625 if (*p
!= NUL
&& *p
!= ',') /* skip non-standard separator */
1627 p
= skip_to_option_part(p
); /* p points to next file name */
1634 * Replacement for free() that ignores NULL pointers.
1635 * Also skip free() when exiting for sure, this helps when we caught a deadly
1636 * signal that was caused by a crash in free().
1642 if (x
!= NULL
&& !really_exiting
)
1653 vim_memset(ptr
, c
, size
)
1668 * Return zero when "b1" and "b2" are the same for "len" bytes.
1669 * Return non-zero otherwise.
1672 vim_memcmp(b1
, b2
, len
)
1677 char_u
*p1
= (char_u
*)b1
, *p2
= (char_u
*)b2
;
1679 for ( ; len
> 0; --len
)
1692 * Version of memmove() that handles overlapping source and destination.
1693 * For systems that don't have a function that is guaranteed to do that (SYSV).
1696 mch_memmove(dst_arg
, src_arg
, len
)
1697 void *src_arg
, *dst_arg
;
1701 * A void doesn't have a size, we use char pointers.
1703 char *dst
= dst_arg
, *src
= src_arg
;
1705 /* overlap, copy backwards */
1706 if (dst
> src
&& dst
< src
+ len
)
1713 else /* copy forwards */
1719 #if (!defined(HAVE_STRCASECMP) && !defined(HAVE_STRICMP)) || defined(PROTO)
1721 * Compare two strings, ignoring case, using current locale.
1722 * Doesn't work for multi-byte characters.
1723 * return 0 for match, < 0 for smaller, > 0 for bigger
1734 i
= (int)TOLOWER_LOC(*s1
) - (int)TOLOWER_LOC(*s2
);
1736 return i
; /* this character different */
1738 break; /* strings match until NUL */
1742 return 0; /* strings match */
1746 #if (!defined(HAVE_STRNCASECMP) && !defined(HAVE_STRNICMP)) || defined(PROTO)
1748 * Compare two strings, for length "len", ignoring case, using current locale.
1749 * Doesn't work for multi-byte characters.
1750 * return 0 for match, < 0 for smaller, > 0 for bigger
1753 vim_strnicmp(s1
, s2
, len
)
1762 i
= (int)TOLOWER_LOC(*s1
) - (int)TOLOWER_LOC(*s2
);
1764 return i
; /* this character different */
1766 break; /* strings match until NUL */
1771 return 0; /* strings match */
1775 #if 0 /* currently not used */
1777 * Check if string "s2" appears somewhere in "s1" while ignoring case.
1778 * Return NULL if not, a pointer to the first occurrence if it does.
1786 int len
= STRLEN(s2
);
1787 char_u
*end
= s1
+ STRLEN(s1
) - len
;
1789 for (p
= s1
; p
<= end
; ++p
)
1790 if (STRNICMP(p
, s2
, len
) == 0)
1797 * Version of strchr() and strrchr() that handle unsigned char strings
1798 * with characters from 128 to 255 correctly. It also doesn't return a
1799 * pointer to the NUL at the end of the string.
1802 vim_strchr(string
, c
)
1813 char_u bytes
[MB_MAXBYTES
];
1814 int len
= (*mb_char2bytes
)(c
, bytes
);
1818 if (p
[0] == bytes
[0]
1819 && (len
<= 1 || vim_memcmp(p
, bytes
, len
) == 0))
1826 while ((b
= *p
) != NUL
)
1836 * Version of strchr() that only works for bytes and handles unsigned char
1837 * strings with characters above 128 correctly. It also doesn't return a
1838 * pointer to the NUL at the end of the string.
1841 vim_strbyte(string
, c
)
1857 * Search for last occurrence of "c" in "string".
1858 * Return NULL if not found.
1859 * Does not handle multi-byte char for "c"!
1862 vim_strrchr(string
, c
)
1866 char_u
*retval
= NULL
;
1879 * Vim's version of strpbrk(), in case it's missing.
1880 * Don't generate a prototype for this, causes problems when it's not used.
1883 # ifndef HAVE_STRPBRK
1888 vim_strpbrk(s
, charset
)
1894 if (vim_strchr(charset
, *s
) != NULL
)
1904 * Vim has its own isspace() function, because on some machines isspace()
1905 * can't handle characters above 128.
1911 return ((x
>= 9 && x
<= 13) || x
== ' ');
1914 /************************************************************************
1915 * Functions for handling growing arrays.
1919 * Clear an allocated growing array.
1925 vim_free(gap
->ga_data
);
1930 * Clear a growing array that contains a list of strings.
1933 ga_clear_strings(gap
)
1938 for (i
= 0; i
< gap
->ga_len
; ++i
)
1939 vim_free(((char_u
**)(gap
->ga_data
))[i
]);
1944 * Initialize a growing array. Don't forget to set ga_itemsize and
1945 * ga_growsize! Or use ga_init2().
1951 gap
->ga_data
= NULL
;
1957 ga_init2(gap
, itemsize
, growsize
)
1963 gap
->ga_itemsize
= itemsize
;
1964 gap
->ga_growsize
= growsize
;
1968 * Make room in growing array "gap" for at least "n" items.
1969 * Return FAIL for failure, OK otherwise.
1979 if (gap
->ga_maxlen
- gap
->ga_len
< n
)
1981 if (n
< gap
->ga_growsize
)
1982 n
= gap
->ga_growsize
;
1983 len
= gap
->ga_itemsize
* (gap
->ga_len
+ n
);
1984 pp
= alloc_clear((unsigned)len
);
1987 gap
->ga_maxlen
= gap
->ga_len
+ n
;
1988 if (gap
->ga_data
!= NULL
)
1990 mch_memmove(pp
, gap
->ga_data
,
1991 (size_t)(gap
->ga_itemsize
* gap
->ga_len
));
1992 vim_free(gap
->ga_data
);
2000 * Concatenate a string to a growarray which contains characters.
2001 * Note: Does NOT copy the NUL at the end!
2008 int len
= (int)STRLEN(s
);
2010 if (ga_grow(gap
, len
) == OK
)
2012 mch_memmove((char *)gap
->ga_data
+ gap
->ga_len
, s
, (size_t)len
);
2018 * Append one byte to a growarray which contains bytes.
2025 if (ga_grow(gap
, 1) == OK
)
2027 *((char *)gap
->ga_data
+ gap
->ga_len
) = c
;
2032 /************************************************************************
2033 * functions that use lookup tables for various things, generally to do with
2034 * special key codes.
2038 * Some useful tables.
2041 static struct modmasktable
2043 short mod_mask
; /* Bit-mask for particular key modifier */
2044 short mod_flag
; /* Bit(s) for particular key modifier */
2045 char_u name
; /* Single letter name of modifier */
2046 } mod_mask_table
[] =
2048 {MOD_MASK_ALT
, MOD_MASK_ALT
, (char_u
)'M'},
2049 {MOD_MASK_META
, MOD_MASK_META
, (char_u
)'T'},
2050 {MOD_MASK_CTRL
, MOD_MASK_CTRL
, (char_u
)'C'},
2051 {MOD_MASK_SHIFT
, MOD_MASK_SHIFT
, (char_u
)'S'},
2052 {MOD_MASK_MULTI_CLICK
, MOD_MASK_2CLICK
, (char_u
)'2'},
2053 {MOD_MASK_MULTI_CLICK
, MOD_MASK_3CLICK
, (char_u
)'3'},
2054 {MOD_MASK_MULTI_CLICK
, MOD_MASK_4CLICK
, (char_u
)'4'},
2056 {MOD_MASK_CMD
, MOD_MASK_CMD
, (char_u
)'D'},
2058 /* 'A' must be the last one */
2059 {MOD_MASK_ALT
, MOD_MASK_ALT
, (char_u
)'A'},
2064 * Shifted key terminal codes and their unshifted equivalent.
2065 * Don't add mouse codes here, they are handled separately!
2067 #define MOD_KEYS_ENTRY_SIZE 5
2069 static char_u modifier_keys_table
[] =
2071 /* mod mask with modifier without modifier */
2072 MOD_MASK_SHIFT
, '&', '9', '@', '1', /* begin */
2073 MOD_MASK_SHIFT
, '&', '0', '@', '2', /* cancel */
2074 MOD_MASK_SHIFT
, '*', '1', '@', '4', /* command */
2075 MOD_MASK_SHIFT
, '*', '2', '@', '5', /* copy */
2076 MOD_MASK_SHIFT
, '*', '3', '@', '6', /* create */
2077 MOD_MASK_SHIFT
, '*', '4', 'k', 'D', /* delete char */
2078 MOD_MASK_SHIFT
, '*', '5', 'k', 'L', /* delete line */
2079 MOD_MASK_SHIFT
, '*', '7', '@', '7', /* end */
2080 MOD_MASK_CTRL
, KS_EXTRA
, (int)KE_C_END
, '@', '7', /* end */
2081 MOD_MASK_SHIFT
, '*', '9', '@', '9', /* exit */
2082 MOD_MASK_SHIFT
, '*', '0', '@', '0', /* find */
2083 MOD_MASK_SHIFT
, '#', '1', '%', '1', /* help */
2084 MOD_MASK_SHIFT
, '#', '2', 'k', 'h', /* home */
2085 MOD_MASK_CTRL
, KS_EXTRA
, (int)KE_C_HOME
, 'k', 'h', /* home */
2086 MOD_MASK_SHIFT
, '#', '3', 'k', 'I', /* insert */
2087 MOD_MASK_SHIFT
, '#', '4', 'k', 'l', /* left arrow */
2088 MOD_MASK_CTRL
, KS_EXTRA
, (int)KE_C_LEFT
, 'k', 'l', /* left arrow */
2089 MOD_MASK_SHIFT
, '%', 'a', '%', '3', /* message */
2090 MOD_MASK_SHIFT
, '%', 'b', '%', '4', /* move */
2091 MOD_MASK_SHIFT
, '%', 'c', '%', '5', /* next */
2092 MOD_MASK_SHIFT
, '%', 'd', '%', '7', /* options */
2093 MOD_MASK_SHIFT
, '%', 'e', '%', '8', /* previous */
2094 MOD_MASK_SHIFT
, '%', 'f', '%', '9', /* print */
2095 MOD_MASK_SHIFT
, '%', 'g', '%', '0', /* redo */
2096 MOD_MASK_SHIFT
, '%', 'h', '&', '3', /* replace */
2097 MOD_MASK_SHIFT
, '%', 'i', 'k', 'r', /* right arr. */
2098 MOD_MASK_CTRL
, KS_EXTRA
, (int)KE_C_RIGHT
, 'k', 'r', /* right arr. */
2099 MOD_MASK_SHIFT
, '%', 'j', '&', '5', /* resume */
2100 MOD_MASK_SHIFT
, '!', '1', '&', '6', /* save */
2101 MOD_MASK_SHIFT
, '!', '2', '&', '7', /* suspend */
2102 MOD_MASK_SHIFT
, '!', '3', '&', '8', /* undo */
2103 MOD_MASK_SHIFT
, KS_EXTRA
, (int)KE_S_UP
, 'k', 'u', /* up arrow */
2104 MOD_MASK_SHIFT
, KS_EXTRA
, (int)KE_S_DOWN
, 'k', 'd', /* down arrow */
2107 MOD_MASK_SHIFT
, KS_EXTRA
, (int)KE_S_XF1
, KS_EXTRA
, (int)KE_XF1
,
2108 MOD_MASK_SHIFT
, KS_EXTRA
, (int)KE_S_XF2
, KS_EXTRA
, (int)KE_XF2
,
2109 MOD_MASK_SHIFT
, KS_EXTRA
, (int)KE_S_XF3
, KS_EXTRA
, (int)KE_XF3
,
2110 MOD_MASK_SHIFT
, KS_EXTRA
, (int)KE_S_XF4
, KS_EXTRA
, (int)KE_XF4
,
2112 MOD_MASK_SHIFT
, KS_EXTRA
, (int)KE_S_F1
, 'k', '1', /* F1 */
2113 MOD_MASK_SHIFT
, KS_EXTRA
, (int)KE_S_F2
, 'k', '2',
2114 MOD_MASK_SHIFT
, KS_EXTRA
, (int)KE_S_F3
, 'k', '3',
2115 MOD_MASK_SHIFT
, KS_EXTRA
, (int)KE_S_F4
, 'k', '4',
2116 MOD_MASK_SHIFT
, KS_EXTRA
, (int)KE_S_F5
, 'k', '5',
2117 MOD_MASK_SHIFT
, KS_EXTRA
, (int)KE_S_F6
, 'k', '6',
2118 MOD_MASK_SHIFT
, KS_EXTRA
, (int)KE_S_F7
, 'k', '7',
2119 MOD_MASK_SHIFT
, KS_EXTRA
, (int)KE_S_F8
, 'k', '8',
2120 MOD_MASK_SHIFT
, KS_EXTRA
, (int)KE_S_F9
, 'k', '9',
2121 MOD_MASK_SHIFT
, KS_EXTRA
, (int)KE_S_F10
, 'k', ';', /* F10 */
2123 MOD_MASK_SHIFT
, KS_EXTRA
, (int)KE_S_F11
, 'F', '1',
2124 MOD_MASK_SHIFT
, KS_EXTRA
, (int)KE_S_F12
, 'F', '2',
2125 MOD_MASK_SHIFT
, KS_EXTRA
, (int)KE_S_F13
, 'F', '3',
2126 MOD_MASK_SHIFT
, KS_EXTRA
, (int)KE_S_F14
, 'F', '4',
2127 MOD_MASK_SHIFT
, KS_EXTRA
, (int)KE_S_F15
, 'F', '5',
2128 MOD_MASK_SHIFT
, KS_EXTRA
, (int)KE_S_F16
, 'F', '6',
2129 MOD_MASK_SHIFT
, KS_EXTRA
, (int)KE_S_F17
, 'F', '7',
2130 MOD_MASK_SHIFT
, KS_EXTRA
, (int)KE_S_F18
, 'F', '8',
2131 MOD_MASK_SHIFT
, KS_EXTRA
, (int)KE_S_F19
, 'F', '9',
2132 MOD_MASK_SHIFT
, KS_EXTRA
, (int)KE_S_F20
, 'F', 'A',
2134 MOD_MASK_SHIFT
, KS_EXTRA
, (int)KE_S_F21
, 'F', 'B',
2135 MOD_MASK_SHIFT
, KS_EXTRA
, (int)KE_S_F22
, 'F', 'C',
2136 MOD_MASK_SHIFT
, KS_EXTRA
, (int)KE_S_F23
, 'F', 'D',
2137 MOD_MASK_SHIFT
, KS_EXTRA
, (int)KE_S_F24
, 'F', 'E',
2138 MOD_MASK_SHIFT
, KS_EXTRA
, (int)KE_S_F25
, 'F', 'F',
2139 MOD_MASK_SHIFT
, KS_EXTRA
, (int)KE_S_F26
, 'F', 'G',
2140 MOD_MASK_SHIFT
, KS_EXTRA
, (int)KE_S_F27
, 'F', 'H',
2141 MOD_MASK_SHIFT
, KS_EXTRA
, (int)KE_S_F28
, 'F', 'I',
2142 MOD_MASK_SHIFT
, KS_EXTRA
, (int)KE_S_F29
, 'F', 'J',
2143 MOD_MASK_SHIFT
, KS_EXTRA
, (int)KE_S_F30
, 'F', 'K',
2145 MOD_MASK_SHIFT
, KS_EXTRA
, (int)KE_S_F31
, 'F', 'L',
2146 MOD_MASK_SHIFT
, KS_EXTRA
, (int)KE_S_F32
, 'F', 'M',
2147 MOD_MASK_SHIFT
, KS_EXTRA
, (int)KE_S_F33
, 'F', 'N',
2148 MOD_MASK_SHIFT
, KS_EXTRA
, (int)KE_S_F34
, 'F', 'O',
2149 MOD_MASK_SHIFT
, KS_EXTRA
, (int)KE_S_F35
, 'F', 'P',
2150 MOD_MASK_SHIFT
, KS_EXTRA
, (int)KE_S_F36
, 'F', 'Q',
2151 MOD_MASK_SHIFT
, KS_EXTRA
, (int)KE_S_F37
, 'F', 'R',
2153 /* TAB pseudo code*/
2154 MOD_MASK_SHIFT
, 'k', 'B', KS_EXTRA
, (int)KE_TAB
,
2159 static struct key_name_entry
2161 int key
; /* Special key code or ascii value */
2162 char_u
*name
; /* Name of key */
2163 } key_names_table
[] =
2165 {' ', (char_u
*)"Space"},
2166 {TAB
, (char_u
*)"Tab"},
2167 {K_TAB
, (char_u
*)"Tab"},
2168 {NL
, (char_u
*)"NL"},
2169 {NL
, (char_u
*)"NewLine"}, /* Alternative name */
2170 {NL
, (char_u
*)"LineFeed"}, /* Alternative name */
2171 {NL
, (char_u
*)"LF"}, /* Alternative name */
2172 {CAR
, (char_u
*)"CR"},
2173 {CAR
, (char_u
*)"Return"}, /* Alternative name */
2174 {CAR
, (char_u
*)"Enter"}, /* Alternative name */
2175 {K_BS
, (char_u
*)"BS"},
2176 {K_BS
, (char_u
*)"BackSpace"}, /* Alternative name */
2177 {ESC
, (char_u
*)"Esc"},
2178 {CSI
, (char_u
*)"CSI"},
2179 {K_CSI
, (char_u
*)"xCSI"},
2180 {'|', (char_u
*)"Bar"},
2181 {'\\', (char_u
*)"Bslash"},
2182 {K_DEL
, (char_u
*)"Del"},
2183 {K_DEL
, (char_u
*)"Delete"}, /* Alternative name */
2184 {K_KDEL
, (char_u
*)"kDel"},
2185 {K_UP
, (char_u
*)"Up"},
2186 {K_DOWN
, (char_u
*)"Down"},
2187 {K_LEFT
, (char_u
*)"Left"},
2188 {K_RIGHT
, (char_u
*)"Right"},
2189 {K_XUP
, (char_u
*)"xUp"},
2190 {K_XDOWN
, (char_u
*)"xDown"},
2191 {K_XLEFT
, (char_u
*)"xLeft"},
2192 {K_XRIGHT
, (char_u
*)"xRight"},
2194 {K_F1
, (char_u
*)"F1"},
2195 {K_F2
, (char_u
*)"F2"},
2196 {K_F3
, (char_u
*)"F3"},
2197 {K_F4
, (char_u
*)"F4"},
2198 {K_F5
, (char_u
*)"F5"},
2199 {K_F6
, (char_u
*)"F6"},
2200 {K_F7
, (char_u
*)"F7"},
2201 {K_F8
, (char_u
*)"F8"},
2202 {K_F9
, (char_u
*)"F9"},
2203 {K_F10
, (char_u
*)"F10"},
2205 {K_F11
, (char_u
*)"F11"},
2206 {K_F12
, (char_u
*)"F12"},
2207 {K_F13
, (char_u
*)"F13"},
2208 {K_F14
, (char_u
*)"F14"},
2209 {K_F15
, (char_u
*)"F15"},
2210 {K_F16
, (char_u
*)"F16"},
2211 {K_F17
, (char_u
*)"F17"},
2212 {K_F18
, (char_u
*)"F18"},
2213 {K_F19
, (char_u
*)"F19"},
2214 {K_F20
, (char_u
*)"F20"},
2216 {K_F21
, (char_u
*)"F21"},
2217 {K_F22
, (char_u
*)"F22"},
2218 {K_F23
, (char_u
*)"F23"},
2219 {K_F24
, (char_u
*)"F24"},
2220 {K_F25
, (char_u
*)"F25"},
2221 {K_F26
, (char_u
*)"F26"},
2222 {K_F27
, (char_u
*)"F27"},
2223 {K_F28
, (char_u
*)"F28"},
2224 {K_F29
, (char_u
*)"F29"},
2225 {K_F30
, (char_u
*)"F30"},
2227 {K_F31
, (char_u
*)"F31"},
2228 {K_F32
, (char_u
*)"F32"},
2229 {K_F33
, (char_u
*)"F33"},
2230 {K_F34
, (char_u
*)"F34"},
2231 {K_F35
, (char_u
*)"F35"},
2232 {K_F36
, (char_u
*)"F36"},
2233 {K_F37
, (char_u
*)"F37"},
2235 {K_XF1
, (char_u
*)"xF1"},
2236 {K_XF2
, (char_u
*)"xF2"},
2237 {K_XF3
, (char_u
*)"xF3"},
2238 {K_XF4
, (char_u
*)"xF4"},
2240 {K_HELP
, (char_u
*)"Help"},
2241 {K_UNDO
, (char_u
*)"Undo"},
2242 {K_INS
, (char_u
*)"Insert"},
2243 {K_INS
, (char_u
*)"Ins"}, /* Alternative name */
2244 {K_KINS
, (char_u
*)"kInsert"},
2245 {K_HOME
, (char_u
*)"Home"},
2246 {K_KHOME
, (char_u
*)"kHome"},
2247 {K_XHOME
, (char_u
*)"xHome"},
2248 {K_ZHOME
, (char_u
*)"zHome"},
2249 {K_END
, (char_u
*)"End"},
2250 {K_KEND
, (char_u
*)"kEnd"},
2251 {K_XEND
, (char_u
*)"xEnd"},
2252 {K_ZEND
, (char_u
*)"zEnd"},
2253 {K_PAGEUP
, (char_u
*)"PageUp"},
2254 {K_PAGEDOWN
, (char_u
*)"PageDown"},
2255 {K_KPAGEUP
, (char_u
*)"kPageUp"},
2256 {K_KPAGEDOWN
, (char_u
*)"kPageDown"},
2258 {K_KPLUS
, (char_u
*)"kPlus"},
2259 {K_KMINUS
, (char_u
*)"kMinus"},
2260 {K_KDIVIDE
, (char_u
*)"kDivide"},
2261 {K_KMULTIPLY
, (char_u
*)"kMultiply"},
2262 {K_KENTER
, (char_u
*)"kEnter"},
2263 {K_KPOINT
, (char_u
*)"kPoint"},
2265 {K_K0
, (char_u
*)"k0"},
2266 {K_K1
, (char_u
*)"k1"},
2267 {K_K2
, (char_u
*)"k2"},
2268 {K_K3
, (char_u
*)"k3"},
2269 {K_K4
, (char_u
*)"k4"},
2270 {K_K5
, (char_u
*)"k5"},
2271 {K_K6
, (char_u
*)"k6"},
2272 {K_K7
, (char_u
*)"k7"},
2273 {K_K8
, (char_u
*)"k8"},
2274 {K_K9
, (char_u
*)"k9"},
2276 {'<', (char_u
*)"lt"},
2278 {K_MOUSE
, (char_u
*)"Mouse"},
2279 {K_NETTERM_MOUSE
, (char_u
*)"NetMouse"},
2280 {K_DEC_MOUSE
, (char_u
*)"DecMouse"},
2281 {K_JSBTERM_MOUSE
, (char_u
*)"JsbMouse"},
2282 {K_PTERM_MOUSE
, (char_u
*)"PtermMouse"},
2283 {K_LEFTMOUSE
, (char_u
*)"LeftMouse"},
2284 {K_LEFTMOUSE_NM
, (char_u
*)"LeftMouseNM"},
2285 {K_LEFTDRAG
, (char_u
*)"LeftDrag"},
2286 {K_LEFTRELEASE
, (char_u
*)"LeftRelease"},
2287 {K_LEFTRELEASE_NM
, (char_u
*)"LeftReleaseNM"},
2288 {K_MIDDLEMOUSE
, (char_u
*)"MiddleMouse"},
2289 {K_MIDDLEDRAG
, (char_u
*)"MiddleDrag"},
2290 {K_MIDDLERELEASE
, (char_u
*)"MiddleRelease"},
2291 {K_RIGHTMOUSE
, (char_u
*)"RightMouse"},
2292 {K_RIGHTDRAG
, (char_u
*)"RightDrag"},
2293 {K_RIGHTRELEASE
, (char_u
*)"RightRelease"},
2294 {K_MOUSEDOWN
, (char_u
*)"MouseDown"},
2295 {K_MOUSEUP
, (char_u
*)"MouseUp"},
2296 {K_X1MOUSE
, (char_u
*)"X1Mouse"},
2297 {K_X1DRAG
, (char_u
*)"X1Drag"},
2298 {K_X1RELEASE
, (char_u
*)"X1Release"},
2299 {K_X2MOUSE
, (char_u
*)"X2Mouse"},
2300 {K_X2DRAG
, (char_u
*)"X2Drag"},
2301 {K_X2RELEASE
, (char_u
*)"X2Release"},
2302 {K_DROP
, (char_u
*)"Drop"},
2303 {K_ZERO
, (char_u
*)"Nul"},
2305 {K_SNR
, (char_u
*)"SNR"},
2307 {K_PLUG
, (char_u
*)"Plug"},
2311 #define KEY_NAMES_TABLE_LEN (sizeof(key_names_table) / sizeof(struct key_name_entry))
2314 static struct mousetable
2316 int pseudo_code
; /* Code for pseudo mouse event */
2317 int button
; /* Which mouse button is it? */
2318 int is_click
; /* Is it a mouse button click event? */
2319 int is_drag
; /* Is it a mouse drag event? */
2322 {(int)KE_LEFTMOUSE
, MOUSE_LEFT
, TRUE
, FALSE
},
2324 {(int)KE_LEFTMOUSE_NM
, MOUSE_LEFT
, TRUE
, FALSE
},
2326 {(int)KE_LEFTDRAG
, MOUSE_LEFT
, FALSE
, TRUE
},
2327 {(int)KE_LEFTRELEASE
, MOUSE_LEFT
, FALSE
, FALSE
},
2329 {(int)KE_LEFTRELEASE_NM
, MOUSE_LEFT
, FALSE
, FALSE
},
2331 {(int)KE_MIDDLEMOUSE
, MOUSE_MIDDLE
, TRUE
, FALSE
},
2332 {(int)KE_MIDDLEDRAG
, MOUSE_MIDDLE
, FALSE
, TRUE
},
2333 {(int)KE_MIDDLERELEASE
, MOUSE_MIDDLE
, FALSE
, FALSE
},
2334 {(int)KE_RIGHTMOUSE
, MOUSE_RIGHT
, TRUE
, FALSE
},
2335 {(int)KE_RIGHTDRAG
, MOUSE_RIGHT
, FALSE
, TRUE
},
2336 {(int)KE_RIGHTRELEASE
, MOUSE_RIGHT
, FALSE
, FALSE
},
2337 {(int)KE_X1MOUSE
, MOUSE_X1
, TRUE
, FALSE
},
2338 {(int)KE_X1DRAG
, MOUSE_X1
, FALSE
, TRUE
},
2339 {(int)KE_X1RELEASE
, MOUSE_X1
, FALSE
, FALSE
},
2340 {(int)KE_X2MOUSE
, MOUSE_X2
, TRUE
, FALSE
},
2341 {(int)KE_X2DRAG
, MOUSE_X2
, FALSE
, TRUE
},
2342 {(int)KE_X2RELEASE
, MOUSE_X2
, FALSE
, FALSE
},
2343 /* DRAG without CLICK */
2344 {(int)KE_IGNORE
, MOUSE_RELEASE
, FALSE
, TRUE
},
2345 /* RELEASE without CLICK */
2346 {(int)KE_IGNORE
, MOUSE_RELEASE
, FALSE
, FALSE
},
2349 #endif /* FEAT_MOUSE */
2352 * Return the modifier mask bit (MOD_MASK_*) which corresponds to the given
2353 * modifier name ('S' for Shift, 'C' for Ctrl etc).
2362 for (i
= 0; mod_mask_table
[i
].mod_mask
!= 0; i
++)
2363 if (c
== mod_mask_table
[i
].name
)
2364 return mod_mask_table
[i
].mod_flag
;
2369 * Check if if there is a special key code for "key" that includes the
2370 * modifiers specified.
2373 simplify_key(key
, modifiers
)
2381 if (*modifiers
& (MOD_MASK_SHIFT
| MOD_MASK_CTRL
| MOD_MASK_ALT
))
2383 /* TAB is a special case */
2384 if (key
== TAB
&& (*modifiers
& MOD_MASK_SHIFT
))
2386 *modifiers
&= ~MOD_MASK_SHIFT
;
2389 key0
= KEY2TERMCAP0(key
);
2390 key1
= KEY2TERMCAP1(key
);
2391 for (i
= 0; modifier_keys_table
[i
] != NUL
; i
+= MOD_KEYS_ENTRY_SIZE
)
2392 if (key0
== modifier_keys_table
[i
+ 3]
2393 && key1
== modifier_keys_table
[i
+ 4]
2394 && (*modifiers
& modifier_keys_table
[i
]))
2396 *modifiers
&= ~modifier_keys_table
[i
];
2397 return TERMCAP2KEY(modifier_keys_table
[i
+ 1],
2398 modifier_keys_table
[i
+ 2]);
2405 * Change <xHome> to <Home>, <xUp> to <Up>, etc.
2413 case K_XUP
: return K_UP
;
2414 case K_XDOWN
: return K_DOWN
;
2415 case K_XLEFT
: return K_LEFT
;
2416 case K_XRIGHT
: return K_RIGHT
;
2417 case K_XHOME
: return K_HOME
;
2418 case K_ZHOME
: return K_HOME
;
2419 case K_XEND
: return K_END
;
2420 case K_ZEND
: return K_END
;
2421 case K_XF1
: return K_F1
;
2422 case K_XF2
: return K_F2
;
2423 case K_XF3
: return K_F3
;
2424 case K_XF4
: return K_F4
;
2425 case K_S_XF1
: return K_S_F1
;
2426 case K_S_XF2
: return K_S_F2
;
2427 case K_S_XF3
: return K_S_F3
;
2428 case K_S_XF4
: return K_S_F4
;
2434 * Return a string which contains the name of the given key when the given
2435 * modifiers are down.
2438 get_special_key_name(c
, modifiers
)
2442 static char_u string
[MAX_KEY_NAME_LEN
+ 1];
2451 /* Key that stands for a normal character. */
2452 if (IS_SPECIAL(c
) && KEY2TERMCAP0(c
) == KS_KEY
)
2453 c
= KEY2TERMCAP1(c
);
2456 * Translate shifted special keys into unshifted keys and set modifier.
2457 * Same for CTRL and ALT modifiers.
2461 for (i
= 0; modifier_keys_table
[i
] != 0; i
+= MOD_KEYS_ENTRY_SIZE
)
2462 if ( KEY2TERMCAP0(c
) == (int)modifier_keys_table
[i
+ 1]
2463 && (int)KEY2TERMCAP1(c
) == (int)modifier_keys_table
[i
+ 2])
2465 modifiers
|= modifier_keys_table
[i
];
2466 c
= TERMCAP2KEY(modifier_keys_table
[i
+ 3],
2467 modifier_keys_table
[i
+ 4]);
2472 /* try to find the key in the special key table */
2473 table_idx
= find_special_key_in_table(c
);
2476 * When not a known special key, and not a printable character, try to
2477 * extract modifiers.
2481 && (*mb_char2len
)(c
) == 1
2486 && (!vim_isprintc(c
) || (c
& 0x7f) == ' ')
2490 modifiers
|= MOD_MASK_ALT
;
2491 /* try again, to find the un-alted key in the special key table */
2492 table_idx
= find_special_key_in_table(c
);
2494 if (table_idx
< 0 && !vim_isprintc(c
) && c
< ' ')
2501 modifiers
|= MOD_MASK_CTRL
;
2505 /* translate the modifier into a string */
2506 for (i
= 0; mod_mask_table
[i
].name
!= 'A'; i
++)
2507 if ((modifiers
& mod_mask_table
[i
].mod_mask
)
2508 == mod_mask_table
[i
].mod_flag
)
2510 string
[idx
++] = mod_mask_table
[i
].name
;
2511 string
[idx
++] = (char_u
)'-';
2514 if (table_idx
< 0) /* unknown special key, may output t_xx */
2518 string
[idx
++] = 't';
2519 string
[idx
++] = '_';
2520 string
[idx
++] = KEY2TERMCAP0(c
);
2521 string
[idx
++] = KEY2TERMCAP1(c
);
2523 /* Not a special key, only modifiers, output directly */
2527 if (has_mbyte
&& (*mb_char2len
)(c
) > 1)
2528 idx
+= (*mb_char2bytes
)(c
, string
+ idx
);
2531 if (vim_isprintc(c
))
2537 string
[idx
++] = *s
++;
2541 else /* use name of special key */
2543 STRCPY(string
+ idx
, key_names_table
[table_idx
].name
);
2544 idx
= (int)STRLEN(string
);
2546 string
[idx
++] = '>';
2552 * Try translating a <> name at (*srcp)[] to dst[].
2553 * Return the number of characters added to dst[], zero for no match.
2554 * If there is a match, srcp is advanced to after the <> name.
2555 * dst[] must be big enough to hold the result (up to six characters)!
2558 trans_special(srcp
, dst
, keycode
)
2561 int keycode
; /* prefer key code, e.g. K_DEL instead of DEL */
2567 key
= find_special_key(srcp
, &modifiers
, keycode
, FALSE
);
2571 /* Put the appropriate modifier in a string */
2574 dst
[dlen
++] = K_SPECIAL
;
2575 dst
[dlen
++] = KS_MODIFIER
;
2576 dst
[dlen
++] = modifiers
;
2579 if (IS_SPECIAL(key
))
2581 dst
[dlen
++] = K_SPECIAL
;
2582 dst
[dlen
++] = KEY2TERMCAP0(key
);
2583 dst
[dlen
++] = KEY2TERMCAP1(key
);
2586 else if (has_mbyte
&& !keycode
)
2587 dlen
+= (*mb_char2bytes
)(key
, dst
+ dlen
);
2590 dlen
= (int)(add_char2buf(key
, dst
+ dlen
) - dst
);
2598 * Try translating a <> name at (*srcp)[], return the key and modifiers.
2599 * srcp is advanced to after the <> name.
2600 * returns 0 if there is no match.
2603 find_special_key(srcp
, modp
, keycode
, keep_x_key
)
2606 int keycode
; /* prefer key code, e.g. K_DEL instead of DEL */
2607 int keep_x_key
; /* don't translate xHome to Home key */
2610 char_u
*end_of_name
;
2622 /* Find end of modifier list */
2624 for (bp
= src
+ 1; *bp
== '-' || vim_isIDc(*bp
); bp
++)
2629 if (bp
[1] != NUL
&& bp
[2] == '>')
2630 ++bp
; /* anything accepted, like <C-?> */
2632 if (bp
[0] == 't' && bp
[1] == '_' && bp
[2] && bp
[3])
2633 bp
+= 3; /* skip t_xx, xx may be '-' or '>' */
2636 if (*bp
== '>') /* found matching '>' */
2638 end_of_name
= bp
+ 1;
2640 if (STRNICMP(src
+ 1, "char-", 5) == 0 && VIM_ISDIGIT(src
[6]))
2642 /* <Char-123> or <Char-033> or <Char-0x33> */
2643 vim_str2nr(src
+ 6, NULL
, NULL
, TRUE
, TRUE
, NULL
, &n
);
2645 *srcp
= end_of_name
;
2649 /* Which modifiers are given? */
2651 for (bp
= src
+ 1; bp
< last_dash
; bp
++)
2655 bit
= name_to_mod_mask(*bp
);
2657 break; /* Illegal modifier name */
2663 * Legal modifier name.
2665 if (bp
>= last_dash
)
2668 * Modifier with single letter, or special key name.
2670 if (modifiers
!= 0 && last_dash
[2] == '>')
2674 key
= get_special_key_code(last_dash
+ 1);
2676 key
= handle_x_keys(key
);
2680 * get_special_key_code() may return NUL for invalid
2686 * Only use a modifier when there is no special key code that
2687 * includes the modifier.
2689 key
= simplify_key(key
, &modifiers
);
2693 /* don't want keycode, use single byte code */
2696 else if (key
== K_DEL
|| key
== K_KDEL
)
2701 * Normal Key with modifier: Try to make a single byte code.
2703 if (!IS_SPECIAL(key
))
2704 key
= extract_modifiers(key
, &modifiers
);
2707 *srcp
= end_of_name
;
2716 * Try to include modifiers in the key.
2717 * Changes "Shift-a" to 'A', "Alt-A" to 0xc0, etc.
2720 extract_modifiers(key
, modp
)
2724 int modifiers
= *modp
;
2727 /* Command-key really special, No fancynest */
2728 if (!(modifiers
& MOD_MASK_CMD
))
2730 if ((modifiers
& MOD_MASK_SHIFT
) && ASCII_ISALPHA(key
))
2732 key
= TOUPPER_ASC(key
);
2733 modifiers
&= ~MOD_MASK_SHIFT
;
2735 if ((modifiers
& MOD_MASK_CTRL
)
2737 /* * TODO: EBCDIC Better use:
2738 * && (Ctrl_chr(key) || key == '?')
2740 && strchr("?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_", key
)
2743 && ((key
>= '?' && key
<= '_') || ASCII_ISALPHA(key
))
2747 key
= Ctrl_chr(key
);
2748 modifiers
&= ~MOD_MASK_CTRL
;
2749 /* <C-@> is <Nul> */
2754 /* Command-key really special, No fancynest */
2755 if (!(modifiers
& MOD_MASK_CMD
))
2757 if ((modifiers
& MOD_MASK_ALT
) && key
< 0x80
2759 && !enc_dbcs
/* avoid creating a lead byte */
2764 modifiers
&= ~MOD_MASK_ALT
; /* remove the META modifier */
2772 * Try to find key "c" in the special key table.
2773 * Return the index when found, -1 when not found.
2776 find_special_key_in_table(c
)
2781 for (i
= 0; key_names_table
[i
].name
!= NULL
; i
++)
2782 if (c
== key_names_table
[i
].key
)
2784 if (key_names_table
[i
].name
== NULL
)
2790 * Find the special key with the given name (the given string does not have to
2791 * end with NUL, the name is assumed to end before the first non-idchar).
2792 * If the name starts with "t_" the next two characters are interpreted as a
2794 * Return the key code, or 0 if not found.
2797 get_special_key_code(name
)
2805 * If it's <t_xx> we get the code for xx from the termcap
2807 if (name
[0] == 't' && name
[1] == '_' && name
[2] != NUL
&& name
[3] != NUL
)
2809 string
[0] = name
[2];
2810 string
[1] = name
[3];
2812 if (add_termcap_entry(string
, FALSE
) == OK
)
2813 return TERMCAP2KEY(name
[2], name
[3]);
2816 for (i
= 0; key_names_table
[i
].name
!= NULL
; i
++)
2818 table_name
= key_names_table
[i
].name
;
2819 for (j
= 0; vim_isIDc(name
[j
]) && table_name
[j
] != NUL
; j
++)
2820 if (TOLOWER_ASC(table_name
[j
]) != TOLOWER_ASC(name
[j
]))
2822 if (!vim_isIDc(name
[j
]) && table_name
[j
] == NUL
)
2823 return key_names_table
[i
].key
;
2828 #if defined(FEAT_CMDL_COMPL) || defined(PROTO)
2833 if (i
>= (int)KEY_NAMES_TABLE_LEN
)
2835 return key_names_table
[i
].name
;
2839 #if defined(FEAT_MOUSE) || defined(PROTO)
2841 * Look up the given mouse code to return the relevant information in the other
2842 * arguments. Return which button is down or was released.
2845 get_mouse_button(code
, is_click
, is_drag
)
2852 for (i
= 0; mouse_table
[i
].pseudo_code
; i
++)
2853 if (code
== mouse_table
[i
].pseudo_code
)
2855 *is_click
= mouse_table
[i
].is_click
;
2856 *is_drag
= mouse_table
[i
].is_drag
;
2857 return mouse_table
[i
].button
;
2859 return 0; /* Shouldn't get here */
2863 * Return the appropriate pseudo mouse event token (KE_LEFTMOUSE etc) based on
2864 * the given information about which mouse button is down, and whether the
2865 * mouse was clicked, dragged or released.
2868 get_pseudo_mouse_code(button
, is_click
, is_drag
)
2869 int button
; /* eg MOUSE_LEFT */
2875 for (i
= 0; mouse_table
[i
].pseudo_code
; i
++)
2876 if (button
== mouse_table
[i
].button
2877 && is_click
== mouse_table
[i
].is_click
2878 && is_drag
== mouse_table
[i
].is_drag
)
2881 /* Trick: a non mappable left click and release has mouse_col -1
2882 * or added MOUSE_COLOFF. Used for 'mousefocus' in
2883 * gui_mouse_moved() */
2884 if (mouse_col
< 0 || mouse_col
> MOUSE_COLOFF
)
2889 mouse_col
-= MOUSE_COLOFF
;
2890 if (mouse_table
[i
].pseudo_code
== (int)KE_LEFTMOUSE
)
2891 return (int)KE_LEFTMOUSE_NM
;
2892 if (mouse_table
[i
].pseudo_code
== (int)KE_LEFTRELEASE
)
2893 return (int)KE_LEFTRELEASE_NM
;
2896 return mouse_table
[i
].pseudo_code
;
2898 return (int)KE_IGNORE
; /* not recognized, ignore it */
2900 #endif /* FEAT_MOUSE */
2903 * Return the current end-of-line type: EOL_DOS, EOL_UNIX or EOL_MAC.
2909 int c
= *buf
->b_p_ff
;
2911 if (buf
->b_p_bin
|| c
== 'u')
2919 * Like get_fileformat(), but override 'fileformat' with "p" for "++opt=val"
2923 get_fileformat_force(buf
, eap
)
2925 exarg_T
*eap
; /* can be NULL! */
2929 if (eap
!= NULL
&& eap
->force_ff
!= 0)
2930 c
= eap
->cmd
[eap
->force_ff
];
2933 if ((eap
!= NULL
&& eap
->force_bin
!= 0)
2934 ? (eap
->force_bin
== FORCE_BIN
) : buf
->b_p_bin
)
2946 * Set the current end-of-line type to EOL_DOS, EOL_UNIX or EOL_MAC.
2947 * Sets both 'textmode' and 'fileformat'.
2948 * Note: Does _not_ set global value of 'textmode'!
2951 set_fileformat(t
, opt_flags
)
2953 int opt_flags
; /* OPT_LOCAL and/or OPT_GLOBAL */
2961 curbuf
->b_p_tx
= TRUE
;
2965 curbuf
->b_p_tx
= FALSE
;
2969 curbuf
->b_p_tx
= FALSE
;
2973 set_string_option_direct((char_u
*)"ff", -1, (char_u
*)p
,
2974 OPT_FREE
| opt_flags
, 0);
2977 /* This may cause the buffer to become (un)modified. */
2978 check_status(curbuf
);
2979 redraw_tabline
= TRUE
;
2982 need_maketitle
= TRUE
; /* set window title later */
2987 * Return the default fileformat from 'fileformats'.
2990 default_fileformat()
2994 case 'm': return EOL_MAC
;
2995 case 'd': return EOL_DOS
;
3001 * Call shell. Calls mch_call_shell, with 'shellxquote' added.
3004 call_shell(cmd
, opt
)
3011 proftime_T wait_time
;
3017 smsg((char_u
*)_("Calling shell to execute: \"%s\""),
3018 cmd
== NULL
? p_sh
: cmd
);
3025 if (do_profiling
== PROF_YES
)
3026 prof_child_enter(&wait_time
);
3031 EMSG(_(e_shellempty
));
3036 #ifdef FEAT_GUI_MSWIN
3037 /* Don't hide the pointer while executing a shell command. */
3038 gui_mch_mousehide(FALSE
);
3043 /* The external command may update a tags file, clear cached tags. */
3046 if (cmd
== NULL
|| *p_sxq
== NUL
)
3047 retval
= mch_call_shell(cmd
, opt
);
3050 ncmd
= alloc((unsigned)(STRLEN(cmd
) + STRLEN(p_sxq
) * 2 + 1));
3053 STRCPY(ncmd
, p_sxq
);
3055 STRCAT(ncmd
, p_sxq
);
3056 retval
= mch_call_shell(ncmd
, opt
);
3066 * Check the window size, in case it changed while executing the
3069 shell_resized_check();
3073 set_vim_var_nr(VV_SHELL_ERROR
, (long)retval
);
3074 # ifdef FEAT_PROFILE
3075 if (do_profiling
== PROF_YES
)
3076 prof_child_exit(&wait_time
);
3084 * VISUAL, SELECTMODE and OP_PENDING State are never set, they are equal to
3085 * NORMAL State with a condition. This function returns the real State.
3107 #if defined(FEAT_MBYTE) || defined(PROTO)
3109 * Return TRUE if "p" points to just after a path separator.
3110 * Take care of multi-byte characters.
3111 * "b" must point to the start of the file name
3118 return vim_ispathsep(p
[-1])
3119 && (!has_mbyte
|| (*mb_head_off
)(b
, p
- 1) == 0);
3124 * Return TRUE if file names "f1" and "f2" are in the same directory.
3125 * "f1" may be a short name, "f2" must be a full path.
3128 same_directory(f1
, f2
)
3132 char_u ffname
[MAXPATHL
];
3137 if (f1
== NULL
|| f2
== NULL
)
3140 (void)vim_FullName(f1
, ffname
, MAXPATHL
, FALSE
);
3141 t1
= gettail_sep(ffname
);
3142 t2
= gettail_sep(f2
);
3143 return (t1
- ffname
== t2
- f2
3144 && pathcmp((char *)ffname
, (char *)f2
, (int)(t1
- ffname
)) == 0);
3147 #if defined(FEAT_SESSION) || defined(MSWIN) || defined(FEAT_GUI_MAC) \
3148 || ((defined(FEAT_GUI_GTK)) \
3149 && ( defined(FEAT_WINDOWS) || defined(FEAT_DND)) ) \
3150 || defined(FEAT_SUN_WORKSHOP) || defined(FEAT_NETBEANS_INTG) \
3153 * Change to a file's directory.
3154 * Caller must call shorten_fnames()!
3155 * Return OK or FAIL.
3158 vim_chdirfile(fname
)
3161 char_u dir
[MAXPATHL
];
3163 vim_strncpy(dir
, fname
, MAXPATHL
- 1);
3164 *gettail_sep(dir
) = NUL
;
3165 return mch_chdir((char *)dir
) == 0 ? OK
: FAIL
;
3169 #if defined(STAT_IGNORES_SLASH) || defined(PROTO)
3171 * Check if "name" ends in a slash and is not a directory.
3172 * Used for systems where stat() ignores a trailing slash on a file name.
3173 * The Vim code assumes a trailing slash is only ignored for a directory.
3180 return FALSE
; /* no file name is not illegal */
3181 if (name
[strlen(name
) - 1] != '/')
3182 return FALSE
; /* no trailing slash */
3183 if (mch_isdir((char_u
*)name
))
3184 return FALSE
; /* trailing slash for a directory */
3189 #if defined(CURSOR_SHAPE) || defined(PROTO)
3192 * Handling of cursor and mouse pointer shapes in various modes.
3195 cursorentry_T shape_table
[SHAPE_IDX_COUNT
] =
3197 /* The values will be filled in from the 'guicursor' and 'mouseshape'
3198 * defaults when Vim starts.
3199 * Adjust the SHAPE_IDX_ defines when making changes! */
3200 {0, 0, 0, 700L, 400L, 250L, 0, 0, "n", SHAPE_CURSOR
+SHAPE_MOUSE
},
3201 {0, 0, 0, 700L, 400L, 250L, 0, 0, "v", SHAPE_CURSOR
+SHAPE_MOUSE
},
3202 {0, 0, 0, 700L, 400L, 250L, 0, 0, "i", SHAPE_CURSOR
+SHAPE_MOUSE
},
3203 {0, 0, 0, 700L, 400L, 250L, 0, 0, "r", SHAPE_CURSOR
+SHAPE_MOUSE
},
3204 {0, 0, 0, 700L, 400L, 250L, 0, 0, "c", SHAPE_CURSOR
+SHAPE_MOUSE
},
3205 {0, 0, 0, 700L, 400L, 250L, 0, 0, "ci", SHAPE_CURSOR
+SHAPE_MOUSE
},
3206 {0, 0, 0, 700L, 400L, 250L, 0, 0, "cr", SHAPE_CURSOR
+SHAPE_MOUSE
},
3207 {0, 0, 0, 700L, 400L, 250L, 0, 0, "o", SHAPE_CURSOR
+SHAPE_MOUSE
},
3208 {0, 0, 0, 700L, 400L, 250L, 0, 0, "ve", SHAPE_CURSOR
+SHAPE_MOUSE
},
3209 {0, 0, 0, 0L, 0L, 0L, 0, 0, "e", SHAPE_MOUSE
},
3210 {0, 0, 0, 0L, 0L, 0L, 0, 0, "s", SHAPE_MOUSE
},
3211 {0, 0, 0, 0L, 0L, 0L, 0, 0, "sd", SHAPE_MOUSE
},
3212 {0, 0, 0, 0L, 0L, 0L, 0, 0, "vs", SHAPE_MOUSE
},
3213 {0, 0, 0, 0L, 0L, 0L, 0, 0, "vd", SHAPE_MOUSE
},
3214 {0, 0, 0, 0L, 0L, 0L, 0, 0, "m", SHAPE_MOUSE
},
3215 {0, 0, 0, 0L, 0L, 0L, 0, 0, "ml", SHAPE_MOUSE
},
3216 {0, 0, 0, 100L, 100L, 100L, 0, 0, "sm", SHAPE_CURSOR
},
3219 #ifdef FEAT_MOUSESHAPE
3221 * Table with names for mouse shapes. Keep in sync with all the tables for
3222 * mch_set_mouse_shape()!.
3224 static char * mshape_names
[] =
3226 "arrow", /* default, must be the first one */
3227 "blank", /* hidden */
3247 * Parse the 'guicursor' option ("what" is SHAPE_CURSOR) or 'mouseshape'
3248 * ("what" is SHAPE_MOUSE).
3249 * Returns error message for an illegal option, NULL otherwise.
3252 parse_shape_opt(what
)
3260 int idx
= 0; /* init for GCC */
3265 int found_ve
= FALSE
; /* found "ve" flag */
3269 * First round: check for errors; second round: do it for real.
3271 for (round
= 1; round
<= 2; ++round
)
3274 * Repeat for all comma separated parts.
3276 #ifdef FEAT_MOUSESHAPE
3277 if (what
== SHAPE_MOUSE
)
3278 modep
= p_mouseshape
;
3281 modep
= p_guicursor
;
3282 while (*modep
!= NUL
)
3284 colonp
= vim_strchr(modep
, ':');
3286 return (char_u
*)N_("E545: Missing colon");
3287 if (colonp
== modep
)
3288 return (char_u
*)N_("E546: Illegal mode");
3289 commap
= vim_strchr(modep
, ',');
3292 * Repeat for all mode's before the colon.
3293 * For the 'a' mode, we loop to handle all the modes.
3296 while (modep
< colonp
|| all_idx
>= 0)
3300 /* Find the mode. */
3301 if (modep
[1] == '-' || modep
[1] == ':')
3305 if (len
== 1 && TOLOWER_ASC(modep
[0]) == 'a')
3306 all_idx
= SHAPE_IDX_COUNT
- 1;
3309 for (idx
= 0; idx
< SHAPE_IDX_COUNT
; ++idx
)
3310 if (STRNICMP(modep
, shape_table
[idx
].name
, len
)
3313 if (idx
== SHAPE_IDX_COUNT
3314 || (shape_table
[idx
].used_for
& what
) == 0)
3315 return (char_u
*)N_("E546: Illegal mode");
3316 if (len
== 2 && modep
[0] == 'v' && modep
[1] == 'e')
3324 else if (round
== 2)
3326 #ifdef FEAT_MOUSESHAPE
3327 if (what
== SHAPE_MOUSE
)
3329 /* Set the default, for the missing parts */
3330 shape_table
[idx
].mshape
= 0;
3335 /* Set the defaults, for the missing parts */
3336 shape_table
[idx
].shape
= SHAPE_BLOCK
;
3337 shape_table
[idx
].blinkwait
= 700L;
3338 shape_table
[idx
].blinkon
= 400L;
3339 shape_table
[idx
].blinkoff
= 250L;
3343 /* Parse the part after the colon */
3344 for (p
= colonp
+ 1; *p
&& *p
!= ','; )
3346 #ifdef FEAT_MOUSESHAPE
3347 if (what
== SHAPE_MOUSE
)
3351 if (mshape_names
[i
] == NULL
)
3353 if (!VIM_ISDIGIT(*p
))
3354 return (char_u
*)N_("E547: Illegal mouseshape");
3356 shape_table
[idx
].mshape
=
3357 getdigits(&p
) + MSHAPE_NUMBERED
;
3359 (void)getdigits(&p
);
3362 len
= (int)STRLEN(mshape_names
[i
]);
3363 if (STRNICMP(p
, mshape_names
[i
], len
) == 0)
3366 shape_table
[idx
].mshape
= i
;
3372 else /* if (what == SHAPE_MOUSE) */
3376 * First handle the ones with a number argument.
3380 if (STRNICMP(p
, "ver", 3) == 0)
3382 else if (STRNICMP(p
, "hor", 3) == 0)
3384 else if (STRNICMP(p
, "blinkwait", 9) == 0)
3386 else if (STRNICMP(p
, "blinkon", 7) == 0)
3388 else if (STRNICMP(p
, "blinkoff", 8) == 0)
3393 if (!VIM_ISDIGIT(*p
))
3394 return (char_u
*)N_("E548: digit expected");
3396 if (len
== 3) /* "ver" or "hor" */
3399 return (char_u
*)N_("E549: Illegal percentage");
3402 if (TOLOWER_ASC(i
) == 'v')
3403 shape_table
[idx
].shape
= SHAPE_VER
;
3405 shape_table
[idx
].shape
= SHAPE_HOR
;
3406 shape_table
[idx
].percentage
= n
;
3409 else if (round
== 2)
3412 shape_table
[idx
].blinkwait
= n
;
3414 shape_table
[idx
].blinkon
= n
;
3416 shape_table
[idx
].blinkoff
= n
;
3419 else if (STRNICMP(p
, "block", 5) == 0)
3422 shape_table
[idx
].shape
= SHAPE_BLOCK
;
3425 else /* must be a highlight group name then */
3427 endp
= vim_strchr(p
, '-');
3428 if (commap
== NULL
) /* last part */
3431 endp
= p
+ STRLEN(p
); /* find end of part */
3433 else if (endp
> commap
|| endp
== NULL
)
3435 slashp
= vim_strchr(p
, '/');
3436 if (slashp
!= NULL
&& slashp
< endp
)
3438 /* "group/langmap_group" */
3439 i
= syn_check_group(p
, (int)(slashp
- p
));
3444 shape_table
[idx
].id
= syn_check_group(p
,
3446 shape_table
[idx
].id_lm
= shape_table
[idx
].id
;
3447 if (slashp
!= NULL
&& slashp
< endp
)
3448 shape_table
[idx
].id
= i
;
3452 } /* if (what != SHAPE_MOUSE) */
3464 /* If the 's' flag is not given, use the 'v' cursor for 's' */
3467 #ifdef FEAT_MOUSESHAPE
3468 if (what
== SHAPE_MOUSE
)
3470 shape_table
[SHAPE_IDX_VE
].mshape
= shape_table
[SHAPE_IDX_V
].mshape
;
3475 shape_table
[SHAPE_IDX_VE
].shape
= shape_table
[SHAPE_IDX_V
].shape
;
3476 shape_table
[SHAPE_IDX_VE
].percentage
=
3477 shape_table
[SHAPE_IDX_V
].percentage
;
3478 shape_table
[SHAPE_IDX_VE
].blinkwait
=
3479 shape_table
[SHAPE_IDX_V
].blinkwait
;
3480 shape_table
[SHAPE_IDX_VE
].blinkon
=
3481 shape_table
[SHAPE_IDX_V
].blinkon
;
3482 shape_table
[SHAPE_IDX_VE
].blinkoff
=
3483 shape_table
[SHAPE_IDX_V
].blinkoff
;
3484 shape_table
[SHAPE_IDX_VE
].id
= shape_table
[SHAPE_IDX_V
].id
;
3485 shape_table
[SHAPE_IDX_VE
].id_lm
= shape_table
[SHAPE_IDX_V
].id_lm
;
3492 # if defined(MCH_CURSOR_SHAPE) || defined(FEAT_GUI) \
3493 || defined(FEAT_MOUSESHAPE) || defined(PROTO)
3495 * Return the index into shape_table[] for the current mode.
3496 * When "mouse" is TRUE, consider indexes valid for the mouse pointer.
3499 get_shape_idx(mouse
)
3502 #ifdef FEAT_MOUSESHAPE
3503 if (mouse
&& (State
== HITRETURN
|| State
== ASKMORE
))
3507 gui_mch_getmouse(&x
, &y
);
3508 if (Y_2_ROW(y
) == Rows
- 1)
3509 return SHAPE_IDX_MOREL
;
3511 return SHAPE_IDX_MORE
;
3513 if (mouse
&& drag_status_line
)
3514 return SHAPE_IDX_SDRAG
;
3515 # ifdef FEAT_VERTSPLIT
3516 if (mouse
&& drag_sep_line
)
3517 return SHAPE_IDX_VDRAG
;
3520 if (!mouse
&& State
== SHOWMATCH
)
3521 return SHAPE_IDX_SM
;
3522 #ifdef FEAT_VREPLACE
3523 if (State
& VREPLACE_FLAG
)
3526 if (State
& REPLACE_FLAG
)
3530 if (State
& CMDLINE
)
3532 if (cmdline_at_end())
3534 if (cmdline_overstrike())
3535 return SHAPE_IDX_CR
;
3536 return SHAPE_IDX_CI
;
3544 return SHAPE_IDX_VE
;
3553 # if defined(FEAT_MOUSESHAPE) || defined(PROTO)
3554 static int old_mouse_shape
= 0;
3557 * Set the mouse shape:
3558 * If "shape" is -1, use shape depending on the current mode,
3559 * depending on the current state.
3560 * If "shape" is -2, only update the shape when it's CLINE or STATUS (used
3561 * when the mouse moves off the status or command line).
3564 update_mouseshape(shape_idx
)
3567 int new_mouse_shape
;
3569 /* Only works in GUI mode. */
3570 if (!gui
.in_use
|| gui
.starting
)
3573 /* Postpone the updating when more is to come. Speeds up executing of
3575 if (shape_idx
== -1 && char_avail())
3577 postponed_mouseshape
= TRUE
;
3581 /* When ignoring the mouse don't change shape on the statusline. */
3583 && (shape_idx
== SHAPE_IDX_CLINE
3584 || shape_idx
== SHAPE_IDX_STATUS
3585 || shape_idx
== SHAPE_IDX_VSEP
))
3589 && old_mouse_shape
!= shape_table
[SHAPE_IDX_CLINE
].mshape
3590 && old_mouse_shape
!= shape_table
[SHAPE_IDX_STATUS
].mshape
3591 && old_mouse_shape
!= shape_table
[SHAPE_IDX_VSEP
].mshape
)
3594 new_mouse_shape
= shape_table
[get_shape_idx(TRUE
)].mshape
;
3596 new_mouse_shape
= shape_table
[shape_idx
].mshape
;
3597 if (new_mouse_shape
!= old_mouse_shape
)
3599 mch_set_mouse_shape(new_mouse_shape
);
3600 old_mouse_shape
= new_mouse_shape
;
3602 postponed_mouseshape
= FALSE
;
3606 #endif /* CURSOR_SHAPE */
3611 * Optional encryption support.
3612 * Mohsin Ahmed, mosh@sasi.com, 98-09-24
3613 * Based on zip/crypt sources.
3615 * NOTE FOR USA: Since 2000 exporting this code from the USA is allowed to
3616 * most countries. There are a few exceptions, but that still should not be a
3617 * problem since this code was originally created in Europe and India.
3622 typedef unsigned short ush
; /* unsigned 16-bit value */
3623 typedef unsigned long ulg
; /* unsigned 32-bit value */
3625 static void make_crc_tab
__ARGS((void));
3627 static ulg crc_32_tab
[256];
3630 * Fill the CRC table.
3636 static int done
= FALSE
;
3640 for (t
= 0; t
< 256; t
++)
3643 for (s
= 0; s
< 8; s
++)
3644 v
= (v
>> 1) ^ ((v
& 1) * (ulg
)0xedb88320L
);
3650 #define CRC32(c, b) (crc_32_tab[((int)(c) ^ (b)) & 0xff] ^ ((c) >> 8))
3653 static ulg keys
[3]; /* keys defining the pseudo-random sequence */
3656 * Return the next byte in the pseudo-random sequence
3663 temp
= (ush
)keys
[2] | 2;
3664 return (int)(((unsigned)(temp
* (temp
^ 1)) >> 8) & 0xff);
3668 * Update the encryption keys with the next byte of plain text
3672 int c
; /* byte of plain text */
3674 keys
[0] = CRC32(keys
[0], c
);
3675 keys
[1] += keys
[0] & 0xff;
3676 keys
[1] = keys
[1] * 134775813L + 1;
3677 keys
[2] = CRC32(keys
[2], (int)(keys
[1] >> 24));
3682 * Initialize the encryption keys and the random header according to
3683 * the given password.
3684 * If "passwd" is NULL or empty, don't do anything.
3687 crypt_init_keys(passwd
)
3688 char_u
*passwd
; /* password string with which to modify keys */
3690 if (passwd
!= NULL
&& *passwd
!= NUL
)
3693 keys
[0] = 305419896L;
3694 keys
[1] = 591751049L;
3695 keys
[2] = 878082192L;
3696 while (*passwd
!= '\0')
3697 update_keys((int)*passwd
++);
3702 * Ask the user for a crypt key.
3703 * When "store" is TRUE, the new key in stored in the 'key' option, and the
3704 * 'key' option value is returned: Don't free it.
3705 * When "store" is FALSE, the typed key is returned in allocated memory.
3706 * Returns NULL on failure.
3709 get_crypt_key(store
, twice
)
3711 int twice
; /* Ask for the key twice. */
3713 char_u
*p1
, *p2
= NULL
;
3716 for (round
= 0; ; ++round
)
3718 cmdline_star
= TRUE
;
3719 cmdline_row
= msg_row
;
3720 p1
= getcmdline_prompt(NUL
, round
== 0
3721 ? (char_u
*)_("Enter encryption key: ")
3722 : (char_u
*)_("Enter same key again: "), 0, EXPAND_NOTHING
,
3724 cmdline_star
= FALSE
;
3731 if (p2
!= NULL
&& STRCMP(p1
, p2
) != 0)
3733 MSG(_("Keys don't match!"));
3737 round
= -1; /* do it again */
3742 set_option_value((char_u
*)"key", 0L, p1
, OPT_LOCAL
);
3744 p1
= curbuf
->b_p_key
;
3751 /* since the user typed this, no need to wait for return */
3752 need_wait_return
= FALSE
;
3759 #endif /* FEAT_CRYPT */
3761 /* TODO: make some #ifdef for this */
3762 /*--------[ file searching ]-------------------------------------------------*/
3764 * File searching functions for 'path', 'tags' and 'cdpath' options.
3765 * External visible functions:
3766 * vim_findfile_init() creates/initialises the search context
3767 * vim_findfile_free_visited() free list of visited files/dirs of search
3769 * vim_findfile() find a file in the search context
3770 * vim_findfile_cleanup() cleanup/free search context created by
3771 * vim_findfile_init()
3773 * All static functions and variables start with 'ff_'
3775 * In general it works like this:
3776 * First you create yourself a search context by calling vim_findfile_init().
3777 * It is possible to give a search context from a previous call to
3778 * vim_findfile_init(), so it can be reused. After this you call vim_findfile()
3779 * until you are satisfied with the result or it returns NULL. On every call it
3780 * returns the next file which matches the conditions given to
3781 * vim_findfile_init(). If it doesn't find a next file it returns NULL.
3783 * It is possible to call vim_findfile_init() again to reinitialise your search
3784 * with some new parameters. Don't forget to pass your old search context to
3785 * it, so it can reuse it and especially reuse the list of already visited
3786 * directories. If you want to delete the list of already visited directories
3787 * simply call vim_findfile_free_visited().
3789 * When you are done call vim_findfile_cleanup() to free the search context.
3791 * The function vim_findfile_init() has a long comment, which describes the
3792 * needed parameters.
3798 * Also we use an allocated search context here, this functions are NOT
3801 * To minimize parameter passing (or because I'm to lazy), only the
3802 * external visible functions get a search context as a parameter. This is
3803 * then assigned to a static global, which is used throughout the local
3808 * type for the directory search stack
3810 typedef struct ff_stack
3812 struct ff_stack
*ffs_prev
;
3814 /* the fix part (no wildcards) and the part containing the wildcards
3815 * of the search path
3817 char_u
*ffs_fix_path
;
3818 #ifdef FEAT_PATH_EXTRA
3819 char_u
*ffs_wc_path
;
3822 /* files/dirs found in the above directory, matched by the first wildcard
3825 char_u
**ffs_filearray
;
3826 int ffs_filearray_size
;
3827 char_u ffs_filearray_cur
; /* needed for partly handled dirs */
3829 /* to store status of partly handled directories
3830 * 0: we work on this directory for the first time
3831 * 1: this directory was partly searched in an earlier step
3835 /* How deep are we in the directory tree?
3836 * Counts backward from value of level parameter to vim_findfile_init
3840 /* Did we already expand '**' to an empty string? */
3841 int ffs_star_star_empty
;
3845 * type for already visited directories or files.
3847 typedef struct ff_visited
3849 struct ff_visited
*ffv_next
;
3851 #ifdef FEAT_PATH_EXTRA
3852 /* Visited directories are different if the wildcard string are
3853 * different. So we have to save it.
3855 char_u
*ffv_wc_path
;
3857 /* for unix use inode etc for comparison (needed because of links), else
3861 int ffv_dev_valid
; /* ffv_dev and ffv_ino were set */
3862 dev_t ffv_dev
; /* device number */
3863 ino_t ffv_ino
; /* inode number */
3865 /* The memory for this struct is allocated according to the length of
3868 char_u ffv_fname
[1]; /* actually longer */
3872 * We might have to manage several visited lists during a search.
3873 * This is especially needed for the tags option. If tags is set to:
3874 * "./++/tags,./++/TAGS,++/tags" (replace + with *)
3875 * So we have to do 3 searches:
3876 * 1) search from the current files directory downward for the file "tags"
3877 * 2) search from the current files directory downward for the file "TAGS"
3878 * 3) search from Vims current directory downwards for the file "tags"
3879 * As you can see, the first and the third search are for the same file, so for
3880 * the third search we can use the visited list of the first search. For the
3881 * second search we must start from a empty visited list.
3882 * The struct ff_visited_list_hdr is used to manage a linked list of already
3885 typedef struct ff_visited_list_hdr
3887 struct ff_visited_list_hdr
*ffvl_next
;
3889 /* the filename the attached visited list is for */
3890 char_u
*ffvl_filename
;
3892 ff_visited_T
*ffvl_visited_list
;
3894 } ff_visited_list_hdr_T
;
3898 * '**' can be expanded to several directory levels.
3899 * Set the default maximum depth.
3901 #define FF_MAX_STAR_STAR_EXPAND ((char_u)30)
3904 * The search context:
3905 * ffsc_stack_ptr: the stack for the dirs to search
3906 * ffsc_visited_list: the currently active visited list
3907 * ffsc_dir_visited_list: the currently active visited list for search dirs
3908 * ffsc_visited_lists_list: the list of all visited lists
3909 * ffsc_dir_visited_lists_list: the list of all visited lists for search dirs
3910 * ffsc_file_to_search: the file to search for
3911 * ffsc_start_dir: the starting directory, if search path was relative
3912 * ffsc_fix_path: the fix part of the given path (without wildcards)
3913 * Needed for upward search.
3914 * ffsc_wc_path: the part of the given path containing wildcards
3915 * ffsc_level: how many levels of dirs to search downwards
3916 * ffsc_stopdirs_v: array of stop directories for upward search
3917 * ffsc_find_what: FINDFILE_BOTH, FINDFILE_DIR or FINDFILE_FILE
3919 typedef struct ff_search_ctx_T
3921 ff_stack_T
*ffsc_stack_ptr
;
3922 ff_visited_list_hdr_T
*ffsc_visited_list
;
3923 ff_visited_list_hdr_T
*ffsc_dir_visited_list
;
3924 ff_visited_list_hdr_T
*ffsc_visited_lists_list
;
3925 ff_visited_list_hdr_T
*ffsc_dir_visited_lists_list
;
3926 char_u
*ffsc_file_to_search
;
3927 char_u
*ffsc_start_dir
;
3928 char_u
*ffsc_fix_path
;
3929 #ifdef FEAT_PATH_EXTRA
3930 char_u
*ffsc_wc_path
;
3932 char_u
**ffsc_stopdirs_v
;
3937 /* locally needed functions */
3938 #ifdef FEAT_PATH_EXTRA
3939 static int ff_check_visited
__ARGS((ff_visited_T
**, char_u
*, char_u
*));
3941 static int ff_check_visited
__ARGS((ff_visited_T
**, char_u
*));
3943 static void vim_findfile_free_visited_list
__ARGS((ff_visited_list_hdr_T
**list_headp
));
3944 static void ff_free_visited_list
__ARGS((ff_visited_T
*vl
));
3945 static ff_visited_list_hdr_T
* ff_get_visited_list
__ARGS((char_u
*, ff_visited_list_hdr_T
**list_headp
));
3946 #ifdef FEAT_PATH_EXTRA
3947 static int ff_wc_equal
__ARGS((char_u
*s1
, char_u
*s2
));
3950 static void ff_push
__ARGS((ff_search_ctx_T
*search_ctx
, ff_stack_T
*stack_ptr
));
3951 static ff_stack_T
*ff_pop
__ARGS((ff_search_ctx_T
*search_ctx
));
3952 static void ff_clear
__ARGS((ff_search_ctx_T
*search_ctx
));
3953 static void ff_free_stack_element
__ARGS((ff_stack_T
*stack_ptr
));
3954 #ifdef FEAT_PATH_EXTRA
3955 static ff_stack_T
*ff_create_stack_element
__ARGS((char_u
*, char_u
*, int, int));
3957 static ff_stack_T
*ff_create_stack_element
__ARGS((char_u
*, int, int));
3959 #ifdef FEAT_PATH_EXTRA
3960 static int ff_path_in_stoplist
__ARGS((char_u
*, int, char_u
**));
3965 * if someone likes findfirst/findnext, here are the functions
3969 static void *ff_fn_search_context
= NULL
;
3972 vim_findfirst(path
, filename
, level
)
3977 ff_fn_search_context
=
3978 vim_findfile_init(path
, filename
, NULL
, level
, TRUE
, FALSE
,
3979 ff_fn_search_context
, rel_fname
);
3980 if (NULL
== ff_fn_search_context
)
3983 return vim_findnext()
3989 char_u
*ret
= vim_findfile(ff_fn_search_context
);
3993 vim_findfile_cleanup(ff_fn_search_context
);
3994 ff_fn_search_context
= NULL
;
4001 * Initialization routine for vim_findfile.
4003 * Returns the newly allocated search context or NULL if an error occured.
4005 * Don't forget to clean up by calling vim_findfile_cleanup() if you are done
4006 * with the search context.
4008 * Find the file 'filename' in the directory 'path'.
4009 * The parameter 'path' may contain wildcards. If so only search 'level'
4010 * directories deep. The parameter 'level' is the absolute maximum and is
4011 * not related to restricts given to the '**' wildcard. If 'level' is 100
4012 * and you use '**200' vim_findfile() will stop after 100 levels.
4014 * 'filename' cannot contain wildcards! It is used as-is, no backslashes to
4015 * escape special characters.
4017 * If 'stopdirs' is not NULL and nothing is found downward, the search is
4018 * restarted on the next higher directory level. This is repeated until the
4019 * start-directory of a search is contained in 'stopdirs'. 'stopdirs' has the
4020 * format ";*<dirname>*\(;<dirname>\)*;\=$".
4022 * If the 'path' is relative, the starting dir for the search is either VIM's
4023 * current dir or if the path starts with "./" the current files dir.
4024 * If the 'path' is absolut, the starting dir is that part of the path before
4025 * the first wildcard.
4027 * Upward search is only done on the starting dir.
4029 * If 'free_visited' is TRUE the list of already visited files/directories is
4030 * cleared. Set this to FALSE if you just want to search from another
4031 * directory, but want to be sure that no directory from a previous search is
4032 * searched again. This is useful if you search for a file at different places.
4033 * The list of visited files/dirs can also be cleared with the function
4034 * vim_findfile_free_visited().
4036 * Set the parameter 'find_what' to FINDFILE_DIR if you want to search for
4037 * directories only, FINDFILE_FILE for files only, FINDFILE_BOTH for both.
4039 * A search context returned by a previous call to vim_findfile_init() can be
4040 * passed in the parameter "search_ctx_arg". This context is reused and
4041 * reinitialized with the new parameters. The list of already visited
4042 * directories from this context is only deleted if the parameter
4043 * "free_visited" is true. Be aware that the passed "search_ctx_arg" is freed
4044 * if the reinitialization fails.
4046 * If you don't have a search context from a previous call "search_ctx_arg"
4049 * This function silently ignores a few errors, vim_findfile() will have
4050 * limited functionality then.
4053 vim_findfile_init(path
, filename
, stopdirs
, level
, free_visited
, find_what
,
4054 search_ctx_arg
, tagfile
, rel_fname
)
4057 char_u
*stopdirs UNUSED
;
4061 void *search_ctx_arg
;
4063 char_u
*rel_fname
; /* file name to use for "." */
4065 #ifdef FEAT_PATH_EXTRA
4069 ff_search_ctx_T
*search_ctx
;
4071 /* If a search context is given by the caller, reuse it, else allocate a
4074 if (search_ctx_arg
!= NULL
)
4075 search_ctx
= search_ctx_arg
;
4078 search_ctx
= (ff_search_ctx_T
*)alloc((unsigned)sizeof(ff_search_ctx_T
));
4079 if (search_ctx
== NULL
)
4081 memset(search_ctx
, 0, sizeof(ff_search_ctx_T
));
4083 search_ctx
->ffsc_find_what
= find_what
;
4085 /* clear the search context, but NOT the visited lists */
4086 ff_clear(search_ctx
);
4088 /* clear visited list if wanted */
4089 if (free_visited
== TRUE
)
4090 vim_findfile_free_visited(search_ctx
);
4093 /* Reuse old visited lists. Get the visited list for the given
4094 * filename. If no list for the current filename exists, creates a new
4096 search_ctx
->ffsc_visited_list
= ff_get_visited_list(filename
,
4097 &search_ctx
->ffsc_visited_lists_list
);
4098 if (search_ctx
->ffsc_visited_list
== NULL
)
4100 search_ctx
->ffsc_dir_visited_list
= ff_get_visited_list(filename
,
4101 &search_ctx
->ffsc_dir_visited_lists_list
);
4102 if (search_ctx
->ffsc_dir_visited_list
== NULL
)
4106 if (ff_expand_buffer
== NULL
)
4108 ff_expand_buffer
= (char_u
*)alloc(MAXPATHL
);
4109 if (ff_expand_buffer
== NULL
)
4113 /* Store information on starting dir now if path is relative.
4114 * If path is absolute, we do that later. */
4116 && (vim_ispathsep(path
[1]) || path
[1] == NUL
)
4117 && (!tagfile
|| vim_strchr(p_cpo
, CPO_DOTTAG
) == NULL
)
4118 && rel_fname
!= NULL
)
4120 int len
= (int)(gettail(rel_fname
) - rel_fname
);
4122 if (!vim_isAbsName(rel_fname
) && len
+ 1 < MAXPATHL
)
4124 /* Make the start dir an absolute path name. */
4125 vim_strncpy(ff_expand_buffer
, rel_fname
, len
);
4126 search_ctx
->ffsc_start_dir
= FullName_save(ff_expand_buffer
, FALSE
);
4129 search_ctx
->ffsc_start_dir
= vim_strnsave(rel_fname
, len
);
4130 if (search_ctx
->ffsc_start_dir
== NULL
)
4135 else if (*path
== NUL
|| !vim_isAbsName(path
))
4137 #ifdef BACKSLASH_IN_FILENAME
4138 /* "c:dir" needs "c:" to be expanded, otherwise use current dir */
4139 if (*path
!= NUL
&& path
[1] == ':')
4146 if (vim_FullName(drive
, ff_expand_buffer
, MAXPATHL
, TRUE
) == FAIL
)
4152 if (mch_dirname(ff_expand_buffer
, MAXPATHL
) == FAIL
)
4155 search_ctx
->ffsc_start_dir
= vim_strsave(ff_expand_buffer
);
4156 if (search_ctx
->ffsc_start_dir
== NULL
)
4159 #ifdef BACKSLASH_IN_FILENAME
4160 /* A path that starts with "/dir" is relative to the drive, not to the
4161 * directory (but not for "//machine/dir"). Only use the drive name. */
4162 if ((*path
== '/' || *path
== '\\')
4163 && path
[1] != path
[0]
4164 && search_ctx
->ffsc_start_dir
[1] == ':')
4165 search_ctx
->ffsc_start_dir
[2] = NUL
;
4169 #ifdef FEAT_PATH_EXTRA
4171 * If stopdirs are given, split them into an array of pointers.
4172 * If this fails (mem allocation), there is no upward search at all or a
4173 * stop directory is not recognized -> continue silently.
4174 * If stopdirs just contains a ";" or is empty,
4175 * search_ctx->ffsc_stopdirs_v will only contain a NULL pointer. This
4176 * is handled as unlimited upward search. See function
4177 * ff_path_in_stoplist() for details.
4179 if (stopdirs
!= NULL
)
4181 char_u
*walker
= stopdirs
;
4184 while (*walker
== ';')
4188 search_ctx
->ffsc_stopdirs_v
=
4189 (char_u
**)alloc((unsigned)sizeof(char_u
*));
4191 if (search_ctx
->ffsc_stopdirs_v
!= NULL
)
4199 ptr
= vim_realloc(search_ctx
->ffsc_stopdirs_v
,
4200 (dircount
+ 1) * sizeof(char_u
*));
4202 search_ctx
->ffsc_stopdirs_v
= ptr
;
4204 /* ignore, keep what we have and continue */
4206 walker
= vim_strchr(walker
, ';');
4209 search_ctx
->ffsc_stopdirs_v
[dircount
-1] =
4210 vim_strnsave(helper
, (int)(walker
- helper
));
4214 /* this might be "", which means ascent till top
4215 * of directory tree.
4217 search_ctx
->ffsc_stopdirs_v
[dircount
-1] =
4218 vim_strsave(helper
);
4222 } while (walker
!= NULL
);
4223 search_ctx
->ffsc_stopdirs_v
[dircount
-1] = NULL
;
4228 #ifdef FEAT_PATH_EXTRA
4229 search_ctx
->ffsc_level
= level
;
4233 * -wildcard_stuff (might be NULL)
4235 wc_part
= vim_strchr(path
, '*');
4236 if (wc_part
!= NULL
)
4242 /* save the fix part of the path */
4243 search_ctx
->ffsc_fix_path
= vim_strnsave(path
, (int)(wc_part
- path
));
4246 * copy wc_path and add restricts to the '**' wildcard.
4247 * The octet after a '**' is used as a (binary) counter.
4248 * So '**3' is transposed to '**^C' ('^C' is ASCII value 3)
4249 * or '**76' is transposed to '**N'( 'N' is ASCII value 76).
4250 * For EBCDIC you get different character values.
4251 * If no restrict is given after '**' the default is used.
4252 * Due to this technique the path looks awful if you print it as a
4256 while (*wc_part
!= NUL
)
4258 if (STRNCMP(wc_part
, "**", 2) == 0)
4260 ff_expand_buffer
[len
++] = *wc_part
++;
4261 ff_expand_buffer
[len
++] = *wc_part
++;
4263 llevel
= strtol((char *)wc_part
, &errpt
, 10);
4264 if ((char_u
*)errpt
!= wc_part
&& llevel
> 0 && llevel
< 255)
4265 ff_expand_buffer
[len
++] = llevel
;
4266 else if ((char_u
*)errpt
!= wc_part
&& llevel
== 0)
4267 /* restrict is 0 -> remove already added '**' */
4270 ff_expand_buffer
[len
++] = FF_MAX_STAR_STAR_EXPAND
;
4271 wc_part
= (char_u
*)errpt
;
4272 if (*wc_part
!= NUL
&& !vim_ispathsep(*wc_part
))
4274 EMSG2(_("E343: Invalid path: '**[number]' must be at the end of the path or be followed by '%s'."), PATHSEPSTR
);
4279 ff_expand_buffer
[len
++] = *wc_part
++;
4281 ff_expand_buffer
[len
] = NUL
;
4282 search_ctx
->ffsc_wc_path
= vim_strsave(ff_expand_buffer
);
4284 if (search_ctx
->ffsc_wc_path
== NULL
)
4289 search_ctx
->ffsc_fix_path
= vim_strsave(path
);
4291 if (search_ctx
->ffsc_start_dir
== NULL
)
4293 /* store the fix part as startdir.
4294 * This is needed if the parameter path is fully qualified.
4296 search_ctx
->ffsc_start_dir
= vim_strsave(search_ctx
->ffsc_fix_path
);
4297 if (search_ctx
->ffsc_start_dir
)
4298 search_ctx
->ffsc_fix_path
[0] = NUL
;
4301 /* create an absolute path */
4302 STRCPY(ff_expand_buffer
, search_ctx
->ffsc_start_dir
);
4303 add_pathsep(ff_expand_buffer
);
4304 STRCAT(ff_expand_buffer
, search_ctx
->ffsc_fix_path
);
4305 add_pathsep(ff_expand_buffer
);
4307 sptr
= ff_create_stack_element(ff_expand_buffer
,
4308 #ifdef FEAT_PATH_EXTRA
4309 search_ctx
->ffsc_wc_path
,
4316 ff_push(search_ctx
, sptr
);
4318 search_ctx
->ffsc_file_to_search
= vim_strsave(filename
);
4319 if (search_ctx
->ffsc_file_to_search
== NULL
)
4326 * We clear the search context now!
4327 * Even when the caller gave us a (perhaps valid) context we free it here,
4328 * as we might have already destroyed it.
4330 vim_findfile_cleanup(search_ctx
);
4334 #if defined(FEAT_PATH_EXTRA) || defined(PROTO)
4336 * Get the stopdir string. Check that ';' is not escaped.
4339 vim_findfile_stopdir(buf
)
4342 char_u
*r_ptr
= buf
;
4344 while (*r_ptr
!= NUL
&& *r_ptr
!= ';')
4346 if (r_ptr
[0] == '\\' && r_ptr
[1] == ';')
4348 /* overwrite the escape char,
4349 * use STRLEN(r_ptr) to move the trailing '\0'
4351 STRMOVE(r_ptr
, r_ptr
+ 1);
4361 else if (*r_ptr
== NUL
)
4368 * Clean up the given search context. Can handle a NULL pointer.
4371 vim_findfile_cleanup(ctx
)
4377 vim_findfile_free_visited(ctx
);
4383 * Find a file in a search context.
4384 * The search context was created with vim_findfile_init() above.
4385 * Return a pointer to an allocated file name or NULL if nothing found.
4386 * To get all matching files call this function until you get NULL.
4388 * If the passed search_context is NULL, NULL is returned.
4390 * The search algorithm is depth first. To change this replace the
4391 * stack with a list (don't forget to leave partly searched directories on the
4395 vim_findfile(search_ctx_arg
)
4396 void *search_ctx_arg
;
4399 #ifdef FEAT_PATH_EXTRA
4400 char_u
*rest_of_wildcards
;
4401 char_u
*path_end
= NULL
;
4404 #if defined(FEAT_SEARCHPATH) || defined(FEAT_PATH_EXTRA)
4409 #ifdef FEAT_SEARCHPATH
4412 ff_search_ctx_T
*search_ctx
;
4414 if (search_ctx_arg
== NULL
)
4417 search_ctx
= (ff_search_ctx_T
*)search_ctx_arg
;
4420 * filepath is used as buffer for various actions and as the storage to
4421 * return a found filename.
4423 if ((file_path
= alloc((int)MAXPATHL
)) == NULL
)
4426 #ifdef FEAT_PATH_EXTRA
4427 /* store the end of the start dir -- needed for upward search */
4428 if (search_ctx
->ffsc_start_dir
!= NULL
)
4429 path_end
= &search_ctx
->ffsc_start_dir
[
4430 STRLEN(search_ctx
->ffsc_start_dir
)];
4433 #ifdef FEAT_PATH_EXTRA
4434 /* upward search loop */
4438 /* downward search loop */
4441 /* check if user user wants to stop the search*/
4446 /* get directory to work on from stack */
4447 stackp
= ff_pop(search_ctx
);
4452 * TODO: decide if we leave this test in
4454 * GOOD: don't search a directory(-tree) twice.
4455 * BAD: - check linked list for every new directory entered.
4456 * - check for double files also done below
4458 * Here we check if we already searched this directory.
4459 * We already searched a directory if:
4460 * 1) The directory is the same.
4461 * 2) We would use the same wildcard string.
4463 * Good if you have links on same directory via several ways
4464 * or you have selfreferences in directories (e.g. SuSE Linux 6.3:
4465 * /etc/rc.d/init.d is linked to /etc/rc.d -> endless loop)
4467 * This check is only needed for directories we work on for the
4468 * first time (hence stackp->ff_filearray == NULL)
4470 if (stackp
->ffs_filearray
== NULL
4471 && ff_check_visited(&search_ctx
->ffsc_dir_visited_list
4472 ->ffvl_visited_list
,
4473 stackp
->ffs_fix_path
4474 #ifdef FEAT_PATH_EXTRA
4475 , stackp
->ffs_wc_path
4482 verbose_enter_scroll();
4483 smsg((char_u
*)"Already Searched: %s (%s)",
4484 stackp
->ffs_fix_path
, stackp
->ffs_wc_path
);
4485 /* don't overwrite this either */
4486 msg_puts((char_u
*)"\n");
4487 verbose_leave_scroll();
4490 ff_free_stack_element(stackp
);
4494 else if (p_verbose
>= 5)
4496 verbose_enter_scroll();
4497 smsg((char_u
*)"Searching: %s (%s)",
4498 stackp
->ffs_fix_path
, stackp
->ffs_wc_path
);
4499 /* don't overwrite this either */
4500 msg_puts((char_u
*)"\n");
4501 verbose_leave_scroll();
4506 if (stackp
->ffs_level
<= 0)
4508 ff_free_stack_element(stackp
);
4515 * If no filearray till now expand wildcards
4516 * The function expand_wildcards() can handle an array of paths
4517 * and all possible expands are returned in one array. We use this
4518 * to handle the expansion of '**' into an empty string.
4520 if (stackp
->ffs_filearray
== NULL
)
4524 /* we use filepath to build the path expand_wildcards() should
4527 dirptrs
[0] = file_path
;
4530 /* if we have a start dir copy it in */
4531 if (!vim_isAbsName(stackp
->ffs_fix_path
)
4532 && search_ctx
->ffsc_start_dir
)
4534 STRCPY(file_path
, search_ctx
->ffsc_start_dir
);
4535 add_pathsep(file_path
);
4538 /* append the fix part of the search path */
4539 STRCAT(file_path
, stackp
->ffs_fix_path
);
4540 add_pathsep(file_path
);
4542 #ifdef FEAT_PATH_EXTRA
4543 rest_of_wildcards
= stackp
->ffs_wc_path
;
4544 if (*rest_of_wildcards
!= NUL
)
4546 len
= (int)STRLEN(file_path
);
4547 if (STRNCMP(rest_of_wildcards
, "**", 2) == 0)
4549 /* pointer to the restrict byte
4550 * The restrict byte is not a character!
4552 p
= rest_of_wildcards
+ 2;
4557 file_path
[len
++] = '*';
4562 /* remove '**<numb> from wildcards */
4563 STRMOVE(rest_of_wildcards
, rest_of_wildcards
+ 3);
4566 rest_of_wildcards
+= 3;
4568 if (stackp
->ffs_star_star_empty
== 0)
4570 /* if not done before, expand '**' to empty */
4571 stackp
->ffs_star_star_empty
= 1;
4572 dirptrs
[1] = stackp
->ffs_fix_path
;
4577 * Here we copy until the next path separator or the end of
4578 * the path. If we stop at a path separator, there is
4579 * still something else left. This is handled below by
4580 * pushing every directory returned from expand_wildcards()
4581 * on the stack again for further search.
4583 while (*rest_of_wildcards
4584 && !vim_ispathsep(*rest_of_wildcards
))
4585 file_path
[len
++] = *rest_of_wildcards
++;
4587 file_path
[len
] = NUL
;
4588 if (vim_ispathsep(*rest_of_wildcards
))
4589 rest_of_wildcards
++;
4594 * Expand wildcards like "*" and "$VAR".
4595 * If the path is a URL don't try this.
4597 if (path_with_url(dirptrs
[0]))
4599 stackp
->ffs_filearray
= (char_u
**)
4600 alloc((unsigned)sizeof(char *));
4601 if (stackp
->ffs_filearray
!= NULL
4602 && (stackp
->ffs_filearray
[0]
4603 = vim_strsave(dirptrs
[0])) != NULL
)
4604 stackp
->ffs_filearray_size
= 1;
4606 stackp
->ffs_filearray_size
= 0;
4609 expand_wildcards((dirptrs
[1] == NULL
) ? 1 : 2, dirptrs
,
4610 &stackp
->ffs_filearray_size
,
4611 &stackp
->ffs_filearray
,
4612 EW_DIR
|EW_ADDSLASH
|EW_SILENT
);
4614 stackp
->ffs_filearray_cur
= 0;
4615 stackp
->ffs_stage
= 0;
4617 #ifdef FEAT_PATH_EXTRA
4619 rest_of_wildcards
= &stackp
->ffs_wc_path
[
4620 STRLEN(stackp
->ffs_wc_path
)];
4623 if (stackp
->ffs_stage
== 0)
4625 /* this is the first time we work on this directory */
4626 #ifdef FEAT_PATH_EXTRA
4627 if (*rest_of_wildcards
== NUL
)
4631 * we don't have further wildcards to expand, so we have to
4632 * check for the final file now
4634 for (i
= stackp
->ffs_filearray_cur
;
4635 i
< stackp
->ffs_filearray_size
; ++i
)
4637 if (!path_with_url(stackp
->ffs_filearray
[i
])
4638 && !mch_isdir(stackp
->ffs_filearray
[i
]))
4639 continue; /* not a directory */
4641 /* prepare the filename to be checked for existence
4643 STRCPY(file_path
, stackp
->ffs_filearray
[i
]);
4644 add_pathsep(file_path
);
4645 STRCAT(file_path
, search_ctx
->ffsc_file_to_search
);
4648 * Try without extra suffix and then with suffixes
4649 * from 'suffixesadd'.
4651 #ifdef FEAT_SEARCHPATH
4652 len
= (int)STRLEN(file_path
);
4653 suf
= curbuf
->b_p_sua
;
4657 /* if file exists and we didn't already find it */
4658 if ((path_with_url(file_path
)
4659 || (mch_getperm(file_path
) >= 0
4660 && (search_ctx
->ffsc_find_what
4662 || ((search_ctx
->ffsc_find_what
4664 == mch_isdir(file_path
)))))
4666 && (ff_check_visited(
4667 &search_ctx
->ffsc_visited_list
->ffvl_visited_list
,
4669 #ifdef FEAT_PATH_EXTRA
4677 if (ff_check_visited(
4678 &search_ctx
->ffsc_visited_list
->ffvl_visited_list
,
4680 #ifdef FEAT_PATH_EXTRA
4687 verbose_enter_scroll();
4688 smsg((char_u
*)"Already: %s",
4690 /* don't overwrite this either */
4691 msg_puts((char_u
*)"\n");
4692 verbose_leave_scroll();
4698 /* push dir to examine rest of subdirs later */
4699 stackp
->ffs_filearray_cur
= i
+ 1;
4700 ff_push(search_ctx
, stackp
);
4702 if (!path_with_url(file_path
))
4703 simplify_filename(file_path
);
4704 if (mch_dirname(ff_expand_buffer
, MAXPATHL
)
4707 p
= shorten_fname(file_path
,
4710 STRMOVE(file_path
, p
);
4715 verbose_enter_scroll();
4716 smsg((char_u
*)"HIT: %s", file_path
);
4717 /* don't overwrite this either */
4718 msg_puts((char_u
*)"\n");
4719 verbose_leave_scroll();
4725 #ifdef FEAT_SEARCHPATH
4726 /* Not found or found already, try next suffix. */
4729 copy_option_part(&suf
, file_path
+ len
,
4730 MAXPATHL
- len
, ",");
4735 #ifdef FEAT_PATH_EXTRA
4739 * still wildcards left, push the directories for further
4742 for (i
= stackp
->ffs_filearray_cur
;
4743 i
< stackp
->ffs_filearray_size
; ++i
)
4745 if (!mch_isdir(stackp
->ffs_filearray
[i
]))
4746 continue; /* not a directory */
4749 ff_create_stack_element(
4750 stackp
->ffs_filearray
[i
],
4752 stackp
->ffs_level
- 1, 0));
4756 stackp
->ffs_filearray_cur
= 0;
4757 stackp
->ffs_stage
= 1;
4760 #ifdef FEAT_PATH_EXTRA
4762 * if wildcards contains '**' we have to descent till we reach the
4763 * leaves of the directory tree.
4765 if (STRNCMP(stackp
->ffs_wc_path
, "**", 2) == 0)
4767 for (i
= stackp
->ffs_filearray_cur
;
4768 i
< stackp
->ffs_filearray_size
; ++i
)
4770 if (fnamecmp(stackp
->ffs_filearray
[i
],
4771 stackp
->ffs_fix_path
) == 0)
4772 continue; /* don't repush same directory */
4773 if (!mch_isdir(stackp
->ffs_filearray
[i
]))
4774 continue; /* not a directory */
4776 ff_create_stack_element(stackp
->ffs_filearray
[i
],
4777 stackp
->ffs_wc_path
, stackp
->ffs_level
- 1, 1));
4782 /* we are done with the current directory */
4783 ff_free_stack_element(stackp
);
4787 #ifdef FEAT_PATH_EXTRA
4788 /* If we reached this, we didn't find anything downwards.
4789 * Let's check if we should do an upward search.
4791 if (search_ctx
->ffsc_start_dir
4792 && search_ctx
->ffsc_stopdirs_v
!= NULL
&& !got_int
)
4796 /* is the last starting directory in the stop list? */
4797 if (ff_path_in_stoplist(search_ctx
->ffsc_start_dir
,
4798 (int)(path_end
- search_ctx
->ffsc_start_dir
),
4799 search_ctx
->ffsc_stopdirs_v
) == TRUE
)
4802 /* cut of last dir */
4803 while (path_end
> search_ctx
->ffsc_start_dir
4804 && vim_ispathsep(*path_end
))
4806 while (path_end
> search_ctx
->ffsc_start_dir
4807 && !vim_ispathsep(path_end
[-1]))
4812 if (*search_ctx
->ffsc_start_dir
== 0)
4815 STRCPY(file_path
, search_ctx
->ffsc_start_dir
);
4816 add_pathsep(file_path
);
4817 STRCAT(file_path
, search_ctx
->ffsc_fix_path
);
4819 /* create a new stack entry */
4820 sptr
= ff_create_stack_element(file_path
,
4821 search_ctx
->ffsc_wc_path
, search_ctx
->ffsc_level
, 0);
4824 ff_push(search_ctx
, sptr
);
4831 vim_free(file_path
);
4836 * Free the list of lists of visited files and directories
4837 * Can handle it if the passed search_context is NULL;
4840 vim_findfile_free_visited(search_ctx_arg
)
4841 void *search_ctx_arg
;
4843 ff_search_ctx_T
*search_ctx
;
4845 if (search_ctx_arg
== NULL
)
4848 search_ctx
= (ff_search_ctx_T
*)search_ctx_arg
;
4849 vim_findfile_free_visited_list(&search_ctx
->ffsc_visited_lists_list
);
4850 vim_findfile_free_visited_list(&search_ctx
->ffsc_dir_visited_lists_list
);
4854 vim_findfile_free_visited_list(list_headp
)
4855 ff_visited_list_hdr_T
**list_headp
;
4857 ff_visited_list_hdr_T
*vp
;
4859 while (*list_headp
!= NULL
)
4861 vp
= (*list_headp
)->ffvl_next
;
4862 ff_free_visited_list((*list_headp
)->ffvl_visited_list
);
4864 vim_free((*list_headp
)->ffvl_filename
);
4865 vim_free(*list_headp
);
4872 ff_free_visited_list(vl
)
4880 #ifdef FEAT_PATH_EXTRA
4881 vim_free(vl
->ffv_wc_path
);
4890 * Returns the already visited list for the given filename. If none is found it
4891 * allocates a new one.
4893 static ff_visited_list_hdr_T
*
4894 ff_get_visited_list(filename
, list_headp
)
4896 ff_visited_list_hdr_T
**list_headp
;
4898 ff_visited_list_hdr_T
*retptr
= NULL
;
4900 /* check if a visited list for the given filename exists */
4901 if (*list_headp
!= NULL
)
4903 retptr
= *list_headp
;
4904 while (retptr
!= NULL
)
4906 if (fnamecmp(filename
, retptr
->ffvl_filename
) == 0)
4911 verbose_enter_scroll();
4912 smsg((char_u
*)"ff_get_visited_list: FOUND list for %s",
4914 /* don't overwrite this either */
4915 msg_puts((char_u
*)"\n");
4916 verbose_leave_scroll();
4921 retptr
= retptr
->ffvl_next
;
4928 verbose_enter_scroll();
4929 smsg((char_u
*)"ff_get_visited_list: new list for %s", filename
);
4930 /* don't overwrite this either */
4931 msg_puts((char_u
*)"\n");
4932 verbose_leave_scroll();
4937 * if we reach this we didn't find a list and we have to allocate new list
4939 retptr
= (ff_visited_list_hdr_T
*)alloc((unsigned)sizeof(*retptr
));
4943 retptr
->ffvl_visited_list
= NULL
;
4944 retptr
->ffvl_filename
= vim_strsave(filename
);
4945 if (retptr
->ffvl_filename
== NULL
)
4950 retptr
->ffvl_next
= *list_headp
;
4951 *list_headp
= retptr
;
4956 #ifdef FEAT_PATH_EXTRA
4958 * check if two wildcard paths are equal. Returns TRUE or FALSE.
4959 * They are equal if:
4960 * - both paths are NULL
4961 * - they have the same length
4962 * - char by char comparison is OK
4963 * - the only differences are in the counters behind a '**', so
4964 * '**\20' is equal to '**\24'
4976 if (s1
== NULL
|| s2
== NULL
)
4979 if (STRLEN(s1
) != STRLEN(s2
))
4982 for (i
= 0; s1
[i
] != NUL
&& s2
[i
] != NUL
; i
++)
4985 #ifdef CASE_INSENSITIVE_FILENAME
4986 && TOUPPER_LOC(s1
[i
]) != TOUPPER_LOC(s2
[i
])
4991 if (s1
[i
-1] == '*' && s1
[i
-2] == '*')
5004 * maintains the list of already visited files and dirs
5005 * returns FAIL if the given file/dir is already in the list
5006 * returns OK if it is newly added
5008 * TODO: What to do on memory allocation problems?
5009 * -> return TRUE - Better the file is found several times instead of
5013 ff_check_visited(visited_list
, fname
5014 #ifdef FEAT_PATH_EXTRA
5018 ff_visited_T
**visited_list
;
5020 #ifdef FEAT_PATH_EXTRA
5030 /* For an URL we only compare the name, otherwise we compare the
5031 * device/inode (unix) or the full path name (not Unix). */
5032 if (path_with_url(fname
))
5034 vim_strncpy(ff_expand_buffer
, fname
, MAXPATHL
- 1);
5041 ff_expand_buffer
[0] = NUL
;
5043 if (mch_stat((char *)fname
, &st
) < 0)
5045 if (vim_FullName(fname
, ff_expand_buffer
, MAXPATHL
, TRUE
) == FAIL
)
5050 /* check against list of already visited files */
5051 for (vp
= *visited_list
; vp
!= NULL
; vp
= vp
->ffv_next
)
5055 !url
? (vp
->ffv_dev_valid
&& vp
->ffv_dev
== st
.st_dev
5056 && vp
->ffv_ino
== st
.st_ino
)
5059 fnamecmp(vp
->ffv_fname
, ff_expand_buffer
) == 0
5062 #ifdef FEAT_PATH_EXTRA
5063 /* are the wildcard parts equal */
5064 if (ff_wc_equal(vp
->ffv_wc_path
, wc_path
) == TRUE
)
5066 /* already visited */
5072 * New file/dir. Add it to the list of visited files/dirs.
5074 vp
= (ff_visited_T
*)alloc((unsigned)(sizeof(ff_visited_T
)
5075 + STRLEN(ff_expand_buffer
)));
5082 vp
->ffv_dev_valid
= TRUE
;
5083 vp
->ffv_ino
= st
.st_ino
;
5084 vp
->ffv_dev
= st
.st_dev
;
5085 vp
->ffv_fname
[0] = NUL
;
5089 vp
->ffv_dev_valid
= FALSE
;
5091 STRCPY(vp
->ffv_fname
, ff_expand_buffer
);
5095 #ifdef FEAT_PATH_EXTRA
5096 if (wc_path
!= NULL
)
5097 vp
->ffv_wc_path
= vim_strsave(wc_path
);
5099 vp
->ffv_wc_path
= NULL
;
5102 vp
->ffv_next
= *visited_list
;
5110 * create stack element from given path pieces
5113 ff_create_stack_element(fix_part
,
5114 #ifdef FEAT_PATH_EXTRA
5117 level
, star_star_empty
)
5119 #ifdef FEAT_PATH_EXTRA
5123 int star_star_empty
;
5127 new = (ff_stack_T
*)alloc((unsigned)sizeof(ff_stack_T
));
5131 new->ffs_prev
= NULL
;
5132 new->ffs_filearray
= NULL
;
5133 new->ffs_filearray_size
= 0;
5134 new->ffs_filearray_cur
= 0;
5136 new->ffs_level
= level
;
5137 new->ffs_star_star_empty
= star_star_empty
;;
5139 /* the following saves NULL pointer checks in vim_findfile */
5140 if (fix_part
== NULL
)
5141 fix_part
= (char_u
*)"";
5142 new->ffs_fix_path
= vim_strsave(fix_part
);
5144 #ifdef FEAT_PATH_EXTRA
5145 if (wc_part
== NULL
)
5146 wc_part
= (char_u
*)"";
5147 new->ffs_wc_path
= vim_strsave(wc_part
);
5150 if (new->ffs_fix_path
== NULL
5151 #ifdef FEAT_PATH_EXTRA
5152 || new->ffs_wc_path
== NULL
5156 ff_free_stack_element(new);
5164 * Push a dir on the directory stack.
5167 ff_push(search_ctx
, stack_ptr
)
5168 ff_search_ctx_T
*search_ctx
;
5169 ff_stack_T
*stack_ptr
;
5171 /* check for NULL pointer, not to return an error to the user, but
5172 * to prevent a crash */
5173 if (stack_ptr
!= NULL
)
5175 stack_ptr
->ffs_prev
= search_ctx
->ffsc_stack_ptr
;
5176 search_ctx
->ffsc_stack_ptr
= stack_ptr
;
5181 * Pop a dir from the directory stack.
5182 * Returns NULL if stack is empty.
5186 ff_search_ctx_T
*search_ctx
;
5190 sptr
= search_ctx
->ffsc_stack_ptr
;
5191 if (search_ctx
->ffsc_stack_ptr
!= NULL
)
5192 search_ctx
->ffsc_stack_ptr
= search_ctx
->ffsc_stack_ptr
->ffs_prev
;
5198 * free the given stack element
5201 ff_free_stack_element(stack_ptr
)
5202 ff_stack_T
*stack_ptr
;
5204 /* vim_free handles possible NULL pointers */
5205 vim_free(stack_ptr
->ffs_fix_path
);
5206 #ifdef FEAT_PATH_EXTRA
5207 vim_free(stack_ptr
->ffs_wc_path
);
5210 if (stack_ptr
->ffs_filearray
!= NULL
)
5211 FreeWild(stack_ptr
->ffs_filearray_size
, stack_ptr
->ffs_filearray
);
5213 vim_free(stack_ptr
);
5217 * Clear the search context, but NOT the visited list.
5220 ff_clear(search_ctx
)
5221 ff_search_ctx_T
*search_ctx
;
5225 /* clear up stack */
5226 while ((sptr
= ff_pop(search_ctx
)) != NULL
)
5227 ff_free_stack_element(sptr
);
5229 vim_free(search_ctx
->ffsc_file_to_search
);
5230 vim_free(search_ctx
->ffsc_start_dir
);
5231 vim_free(search_ctx
->ffsc_fix_path
);
5232 #ifdef FEAT_PATH_EXTRA
5233 vim_free(search_ctx
->ffsc_wc_path
);
5236 #ifdef FEAT_PATH_EXTRA
5237 if (search_ctx
->ffsc_stopdirs_v
!= NULL
)
5241 while (search_ctx
->ffsc_stopdirs_v
[i
] != NULL
)
5243 vim_free(search_ctx
->ffsc_stopdirs_v
[i
]);
5246 vim_free(search_ctx
->ffsc_stopdirs_v
);
5248 search_ctx
->ffsc_stopdirs_v
= NULL
;
5251 /* reset everything */
5252 search_ctx
->ffsc_file_to_search
= NULL
;
5253 search_ctx
->ffsc_start_dir
= NULL
;
5254 search_ctx
->ffsc_fix_path
= NULL
;
5255 #ifdef FEAT_PATH_EXTRA
5256 search_ctx
->ffsc_wc_path
= NULL
;
5257 search_ctx
->ffsc_level
= 0;
5261 #ifdef FEAT_PATH_EXTRA
5263 * check if the given path is in the stopdirs
5264 * returns TRUE if yes else FALSE
5267 ff_path_in_stoplist(path
, path_len
, stopdirs_v
)
5270 char_u
**stopdirs_v
;
5274 /* eat up trailing path separators, except the first */
5275 while (path_len
> 1 && vim_ispathsep(path
[path_len
- 1]))
5278 /* if no path consider it as match */
5282 for (i
= 0; stopdirs_v
[i
] != NULL
; i
++)
5284 if ((int)STRLEN(stopdirs_v
[i
]) > path_len
)
5286 /* match for parent directory. So '/home' also matches
5287 * '/home/rks'. Check for PATHSEP in stopdirs_v[i], else
5288 * '/home/r' would also match '/home/rks'
5290 if (fnamencmp(stopdirs_v
[i
], path
, path_len
) == 0
5291 && vim_ispathsep(stopdirs_v
[i
][path_len
]))
5296 if (fnamecmp(stopdirs_v
[i
], path
) == 0)
5304 #if defined(FEAT_SEARCHPATH) || defined(PROTO)
5306 * Find the file name "ptr[len]" in the path. Also finds directory names.
5308 * On the first call set the parameter 'first' to TRUE to initialize
5309 * the search. For repeating calls to FALSE.
5311 * Repeating calls will return other files called 'ptr[len]' from the path.
5313 * Only on the first call 'ptr' and 'len' are used. For repeating calls they
5314 * don't need valid values.
5316 * If nothing found on the first call the option FNAME_MESS will issue the
5318 * 'Can't find file "<file>" in path'
5319 * On repeating calls:
5320 * 'No more file "<file>" found in path'
5323 * FNAME_MESS give error message when not found
5327 * Returns an allocated string for the file name. NULL for error.
5331 find_file_in_path(ptr
, len
, options
, first
, rel_fname
)
5332 char_u
*ptr
; /* file name */
5333 int len
; /* length of file name */
5335 int first
; /* use count'th matching file name */
5336 char_u
*rel_fname
; /* file name searching relative to */
5338 return find_file_in_path_option(ptr
, len
, options
, first
,
5339 *curbuf
->b_p_path
== NUL
? p_path
: curbuf
->b_p_path
,
5340 FINDFILE_BOTH
, rel_fname
, curbuf
->b_p_sua
);
5343 static char_u
*ff_file_to_find
= NULL
;
5344 static void *fdip_search_ctx
= NULL
;
5346 #if defined(EXITFREE)
5350 vim_free(ff_file_to_find
);
5351 vim_findfile_cleanup(fdip_search_ctx
);
5356 * Find the directory name "ptr[len]" in the path.
5359 * FNAME_MESS give error message when not found
5363 * Returns an allocated string for the file name. NULL for error.
5366 find_directory_in_path(ptr
, len
, options
, rel_fname
)
5367 char_u
*ptr
; /* file name */
5368 int len
; /* length of file name */
5370 char_u
*rel_fname
; /* file name searching relative to */
5372 return find_file_in_path_option(ptr
, len
, options
, TRUE
, p_cdpath
,
5373 FINDFILE_DIR
, rel_fname
, (char_u
*)"");
5377 find_file_in_path_option(ptr
, len
, options
, first
, path_option
, find_what
, rel_fname
, suffixes
)
5378 char_u
*ptr
; /* file name */
5379 int len
; /* length of file name */
5381 int first
; /* use count'th matching file name */
5382 char_u
*path_option
; /* p_path or p_cdpath */
5383 int find_what
; /* FINDFILE_FILE, _DIR or _BOTH */
5384 char_u
*rel_fname
; /* file name we are looking relative to. */
5385 char_u
*suffixes
; /* list of suffixes, 'suffixesadd' option */
5388 static int did_findfile_init
= FALSE
;
5390 char_u
*file_name
= NULL
;
5394 struct Process
*proc
= (struct Process
*)FindTask(0L);
5395 APTR save_winptr
= proc
->pr_WindowPtr
;
5397 /* Avoid a requester here for a volume that doesn't exist. */
5398 proc
->pr_WindowPtr
= (APTR
)-1L;
5403 /* copy file name into NameBuff, expanding environment variables */
5404 save_char
= ptr
[len
];
5406 expand_env(ptr
, NameBuff
, MAXPATHL
);
5407 ptr
[len
] = save_char
;
5409 vim_free(ff_file_to_find
);
5410 ff_file_to_find
= vim_strsave(NameBuff
);
5411 if (ff_file_to_find
== NULL
) /* out of memory */
5418 rel_to_curdir
= (ff_file_to_find
[0] == '.'
5419 && (ff_file_to_find
[1] == NUL
5420 || vim_ispathsep(ff_file_to_find
[1])
5421 || (ff_file_to_find
[1] == '.'
5422 && (ff_file_to_find
[2] == NUL
5423 || vim_ispathsep(ff_file_to_find
[2])))));
5424 if (vim_isAbsName(ff_file_to_find
)
5425 /* "..", "../path", "." and "./path": don't use the path_option */
5427 #if defined(MSWIN) || defined(MSDOS) || defined(OS2)
5428 /* handle "\tmp" as absolute path */
5429 || vim_ispathsep(ff_file_to_find
[0])
5430 /* handle "c:name" as absolute path */
5431 || (ff_file_to_find
[0] != NUL
&& ff_file_to_find
[1] == ':')
5434 /* handle ":tmp" as absolute path */
5435 || ff_file_to_find
[0] == ':'
5440 * Absolute path, no need to use "path_option".
5441 * If this is not a first call, return NULL. We already returned a
5442 * filename on the first call.
5449 if (path_with_url(ff_file_to_find
))
5451 file_name
= vim_strsave(ff_file_to_find
);
5455 /* When FNAME_REL flag given first use the directory of the file.
5456 * Otherwise or when this fails use the current directory. */
5457 for (run
= 1; run
<= 2; ++run
)
5459 l
= (int)STRLEN(ff_file_to_find
);
5462 && (options
& FNAME_REL
)
5463 && rel_fname
!= NULL
5464 && STRLEN(rel_fname
) + l
< MAXPATHL
)
5466 STRCPY(NameBuff
, rel_fname
);
5467 STRCPY(gettail(NameBuff
), ff_file_to_find
);
5468 l
= (int)STRLEN(NameBuff
);
5472 STRCPY(NameBuff
, ff_file_to_find
);
5476 /* When the file doesn't exist, try adding parts of
5483 /* "C:" by itself will fail for mch_getperm(),
5484 * assume it's always valid. */
5485 (find_what
!= FINDFILE_FILE
&& NameBuff
[0] != NUL
5486 && NameBuff
[1] == ':'
5487 && NameBuff
[2] == NUL
) ||
5489 (mch_getperm(NameBuff
) >= 0
5490 && (find_what
== FINDFILE_BOTH
5491 || ((find_what
== FINDFILE_DIR
)
5492 == mch_isdir(NameBuff
)))))
5494 file_name
= vim_strsave(NameBuff
);
5499 copy_option_part(&buf
, NameBuff
+ l
, MAXPATHL
- l
, ",");
5507 * Loop over all paths in the 'path' or 'cdpath' option.
5508 * When "first" is set, first setup to the start of the option.
5509 * Otherwise continue to find the next match.
5513 /* vim_findfile_free_visited can handle a possible NULL pointer */
5514 vim_findfile_free_visited(fdip_search_ctx
);
5516 did_findfile_init
= FALSE
;
5521 if (did_findfile_init
)
5523 file_name
= vim_findfile(fdip_search_ctx
);
5524 if (file_name
!= NULL
)
5527 did_findfile_init
= FALSE
;
5533 if (dir
== NULL
|| *dir
== NUL
)
5535 /* We searched all paths of the option, now we can
5536 * free the search context. */
5537 vim_findfile_cleanup(fdip_search_ctx
);
5538 fdip_search_ctx
= NULL
;
5542 if ((buf
= alloc((int)(MAXPATHL
))) == NULL
)
5545 /* copy next path */
5547 copy_option_part(&dir
, buf
, MAXPATHL
, " ,");
5549 #ifdef FEAT_PATH_EXTRA
5550 /* get the stopdir string */
5551 r_ptr
= vim_findfile_stopdir(buf
);
5555 fdip_search_ctx
= vim_findfile_init(buf
, ff_file_to_find
,
5556 r_ptr
, 100, FALSE
, find_what
,
5557 fdip_search_ctx
, FALSE
, rel_fname
);
5558 if (fdip_search_ctx
!= NULL
)
5559 did_findfile_init
= TRUE
;
5564 if (file_name
== NULL
&& (options
& FNAME_MESS
))
5568 if (find_what
== FINDFILE_DIR
)
5569 EMSG2(_("E344: Can't find directory \"%s\" in cdpath"),
5572 EMSG2(_("E345: Can't find file \"%s\" in path"),
5577 if (find_what
== FINDFILE_DIR
)
5578 EMSG2(_("E346: No more directory \"%s\" found in cdpath"),
5581 EMSG2(_("E347: No more file \"%s\" found in path"),
5588 proc
->pr_WindowPtr
= save_winptr
;
5593 #endif /* FEAT_SEARCHPATH */
5596 * Change directory to "new_dir". If FEAT_SEARCHPATH is defined, search
5597 * 'cdpath' for relative directory names, otherwise just mch_chdir().
5603 #ifndef FEAT_SEARCHPATH
5604 return mch_chdir((char *)new_dir
);
5609 dir_name
= find_directory_in_path(new_dir
, (int)STRLEN(new_dir
),
5610 FNAME_MESS
, curbuf
->b_ffname
);
5611 if (dir_name
== NULL
)
5613 r
= mch_chdir((char *)dir_name
);
5620 * Get user name from machine-specific function.
5621 * Returns the user name in "buf[len]".
5622 * Some systems are quite slow in obtaining the user name (Windows NT), thus
5624 * Returns OK or FAIL.
5627 get_user_name(buf
, len
)
5631 if (username
== NULL
)
5633 if (mch_get_user_name(buf
, len
) == FAIL
)
5635 username
= vim_strsave(buf
);
5638 vim_strncpy(buf
, username
, len
- 1);
5644 * Our own qsort(), for systems that don't have it.
5645 * It's simple and slow. From the K&R C book.
5648 qsort(base
, elm_count
, elm_size
, cmp
)
5652 int (*cmp
) __ARGS((const void *, const void *));
5660 buf
= alloc((unsigned)elm_size
);
5664 for (gap
= elm_count
/ 2; gap
> 0; gap
/= 2)
5665 for (i
= gap
; i
< elm_count
; ++i
)
5666 for (j
= i
- gap
; j
>= 0; j
-= gap
)
5668 /* Compare the elements. */
5669 p1
= (char_u
*)base
+ j
* elm_size
;
5670 p2
= (char_u
*)base
+ (j
+ gap
) * elm_size
;
5671 if ((*cmp
)((void *)p1
, (void *)p2
) <= 0)
5673 /* Exchange the elements. */
5674 mch_memmove(buf
, p1
, elm_size
);
5675 mch_memmove(p1
, p2
, elm_size
);
5676 mch_memmove(p2
, buf
, elm_size
);
5684 * Sort an array of strings.
5690 sort_compare
__ARGS((const void *s1
, const void *s2
));
5696 sort_compare(s1
, s2
)
5700 return STRCMP(*(char **)s1
, *(char **)s2
);
5704 sort_strings(files
, count
)
5708 qsort((void *)files
, (size_t)count
, sizeof(char_u
*), sort_compare
);
5711 #if !defined(NO_EXPANDPATH) || defined(PROTO)
5713 * Compare path "p[]" to "q[]".
5714 * If "maxlen" >= 0 compare "p[maxlen]" to "q[maxlen]"
5715 * Return value like strcmp(p, q), but consider path separators.
5718 pathcmp(p
, q
, maxlen
)
5723 const char *s
= NULL
;
5725 for (i
= 0; maxlen
< 0 || i
< maxlen
; ++i
)
5727 /* End of "p": check if "q" also ends or just has a slash. */
5730 if (q
[i
] == NUL
) /* full match */
5736 /* End of "q": check if "p" just has a slash. */
5744 #ifdef CASE_INSENSITIVE_FILENAME
5745 TOUPPER_LOC(p
[i
]) != TOUPPER_LOC(q
[i
])
5749 #ifdef BACKSLASH_IN_FILENAME
5750 /* consider '/' and '\\' to be equal */
5751 && !((p
[i
] == '/' && q
[i
] == '\\')
5752 || (p
[i
] == '\\' && q
[i
] == '/'))
5756 if (vim_ispathsep(p
[i
]))
5758 if (vim_ispathsep(q
[i
]))
5760 return ((char_u
*)p
)[i
] - ((char_u
*)q
)[i
]; /* no match */
5763 if (s
== NULL
) /* "i" ran into "maxlen" */
5766 /* ignore a trailing slash, but not "//" or ":/" */
5769 && !after_pathsep((char_u
*)s
, (char_u
*)s
+ i
)
5770 #ifdef BACKSLASH_IN_FILENAME
5771 && (s
[i
] == '/' || s
[i
] == '\\')
5776 return 0; /* match with trailing slash */
5778 return -1; /* no match */
5784 * The putenv() implementation below comes from the "screen" program.
5785 * Included with permission from Juergen Weigert.
5786 * See pty.c for the copyright notice.
5790 * putenv -- put value into environment
5792 * Usage: i = putenv (string)
5796 * where string is of the form <name>=<value>.
5797 * Putenv returns 0 normally, -1 on error (not enough core for malloc).
5799 * Putenv may need to add a new name into the environment, or to
5800 * associate a value longer than the current value with a particular
5801 * name. So, to make life simpler, putenv() copies your entire
5802 * environment into the heap (i.e. malloc()) from the stack
5803 * (i.e. where it resides when your process is initiated) the first
5806 * (history removed, not very interesting. See the "screen" sources.)
5809 #if !defined(HAVE_SETENV) && !defined(HAVE_PUTENV)
5811 #define EXTRASIZE 5 /* increment to add to env. size */
5813 static int envsize
= -1; /* current size of environment */
5814 #ifndef MACOS_CLASSIC
5817 char **environ
; /* the global which is your env. */
5819 static int findenv
__ARGS((char *name
)); /* look for a name in the env. */
5820 static int newenv
__ARGS((void)); /* copy env. from stack to heap */
5821 static int moreenv
__ARGS((void)); /* incr. size of env. */
5831 { /* first time putenv called */
5832 if (newenv() < 0) /* copy env. to heap */
5836 i
= findenv((char *)string
); /* look for name in environment */
5839 { /* name must be added */
5840 for (i
= 0; environ
[i
]; i
++);
5841 if (i
>= (envsize
- 1))
5842 { /* need new slot */
5846 p
= (char *)alloc((unsigned)(strlen(string
) + 1));
5847 if (p
== NULL
) /* not enough core */
5849 environ
[i
+ 1] = 0; /* new end of env. */
5852 { /* name already in env. */
5853 p
= vim_realloc(environ
[i
], strlen(string
) + 1);
5857 sprintf(p
, "%s", string
); /* copy into env. */
5867 char *namechar
, *envchar
;
5871 for (i
= 0; environ
[i
] && !found
; i
++)
5873 envchar
= environ
[i
];
5875 while (*namechar
&& *namechar
!= '=' && (*namechar
== *envchar
))
5880 found
= ((*namechar
== '\0' || *namechar
== '=') && *envchar
== '=');
5882 return found
? i
- 1 : -1;
5892 /* for Mac a new, empty environment is created */
5895 for (i
= 0; environ
[i
]; i
++)
5898 esize
= i
+ EXTRASIZE
+ 1;
5899 env
= (char **)alloc((unsigned)(esize
* sizeof (elem
)));
5904 for (i
= 0; environ
[i
]; i
++)
5906 elem
= (char *)alloc((unsigned)(strlen(environ
[i
]) + 1));
5910 strcpy(elem
, environ
[i
]);
5926 esize
= envsize
+ EXTRASIZE
;
5927 env
= (char **)vim_realloc((char *)environ
, esize
* sizeof (*env
));
5935 # ifdef USE_VIMPTY_GETENV
5937 vimpty_getenv(string
)
5938 const char_u
*string
;
5946 i
= findenv((char *)string
);
5951 p
= vim_strchr((char_u
*)environ
[i
], '=');
5956 #endif /* !defined(HAVE_SETENV) && !defined(HAVE_PUTENV) */
5958 #if defined(FEAT_EVAL) || defined(FEAT_SPELL) || defined(PROTO)
5960 * Return 0 for not writable, 1 for writable file, 2 for a dir which we have
5961 * rights to write into.
5968 #if defined(UNIX) || defined(VMS)
5972 #if defined(UNIX) || defined(VMS)
5973 perm
= mch_getperm(fname
);
5975 #ifndef MACOS_CLASSIC /* TODO: get either mch_writable or mch_access */
5978 mch_writable(fname
) &&
5980 # if defined(UNIX) || defined(VMS)
5984 mch_access((char *)fname
, W_OK
) == 0
5989 if (mch_isdir(fname
))
5997 * Print an error message with one or two "%s" and one or two string arguments.
5998 * This is not in message.c to avoid a warning for prototypes.
6002 char_u
*s
, *a1
, *a2
;
6005 return TRUE
; /* no error messages at the moment */
6006 #ifdef HAVE_STDARG_H
6007 vim_snprintf((char *)IObuff
, IOSIZE
, (char *)s
, a1
, a2
);
6009 vim_snprintf((char *)IObuff
, IOSIZE
, (char *)s
, (long_u
)a1
, (long_u
)a2
);
6011 return emsg(IObuff
);
6015 * Print an error message with one "%ld" and one long int argument.
6016 * This is not in message.c to avoid a warning for prototypes.
6024 return TRUE
; /* no error messages at the moment */
6025 vim_snprintf((char *)IObuff
, IOSIZE
, (char *)s
, n
);
6026 return emsg(IObuff
);