vim: src/eval.c comparison

comparison src/eval.c @ 1591:c19f6b8d0393 v7.1.304

updated for version 7.1-304

author	vimboss
date	Thu, 29 May 2008 19:47:13 +0000
parents	fe7db192c7cc
children	1324b7b755f3

comparison

equal deleted inserted replaced

-:fe3ec5ea62f7
+:c19f6b8d0393
 static int get_short_pathname __ARGS((char_u **fnamep, char_u **bufp, int *fnamelen));
 static int shortpath_for_invalid_fname __ARGS((char_u **fname, char_u **bufp, int *fnamelen));
 static int shortpath_for_partial __ARGS((char_u **fnamep, char_u **bufp, int *fnamelen));
 /*
-* Get the short pathname of a file.
+* Get the short path (8.3) for the filename in "fnamep".
-* Returns 1 on success. *fnamelen is 0 for nonexistent path.
+* Only works for a valid file name.
+* When the path gets longer "fnamep" is changed and the allocated buffer
+* is put in "bufp".
+* *fnamelen is the length of "fnamep" and set to 0 for a nonexistent path.
+* Returns OK on success, FAIL on failure.
 */
 static int
 get_short_pathname(fnamep, bufp, fnamelen)
 char_u	**fnamep;
 char_u	**bufp;
 int		*fnamelen;
 {
-int		l,len;
+int		l, len;
 char_u	*newbuf;
 len = *fnamelen;
 l = GetShortPathName(*fnamep, *fnamep, len);
 if (l > len - 1)
 {
 	/* If that doesn't work (not enough space), then save the string
-	 * and try again with a new buffer big enough
+	 * and try again with a new buffer big enough. */
-	 */
 	newbuf = vim_strnsave(*fnamep, l);
 	if (newbuf == NULL)
-	    return 0;
+	    return FAIL;
 	vim_free(*bufp);
 	*fnamep = *bufp = newbuf;
-	l = GetShortPathName(*fnamep,*fnamep,l+1);
+	/* Really should always succeed, as the buffer is big enough. */
+	l = GetShortPathName(*fnamep, *fnamep, l+1);
-	/* Really should always succeed, as the buffer is big enough */
 }
 *fnamelen = l;
-return 1;
+return OK;
 }
 /*
-* Create a short path name.  Returns the length of the buffer it needs.
+* Get the short path (8.3) for the filename in "fname". The converted
-* Doesn't copy over the end of the buffer passed in.
+* path is returned in "bufp".
+*
+* Some of the directories specified in "fname" may not exist. This function
+* will shorten the existing directories at the beginning of the path and then
+* append the remaining non-existing path.
+*
+* fname - Pointer to the filename to shorten.  On return, contains the
+*         pointer to the shortened pathname
+* bufp -  Pointer to an allocated buffer for the filename.
+* fnamelen - Length of the filename pointed to by fname
+*
+* Returns OK on success (or nothing done) and FAIL on failure (out of memory).
 */
 static int
 shortpath_for_invalid_fname(fname, bufp, fnamelen)
 char_u	**fname;
 char_u	**bufp;
 int		*fnamelen;
 {
-char_u	*s, *p, *pbuf2, *pbuf3;
+char_u	*short_fname, *save_fname, *pbuf_unused;
+char_u	*endp, *save_endp;
 char_u	ch;
-int		len, len2, plen, slen;
+int		old_len, len;
+int		new_len, sfx_len;
+int		retval = OK;
 /* Make a copy */
-len2 = *fnamelen;
+old_len = *fnamelen;
-pbuf2 = vim_strnsave(*fname, len2);
+save_fname = vim_strnsave(*fname, old_len);
-pbuf3 = NULL;
+pbuf_unused = NULL;
+short_fname = NULL;
-s = pbuf2 + len2 - 1; /* Find the end */
-slen = 1;
+endp = save_fname + old_len - 1; /* Find the end of the copy */
-plen = len2;
+save_endp = endp;
-if (after_pathsep(pbuf2, s + 1))
+/*
-{
+* Try shortening the supplied path till it succeeds by removing one
-	--s;
+* directory at a time from the tail of the path.
-	++slen;
+*/
-	--plen;
+len = 0;
-}
+for (;;)
+{
-do
+	/* go back one path-separator */
-{
+	while (endp > save_fname && !after_pathsep(save_fname, endp + 1))
-	/* Go back one path-separator */
+	    --endp;
-	while (s > pbuf2 && !after_pathsep(pbuf2, s + 1))
+	if (endp <= save_fname)
-	{
+	    break;		/* processed the complete path */
-	    --s;
-	    ++slen;
+	/*
-	    --plen;
+	 * Replace the path separator with a NUL and try to shorten the
-	}
+	 * resulting path.
-	if (s <= pbuf2)
+	 */
-	    break;
+	ch = *endp;
+	*endp = 0;
-	/* Remember the character that is about to be splatted */
+	short_fname = save_fname;
-	ch = *s;
+	len = STRLEN(short_fname) + 1;
-	*s = 0; /* get_short_pathname requires a null-terminated string */
+	if (get_short_pathname(&short_fname, &pbuf_unused, &len) == FAIL)
+	{
-	/* Try it in situ */
+	    retval = FAIL;
-	p = pbuf2;
+	    goto theend;
-	if (!get_short_pathname(&p, &pbuf3, &plen))
+	}
-	{
+	*endp = ch;	/* preserve the string */
-	    vim_free(pbuf2);
-	    return -1;
+	if (len > 0)
-	}
+	    break;	/* successfully shortened the path */
-	*s = ch;    /* Preserve the string */
-} while (plen == 0);
+	/* failed to shorten the path. Skip the path separator */
+	--endp;
-if (plen > 0)
+}
-{
-	/* Remember the length of the new string.  */
+if (len > 0)
-	*fnamelen = len = plen + slen;
+{
+	/*
+	 * Succeeded in shortening the path. Now concatenate the shortened
+	 * path with the remaining path at the tail.
+	 */
+	/* Compute the length of the new path. */
+	sfx_len = (int)(save_endp - endp) + 1;
+	new_len = len + sfx_len;
+	*fnamelen = new_len;
 	vim_free(*bufp);
-	if (len > len2)
+	if (new_len > old_len)
 	{
-	    /* If there's not enough space in the currently allocated string,
+	    /* There is not enough space in the currently allocated string,
-	     * then copy it to a buffer big enough.
+	     * copy it to a buffer big enough. */
-	     */
+	    *fname = *bufp = vim_strnsave(short_fname, new_len);
-	    *fname= *bufp = vim_strnsave(p, len);
 	    if (*fname == NULL)
-		return -1;
+	    {
+		retval = FAIL;
+		goto theend;
+	    }
 	}
 	else
 	{
-	    /* Transfer pbuf2 to being the main buffer  (it's big enough) */
+	    /* Transfer short_fname to the main buffer (it's big enough),
-	    *fname = *bufp = pbuf2;
+	     * unless get_short_pathname() did its work in-place. */
-	    if (p != pbuf2)
+	    *fname = *bufp = save_fname;
-		strncpy(*fname, p, plen);
+	    if (short_fname != save_fname)
-	    pbuf2 = NULL;
+		vim_strncpy(save_fname, short_fname, len);
-	}
+	    save_fname = NULL;
-	/* Concat the next bit */
+	}
-	strncpy(*fname + plen, s, slen);
-	(*fname)[len] = '\0';
+	/* concat the not-shortened part of the path */
-}
+	vim_strncpy(*fname + len, endp, sfx_len);
-vim_free(pbuf3);
+	(*fname)[new_len] = NUL;
-vim_free(pbuf2);
+}
-return 0;
+theend:
+vim_free(pbuf_unused);
+vim_free(save_fname);
+return retval;
 }
 /*
 * Get a pathname for a partial path.
+* Returns OK for success, FAIL for failure.
 */
 static int
 shortpath_for_partial(fnamep, bufp, fnamelen)
 char_u	**fnamep;
 char_u	**bufp;
 else
 	pbuf = tfname = FullName_save(*fnamep, FALSE);
 len = tflen = (int)STRLEN(tfname);
