Return to dirname-lgpl.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / libiconv / srclib

Annotation of embedaddon/libiconv/srclib/dirname-lgpl.c, revision 1.1

1.1     ! misho       1: /* dirname.c -- return all but the last element in a file name
        !             2: 
        !             3:    Copyright (C) 1990, 1998, 2000-2001, 2003-2006, 2009-2019 Free Software
        !             4:    Foundation, Inc.
        !             5: 
        !             6:    This program is free software: you can redistribute it and/or modify
        !             7:    it under the terms of the GNU General Public License as published by
        !             8:    the Free Software Foundation; either version 3 of the License, or
        !             9:    (at your option) any later version.
        !            10: 
        !            11:    This program is distributed in the hope that it will be useful,
        !            12:    but WITHOUT ANY WARRANTY; without even the implied warranty of
        !            13:    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
        !            14:    GNU General Public License for more details.
        !            15: 
        !            16:    You should have received a copy of the GNU General Public License
        !            17:    along with this program.  If not, see <https://www.gnu.org/licenses/>.  */
        !            18: 
        !            19: #include <config.h>
        !            20: 
        !            21: #include "dirname.h"
        !            22: 
        !            23: #include <stdlib.h>
        !            24: #include <string.h>
        !            25: 
        !            26: /* Return the length of the prefix of FILE that will be used by
        !            27:    dir_name.  If FILE is in the working directory, this returns zero
        !            28:    even though 'dir_name (FILE)' will return ".".  Works properly even
        !            29:    if there are trailing slashes (by effectively ignoring them).  */
        !            30: 
        !            31: size_t
        !            32: dir_len (char const *file)
        !            33: {
        !            34:   size_t prefix_length = FILE_SYSTEM_PREFIX_LEN (file);
        !            35:   size_t length;
        !            36: 
        !            37:   /* Advance prefix_length beyond important leading slashes.  */
        !            38:   prefix_length += (prefix_length != 0
        !            39:                     ? (FILE_SYSTEM_DRIVE_PREFIX_CAN_BE_RELATIVE
        !            40:                        && ISSLASH (file[prefix_length]))
        !            41:                     : (ISSLASH (file[0])
        !            42:                        ? ((DOUBLE_SLASH_IS_DISTINCT_ROOT
        !            43:                            && ISSLASH (file[1]) && ! ISSLASH (file[2])
        !            44:                            ? 2 : 1))
        !            45:                        : 0));
        !            46: 
        !            47:   /* Strip the basename and any redundant slashes before it.  */
        !            48:   for (length = last_component (file) - file;
        !            49:        prefix_length < length; length--)
        !            50:     if (! ISSLASH (file[length - 1]))
        !            51:       break;
        !            52:   return length;
        !            53: }
        !            54: 
        !            55: 
        !            56: /* In general, we can't use the builtin 'dirname' function if available,
        !            57:    since it has different meanings in different environments.
        !            58:    In some environments the builtin 'dirname' modifies its argument.
        !            59: 
        !            60:    Return the leading directories part of FILE, allocated with malloc.
        !            61:    Works properly even if there are trailing slashes (by effectively
        !            62:    ignoring them).  Return NULL on failure.
        !            63: 
        !            64:    If lstat (FILE) would succeed, then { chdir (dir_name (FILE));
        !            65:    lstat (base_name (FILE)); } will access the same file.  Likewise,
        !            66:    if the sequence { chdir (dir_name (FILE));
        !            67:    rename (base_name (FILE), "foo"); } succeeds, you have renamed FILE
        !            68:    to "foo" in the same directory FILE was in.  */
        !            69: 
        !            70: char *
        !            71: mdir_name (char const *file)
        !            72: {
        !            73:   size_t length = dir_len (file);
        !            74:   bool append_dot = (length == 0
        !            75:                      || (FILE_SYSTEM_DRIVE_PREFIX_CAN_BE_RELATIVE
        !            76:                          && length == FILE_SYSTEM_PREFIX_LEN (file)
        !            77:                          && file[2] != '\0' && ! ISSLASH (file[2])));
        !            78:   char *dir = malloc (length + append_dot + 1);
        !            79:   if (!dir)
        !            80:     return NULL;
        !            81:   memcpy (dir, file, length);
        !            82:   if (append_dot)
        !            83:     dir[length++] = '.';
        !            84:   dir[length] = '\0';
        !            85:   return dir;
        !            86: }