8af7c2 - patchlevel 304

Authored and Committed by Karsten Hopp 16 years ago
1 file changed. 477 lines added. 0 lines removed.
    - patchlevel 304
    
        
file added
+477
7.1.304 ADDED
@@ -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 ///