-if (!get_short_pathname(&tfname, &pbuf, &len))
+if (get_short_pathname(&tfname, &pbuf, &len) == FAIL)
-	return -1;
+	return FAIL;
 if (len == 0)
 {
 	/* Don't have a valid filename, so shorten the rest of the
 	 * path if we can. This CAN give us invalid 8.3 filenames, but
 	 * there's not a lot of point in guessing what it might be.
 	 */
 	len = tflen;
-	if (shortpath_for_invalid_fname(&tfname, &pbuf, &len) == -1)
+	if (shortpath_for_invalid_fname(&tfname, &pbuf, &len) == FAIL)
-	    return -1;
+	    return FAIL;
 }
 /* Count the paths backward to find the beginning of the desired string. */
 for (p = tfname + len - 1; p >= tfname; --p)
 {
 {
 	--p;
 	if (p >= tfname)
 	    *p = '~';
 	else
-	    return -1;
+	    return FAIL;
 }
 else
 	++p;
 /* Copy in the string - p indexes into tfname - allocated at pbuf */
 vim_free(*bufp);
 *fnamelen = (int)STRLEN(p);
 *bufp = pbuf;
 *fnamep = p;
-return 0;
+return OK;
 }
 #endif /* WIN3264 */
 /*
 * Adjust a filename, according to a string of modifiers.
 * *fnamep must be NUL terminated when called.  When returning, the length is
 * determined by *fnamelen.
-* Returns valid flags.
+* Returns VALID_ flags or -1 for failure.
 * When there is an error, *fnamep is set to NULL.
 */
 int
 modify_fname(src, usedlen, fnamep, bufp, fnamelen)
 char_u	*src;		/* string with modifiers */
 	/* Split into two implementations - makes it easier.  First is where
 	 * there isn't a full name already, second is where there is.
 	 */
 	if (!has_fullname && !vim_isAbsName(*fnamep))
 	{
-	    if (shortpath_for_partial(fnamep, bufp, fnamelen) == -1)
+	    if (shortpath_for_partial(fnamep, bufp, fnamelen) == FAIL)
 		return -1;
 	}
 	else
 	{
 	    int		l;
 	    /* Simple case, already have the full-name
 	     * Nearly always shorter, so try first time. */
 	    l = *fnamelen;
-	    if (!get_short_pathname(fnamep, bufp, &l))
+	    if (get_short_pathname(fnamep, bufp, &l) == FAIL)
 		return -1;
 	    if (l == 0)
 	    {
 		/* Couldn't find the filename.. search the paths.
 		 */
 		l = *fnamelen;
-		if (shortpath_for_invalid_fname(fnamep, bufp, &l ) == -1)
+		if (shortpath_for_invalid_fname(fnamep, bufp, &l) == FAIL)
 		    return -1;
 	    }
 	    *fnamelen = l;
 	}
 }

Mercurial > vim

comparison src/eval.c @ 1591:c19f6b8d0393 v7.1.304