@@ -0,0 +1,477 @@
|
|
1
|
+
To: vim-dev@vim.org
|
2
|
+
Subject: Patch 7.1.304
|
3
|
+
Fcc: outbox
|
4
|
+
From: Bram Moolenaar <Bram@moolenaar.net>
|
5
|
+
Mime-Version: 1.0
|
6
|
+
Content-Type: text/plain; charset=ISO-8859-1
|
7
|
+
Content-Transfer-Encoding: 8bit
|
8
|
+
------------
|
9
|
+
|
10
|
+
Patch 7.1.304
|
11
|
+
Problem: Shortpath_for_invalid_fname() does not work correctly and is
|
12
|
+
unnecessary complex.
|
13
|
+
Solution: Clean up shortpath_for_invalid_fname(). (mostly by Yegappan
|
14
|
+
Lakshmanan)
|
15
|
+
Files: src/eval.c
|
16
|
+
|
17
|
+
|
18
|
+
*** ../vim-7.1.303/src/eval.c Wed May 28 16:48:01 2008
|
19
|
+
--- src/eval.c Wed May 28 16:35:51 2008
|
20
|
+
***************
|
21
|
+
*** 21068,21075 ****
|
22
|
+
static int shortpath_for_partial __ARGS((char_u **fnamep, char_u **bufp, int *fnamelen));
|
23
|
+
|
24
|
+
/*
|
25
|
+
! * Get the short pathname of a file.
|
26
|
+
! * Returns 1 on success. *fnamelen is 0 for nonexistent path.
|
27
|
+
*/
|
28
|
+
static int
|
29
|
+
get_short_pathname(fnamep, bufp, fnamelen)
|
30
|
+
--- 21476,21487 ----
|
31
|
+
static int shortpath_for_partial __ARGS((char_u **fnamep, char_u **bufp, int *fnamelen));
|
32
|
+
|
33
|
+
/*
|
34
|
+
! * Get the short path (8.3) for the filename in "fnamep".
|
35
|
+
! * Only works for a valid file name.
|
36
|
+
! * When the path gets longer "fnamep" is changed and the allocated buffer
|
37
|
+
! * is put in "bufp".
|
38
|
+
! * *fnamelen is the length of "fnamep" and set to 0 for a nonexistent path.
|
39
|
+
! * Returns OK on success, FAIL on failure.
|
40
|
+
*/
|
41
|
+
static int
|
42
|
+
get_short_pathname(fnamep, bufp, fnamelen)
|
43
|
+
***************
|
44
|
+
*** 21077,21112 ****
|
45
|
+
char_u **bufp;
|
46
|
+
int *fnamelen;
|
47
|
+
{
|
48
|
+
! int l,len;
|
49
|
+
char_u *newbuf;
|
50
|
+
|
51
|
+
len = *fnamelen;
|
52
|
+
-
|
53
|
+
l = GetShortPathName(*fnamep, *fnamep, len);
|
54
|
+
if (l > len - 1)
|
55
|
+
{
|
56
|
+
/* If that doesn't work (not enough space), then save the string
|
57
|
+
! * and try again with a new buffer big enough
|
58
|
+
! */
|
59
|
+
newbuf = vim_strnsave(*fnamep, l);
|
60
|
+
if (newbuf == NULL)
|
61
|
+
! return 0;
|
62
|
+
|
63
|
+
vim_free(*bufp);
|
64
|
+
*fnamep = *bufp = newbuf;
|
65
|
+
|
66
|
+
! l = GetShortPathName(*fnamep,*fnamep,l+1);
|
67
|
+
!
|
68
|
+
! /* Really should always succeed, as the buffer is big enough */
|
69
|
+
}
|
70
|
+
|
71
|
+
*fnamelen = l;
|
72
|
+
! return 1;
|
73
|
+
}
|
74
|
+
|
75
|
+
/*
|
76
|
+
! * Create a short path name. Returns the length of the buffer it needs.
|
77
|
+
! * Doesn't copy over the end of the buffer passed in.
|
78
|
+
*/
|
79
|
+
static int
|
80
|
+
shortpath_for_invalid_fname(fname, bufp, fnamelen)
|
81
|
+
--- 21489,21532 ----
|
82
|
+
char_u **bufp;
|
83
|
+
int *fnamelen;
|
84
|
+
{
|
85
|
+
! int l, len;
|
86
|
+
char_u *newbuf;
|
87
|
+
|
88
|
+
len = *fnamelen;
|
89
|
+
l = GetShortPathName(*fnamep, *fnamep, len);
|
90
|
+
if (l > len - 1)
|
91
|
+
{
|
92
|
+
/* If that doesn't work (not enough space), then save the string
|
93
|
+
! * and try again with a new buffer big enough. */
|
94
|
+
newbuf = vim_strnsave(*fnamep, l);
|
95
|
+
if (newbuf == NULL)
|
96
|
+
! return FAIL;
|
97
|
+
|
98
|
+
vim_free(*bufp);
|
99
|
+
*fnamep = *bufp = newbuf;
|
100
|
+
|
101
|
+
! /* Really should always succeed, as the buffer is big enough. */
|
102
|
+
! l = GetShortPathName(*fnamep, *fnamep, l+1);
|
103
|
+
}
|
104
|
+
|
105
|
+
*fnamelen = l;
|
106
|
+
! return OK;
|
107
|
+
}
|
108
|
+
|
109
|
+
/*
|
110
|
+
! * Get the short path (8.3) for the filename in "fname". The converted
|
111
|
+
! * path is returned in "bufp".
|
112
|
+
! *
|
113
|
+
! * Some of the directories specified in "fname" may not exist. This function
|
114
|
+
! * will shorten the existing directories at the beginning of the path and then
|
115
|
+
! * append the remaining non-existing path.
|
116
|
+
! *
|
117
|
+
! * fname - Pointer to the filename to shorten. On return, contains the
|
118
|
+
! * pointer to the shortened pathname
|
119
|
+
! * bufp - Pointer to an allocated buffer for the filename.
|
120
|
+
! * fnamelen - Length of the filename pointed to by fname
|
121
|
+
! *
|
122
|
+
! * Returns OK on success (or nothing done) and FAIL on failure (out of memory).
|
123
|
+
*/
|
124
|
+
static int
|
125
|
+
shortpath_for_invalid_fname(fname, bufp, fnamelen)
|
126
|
+
***************
|
127
|
+
*** 21114,21198 ****
|
128
|
+
char_u **bufp;
|
129
|
+
int *fnamelen;
|
130
|
+
{
|
131
|
+
! char_u *s, *p, *pbuf2, *pbuf3;
|
132
|
+
char_u ch;
|
133
|
+
! int len, len2, plen, slen;
|
134
|
+
|
135
|
+
/* Make a copy */
|
136
|
+
! len2 = *fnamelen;
|
137
|
+
! pbuf2 = vim_strnsave(*fname, len2);
|
138
|
+
! pbuf3 = NULL;
|
139
|
+
!
|
140
|
+
! s = pbuf2 + len2 - 1; /* Find the end */
|
141
|
+
! slen = 1;
|
142
|
+
! plen = len2;
|
143
|
+
!
|
144
|
+
! if (after_pathsep(pbuf2, s + 1))
|
145
|
+
! {
|
146
|
+
! --s;
|
147
|
+
! ++slen;
|
148
|
+
! --plen;
|
149
|
+
! }
|
150
|
+
|
151
|
+
! do
|
152
|
+
{
|
153
|
+
! /* Go back one path-separator */
|
154
|
+
! while (s > pbuf2 && !after_pathsep(pbuf2, s + 1))
|
155
|
+
! {
|
156
|
+
! --s;
|
157
|
+
! ++slen;
|
158
|
+
! --plen;
|
159
|
+
! }
|
160
|
+
! if (s <= pbuf2)
|
161
|
+
! break;
|
162
|
+
|
163
|
+
! /* Remember the character that is about to be splatted */
|
164
|
+
! ch = *s;
|
165
|
+
! *s = 0; /* get_short_pathname requires a null-terminated string */
|
166
|
+
!
|
167
|
+
! /* Try it in situ */
|
168
|
+
! p = pbuf2;
|
169
|
+
! if (!get_short_pathname(&p, &pbuf3, &plen))
|
170
|
+
{
|
171
|
+
! vim_free(pbuf2);
|
172
|
+
! return -1;
|
173
|
+
}
|
174
|
+
! *s = ch; /* Preserve the string */
|
175
|
+
! } while (plen == 0);
|
176
|
+
|
177
|
+
! if (plen > 0)
|
178
|
+
{
|
179
|
+
! /* Remember the length of the new string. */
|
180
|
+
! *fnamelen = len = plen + slen;
|
181
|
+
vim_free(*bufp);
|
182
|
+
! if (len > len2)
|
183
|
+
{
|
184
|
+
! /* If there's not enough space in the currently allocated string,
|
185
|
+
! * then copy it to a buffer big enough.
|
186
|
+
! */
|
187
|
+
! *fname= *bufp = vim_strnsave(p, len);
|
188
|
+
if (*fname == NULL)
|
189
|
+
! return -1;
|
190
|
+
}
|
191
|
+
else
|
192
|
+
{
|
193
|
+
! /* Transfer pbuf2 to being the main buffer (it's big enough) */
|
194
|
+
! *fname = *bufp = pbuf2;
|
195
|
+
! if (p != pbuf2)
|
196
|
+
! strncpy(*fname, p, plen);
|
197
|
+
! pbuf2 = NULL;
|
198
|
+
! }
|
199
|
+
! /* Concat the next bit */
|
200
|
+
! strncpy(*fname + plen, s, slen);
|
201
|
+
! (*fname)[len] = '\0';
|
202
|
+
}
|
203
|
+
! vim_free(pbuf3);
|
204
|
+
! vim_free(pbuf2);
|
205
|
+
! return 0;
|
206
|
+
}
|
207
|
+
|
208
|
+
/*
|
209
|
+
* Get a pathname for a partial path.
|
210
|
+
*/
|
211
|
+
static int
|
212
|
+
shortpath_for_partial(fnamep, bufp, fnamelen)
|
213
|
+
--- 21534,21639 ----
|
214
|
+
char_u **bufp;
|
215
|
+
int *fnamelen;
|
216
|
+
{
|
217
|
+
! char_u *short_fname, *save_fname, *pbuf_unused;
|
218
|
+
! char_u *endp, *save_endp;
|
219
|
+
char_u ch;
|
220
|
+
! int old_len, len;
|
221
|
+
! int new_len, sfx_len;
|
222
|
+
! int retval = OK;
|
223
|
+
|
224
|
+
/* Make a copy */
|
225
|
+
! old_len = *fnamelen;
|
226
|
+
! save_fname = vim_strnsave(*fname, old_len);
|
227
|
+
! pbuf_unused = NULL;
|
228
|
+
! short_fname = NULL;
|
229
|
+
|
230
|
+
! endp = save_fname + old_len - 1; /* Find the end of the copy */
|
231
|
+
! save_endp = endp;
|
232
|
+
!
|
233
|
+
! /*
|
234
|
+
! * Try shortening the supplied path till it succeeds by removing one
|
235
|
+
! * directory at a time from the tail of the path.
|
236
|
+
! */
|
237
|
+
! len = 0;
|
238
|
+
! for (;;)
|
239
|
+
{
|
240
|
+
! /* go back one path-separator */
|
241
|
+
! while (endp > save_fname && !after_pathsep(save_fname, endp + 1))
|
242
|
+
! --endp;
|
243
|
+
! if (endp <= save_fname)
|
244
|
+
! break; /* processed the complete path */
|
245
|
+
|
246
|
+
! /*
|
247
|
+
! * Replace the path separator with a NUL and try to shorten the
|
248
|
+
! * resulting path.
|
249
|
+
! */
|
250
|
+
! ch = *endp;
|
251
|
+
! *endp = 0;
|
252
|
+
! short_fname = save_fname;
|
253
|
+
! len = STRLEN(short_fname) + 1;
|
254
|
+
! if (get_short_pathname(&short_fname, &pbuf_unused, &len) == FAIL)
|
255
|
+
{
|
256
|
+
! retval = FAIL;
|
257
|
+
! goto theend;
|
258
|
+
}
|
259
|
+
! *endp = ch; /* preserve the string */
|
260
|
+
!
|
261
|
+
! if (len > 0)
|
262
|
+
! break; /* successfully shortened the path */
|
263
|
+
|
264
|
+
! /* failed to shorten the path. Skip the path separator */
|
265
|
+
! --endp;
|
266
|
+
! }
|
267
|
+
!
|
268
|
+
! if (len > 0)
|
269
|
+
{
|
270
|
+
! /*
|
271
|
+
! * Succeeded in shortening the path. Now concatenate the shortened
|
272
|
+
! * path with the remaining path at the tail.
|
273
|
+
! */
|
274
|
+
!
|
275
|
+
! /* Compute the length of the new path. */
|
276
|
+
! sfx_len = (int)(save_endp - endp) + 1;
|
277
|
+
! new_len = len + sfx_len;
|
278
|
+
!
|
279
|
+
! *fnamelen = new_len;
|
280
|
+
vim_free(*bufp);
|
281
|
+
! if (new_len > old_len)
|
282
|
+
{
|
283
|
+
! /* There is not enough space in the currently allocated string,
|
284
|
+
! * copy it to a buffer big enough. */
|
285
|
+
! *fname = *bufp = vim_strnsave(short_fname, new_len);
|
286
|
+
if (*fname == NULL)
|
287
|
+
! {
|
288
|
+
! retval = FAIL;
|
289
|
+
! goto theend;
|
290
|
+
! }
|
291
|
+
}
|
292
|
+
else
|
293
|
+
{
|
294
|
+
! /* Transfer short_fname to the main buffer (it's big enough),
|
295
|
+
! * unless get_short_pathname() did its work in-place. */
|
296
|
+
! *fname = *bufp = save_fname;
|
297
|
+
! if (short_fname != save_fname)
|
298
|
+
! vim_strncpy(save_fname, short_fname, len);
|
299
|
+
! save_fname = NULL;
|
300
|
+
! }
|
301
|
+
!
|
302
|
+
! /* concat the not-shortened part of the path */
|
303
|
+
! vim_strncpy(*fname + len, endp, sfx_len);
|
304
|
+
! (*fname)[new_len] = NUL;
|
305
|
+
}
|
306
|
+
!
|
307
|
+
! theend:
|
308
|
+
! vim_free(pbuf_unused);
|
309
|
+
! vim_free(save_fname);
|
310
|
+
!
|
311
|
+
! return retval;
|
312
|
+
}
|
313
|
+
|
314
|
+
/*
|
315
|
+
* Get a pathname for a partial path.
|
316
|
+
+ * Returns OK for success, FAIL for failure.
|
317
|
+
*/
|
318
|
+
static int
|
319
|
+
shortpath_for_partial(fnamep, bufp, fnamelen)
|
320
|
+
***************
|
321
|
+
*** 21222,21229 ****
|
322
|
+
|
323
|
+
len = tflen = (int)STRLEN(tfname);
|
324
|
+
|
325
|
+
! if (!get_short_pathname(&tfname, &pbuf, &len))
|
326
|
+
! return -1;
|
327
|
+
|
328
|
+
if (len == 0)
|
329
|
+
{
|
330
|
+
--- 21663,21670 ----
|
331
|
+
|
332
|
+
len = tflen = (int)STRLEN(tfname);
|
333
|
+
|
334
|
+
! if (get_short_pathname(&tfname, &pbuf, &len) == FAIL)
|
335
|
+
! return FAIL;
|
336
|
+
|
337
|
+
if (len == 0)
|
338
|
+
{
|
339
|
+
***************
|
340
|
+
*** 21232,21239 ****
|
341
|
+
* there's not a lot of point in guessing what it might be.
|
342
|
+
*/
|
343
|
+
len = tflen;
|
344
|
+
! if (shortpath_for_invalid_fname(&tfname, &pbuf, &len) == -1)
|
345
|
+
! return -1;
|
346
|
+
}
|
347
|
+
|
348
|
+
/* Count the paths backward to find the beginning of the desired string. */
|
349
|
+
--- 21673,21680 ----
|
350
|
+
* there's not a lot of point in guessing what it might be.
|
351
|
+
*/
|
352
|
+
len = tflen;
|
353
|
+
! if (shortpath_for_invalid_fname(&tfname, &pbuf, &len) == FAIL)
|
354
|
+
! return FAIL;
|
355
|
+
}
|
356
|
+
|
357
|
+
/* Count the paths backward to find the beginning of the desired string. */
|
358
|
+
***************
|
359
|
+
*** 21257,21263 ****
|
360
|
+
if (p >= tfname)
|
361
|
+
*p = '~';
|
362
|
+
else
|
363
|
+
! return -1;
|
364
|
+
}
|
365
|
+
else
|
366
|
+
++p;
|
367
|
+
--- 21698,21704 ----
|
368
|
+
if (p >= tfname)
|
369
|
+
*p = '~';
|
370
|
+
else
|
371
|
+
! return FAIL;
|
372
|
+
}
|
373
|
+
else
|
374
|
+
++p;
|
375
|
+
***************
|
376
|
+
*** 21268,21274 ****
|
377
|
+
*bufp = pbuf;
|
378
|
+
*fnamep = p;
|
379
|
+
|
380
|
+
! return 0;
|
381
|
+
}
|
382
|
+
#endif /* WIN3264 */
|
383
|
+
|
384
|
+
--- 21709,21715 ----
|
385
|
+
*bufp = pbuf;
|
386
|
+
*fnamep = p;
|
387
|
+
|
388
|
+
! return OK;
|
389
|
+
}
|
390
|
+
#endif /* WIN3264 */
|
391
|
+
|
392
|
+
***************
|
393
|
+
*** 21276,21282 ****
|
394
|
+
* Adjust a filename, according to a string of modifiers.
|
395
|
+
* *fnamep must be NUL terminated when called. When returning, the length is
|
396
|
+
* determined by *fnamelen.
|
397
|
+
! * Returns valid flags.
|
398
|
+
* When there is an error, *fnamep is set to NULL.
|
399
|
+
*/
|
400
|
+
int
|
401
|
+
--- 21717,21723 ----
|
402
|
+
* Adjust a filename, according to a string of modifiers.
|
403
|
+
* *fnamep must be NUL terminated when called. When returning, the length is
|
404
|
+
* determined by *fnamelen.
|
405
|
+
! * Returns VALID_ flags or -1 for failure.
|
406
|
+
* When there is an error, *fnamep is set to NULL.
|
407
|
+
*/
|
408
|
+
int
|
409
|
+
***************
|
410
|
+
*** 21488,21494 ****
|
411
|
+
*/
|
412
|
+
if (!has_fullname && !vim_isAbsName(*fnamep))
|
413
|
+
{
|
414
|
+
! if (shortpath_for_partial(fnamep, bufp, fnamelen) == -1)
|
415
|
+
return -1;
|
416
|
+
}
|
417
|
+
else
|
418
|
+
--- 21929,21935 ----
|
419
|
+
*/
|
420
|
+
if (!has_fullname && !vim_isAbsName(*fnamep))
|
421
|
+
{
|
422
|
+
! if (shortpath_for_partial(fnamep, bufp, fnamelen) == FAIL)
|
423
|
+
return -1;
|
424
|
+
}
|
425
|
+
else
|
426
|
+
***************
|
427
|
+
*** 21498,21504 ****
|
428
|
+
/* Simple case, already have the full-name
|
429
|
+
* Nearly always shorter, so try first time. */
|
430
|
+
l = *fnamelen;
|
431
|
+
! if (!get_short_pathname(fnamep, bufp, &l))
|
432
|
+
return -1;
|
433
|
+
|
434
|
+
if (l == 0)
|
435
|
+
--- 21939,21945 ----
|
436
|
+
/* Simple case, already have the full-name
|
437
|
+
* Nearly always shorter, so try first time. */
|
438
|
+
l = *fnamelen;
|
439
|
+
! if (get_short_pathname(fnamep, bufp, &l) == FAIL)
|
440
|
+
return -1;
|
441
|
+
|
442
|
+
if (l == 0)
|
443
|
+
***************
|
444
|
+
*** 21506,21512 ****
|
445
|
+
/* Couldn't find the filename.. search the paths.
|
446
|
+
*/
|
447
|
+
l = *fnamelen;
|
448
|
+
! if (shortpath_for_invalid_fname(fnamep, bufp, &l ) == -1)
|
449
|
+
return -1;
|
450
|
+
}
|
451
|
+
*fnamelen = l;
|
452
|
+
--- 21947,21953 ----
|
453
|
+
/* Couldn't find the filename.. search the paths.
|
454
|
+
*/
|
455
|
+
l = *fnamelen;
|
456
|
+
! if (shortpath_for_invalid_fname(fnamep, bufp, &l) == FAIL)
|
457
|
+
return -1;
|
458
|
+
}
|
459
|
+
*fnamelen = l;
|
460
|
+
*** ../vim-7.1.303/src/version.c Thu May 29 15:33:13 2008
|
461
|
+
--- src/version.c Thu May 29 21:41:55 2008
|
462
|
+
***************
|
463
|
+
*** 668,669 ****
|
464
|
+
--- 673,676 ----
|
465
|
+
{ /* Add new patch number below this line */
|
466
|
+
+ /**/
|
467
|
+
+ 304,
|
468
|
+
/**/
|
469
|
+
|
470
|
+
--
|
471
|
+
"The future's already arrived - it's just not evenly distributed yet."
|
472
|
+
-- William Gibson
|
473
|
+
|
474
|
+
/// Bram Moolenaar -- Bram@Moolenaar.net -- http://www.Moolenaar.net \\\
|
475
|
+
/// sponsor Vim, vote for features -- http://www.Vim.org/sponsor/ \\\
|
476
|
+
\\\ download, build and distribute -- http://www.A-A-P.org ///
|
477
|
+
\\\ help me help AIDS victims -- http://ICCF-Holland.org ///
|