Logo Search packages:      
Sourcecode: mingw-w64 version File versions  Download package

dirname.c

/* dirname.c
 *
 * $Id: dirname.c,v 1.2 2007/03/08 23:15:58 keithmarshall Exp $
 *
 * Provides an implementation of the "dirname" function, conforming
 * to SUSv3, with extensions to accommodate Win32 drive designators,
 * and suitable for use on native Microsoft(R) Win32 platforms.
 *
 * Written by Keith Marshall <keithmarshall@users.sourceforge.net>
 *
 * This is free software.  You may redistribute and/or modify it as you
 * see fit, without restriction of copyright.
 *
 * This software is provided "as is", in the hope that it may be useful,
 * but WITHOUT WARRANTY OF ANY KIND, not even any implied warranty of
 * MERCHANTABILITY, nor of FITNESS FOR ANY PARTICULAR PURPOSE.  At no
 * time will the author accept any form of liability for any damages,
 * however caused, resulting from the use of this software.
 *
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <libgen.h>
#include <locale.h>

#ifndef __cdecl  /* If compiling on any non-Win32 platform ... */
#define __cdecl  /* this may not be defined.                   */
#endif

char * __cdecl
dirname(char *path)
{
  static char *retfail = NULL;
  size_t len;
  /* to handle path names for files in multibyte character locales,
   * we need to set up LC_CTYPE to match the host file system locale.  */
  char *locale = setlocale (LC_CTYPE, NULL);

  if (locale != NULL)
    locale = strdup (locale);
  setlocale (LC_CTYPE, "");

  if (path && *path)
    {
      /* allocate sufficient local storage space,
       * in which to create a wide character reference copy of path.  */
      wchar_t refcopy[1 + (len = mbstowcs (NULL, path, 0))];
      /* create the wide character reference copy of path */
      wchar_t *refpath = refcopy;

      len = mbstowcs (refpath, path, len);
      refcopy[len] = L'\0';
      /* SUSv3 identifies a special case, where path is exactly equal to "//";
       * (we will also accept "\\" in the Win32 context, but not "/\" or "\/",
       *  and neither will we consider paths with an initial drive designator).
       * For this special case, SUSv3 allows the implementation to choose to
       * return "/" or "//", (or "\" or "\\", since this is Win32); we will
       * simply return the path unchanged, (i.e. "//" or "\\").  */
      if (len > 1 && (refpath[0] == L'/' || refpath[0] == L'\\'))
        {
        if (refpath[1] == refpath[0] && refpath[2] == L'\0')
          {
            setlocale (LC_CTYPE, locale);
            free (locale);
            return path;
          }
        }
      /* For all other cases ...
       * step over the drive designator, if present ...  */
      else if (len > 1 && refpath[1] == L':')
        {
        /* FIXME: maybe should confirm *refpath is a valid drive designator.  */
        refpath += 2;
        }
      /* check again, just to ensure we still have a non-empty path name ... */
      if (*refpath)
        {
#     undef  basename
#     define basename __the_basename            /* avoid shadowing. */
        /* reproduce the scanning logic of the "basename" function
         * to locate the basename component of the current path string,
         * (but also remember where the dirname component starts).  */
        wchar_t *refname, *basename;
        for (refname = basename = refpath; *refpath; ++refpath)
          {
            if (*refpath == L'/' || *refpath == L'\\')
              {
              /* we found a dir separator ...
               * step over it, and any others which immediately follow it.  */
              while (*refpath == L'/' || *refpath == L'\\')
                ++refpath;
              /* if we didn't reach the end of the path string ... */
              if (*refpath)
                /* then we have a new candidate for the base name.  */
                basename = refpath;
              else
                /* we struck an early termination of the path string,
                 * with trailing dir separators following the base name,
                 * so break out of the for loop, to avoid overrun.  */
                break;
              }
          }
        /* now check,
         * to confirm that we have distinct dirname and basename components.  */
        if (basename > refname)
          {
            /* and, when we do ...
             * backtrack over all trailing separators on the dirname component,
             * (but preserve exactly two initial dirname separators, if identical),
             * and add a NUL terminator in their place.  */
            do --basename;
            while (basename > refname && (*basename == L'/' || *basename == L'\\'));
            if (basename == refname && (refname[0] == L'/' || refname[0] == L'\\')
              && refname[1] == refname[0] && refname[2] != L'/' && refname[2] != L'\\')
            ++basename;
            *++basename = L'\0';
            /* if the resultant dirname begins with EXACTLY two dir separators,
             * AND both are identical, then we preserve them.  */
            refpath = refcopy;
            while ((*refpath == L'/' || *refpath == L'\\'))
            ++refpath;
            if ((refpath - refcopy) > 2 || refcopy[1] != refcopy[0])
            refpath = refcopy;
            /* and finally ...
             * we remove any residual, redundantly duplicated separators from the dirname,
             * reterminate, and return it.  */
            refname = refpath;
            while (*refpath)
              {
              if ((*refname++ = *refpath) == L'/' || *refpath++ == L'\\')
                {
                  while (*refpath == L'/' || *refpath == L'\\')
                  ++refpath;
                }
              }
            *refname = L'\0';
            /* finally ...
             * transform the resolved dirname back into the multibyte char domain,
             * restore the caller's locale, and return the resultant dirname.  */
            if ((len = wcstombs( path, refcopy, len )) != (size_t)(-1))
            path[len] = '\0';
          }
        else
          {
            /* either there were no dirname separators in the path name,
             * or there was nothing else ...  */
            if (*refname == L'/' || *refname == L'\\')
              {
              /* it was all separators, so return one.  */
              ++refname;
              }
            else
              {
              /* there were no separators, so return '.'.  */
              *refname++ = L'.';
              }
            /* add a NUL terminator, in either case,
             * then transform to the multibyte char domain,
             * using our own buffer.  */
            *refname = L'\0';
            retfail = realloc (retfail, len = 1 + wcstombs (NULL, refcopy, 0));
            wcstombs (path = retfail, refcopy, len);
          }
        /* restore caller's locale, clean up, and return the resolved dirname.  */
        setlocale (LC_CTYPE, locale);
        free (locale);
        return path;
        }
#     undef  basename
    }
  /* path is NULL, or an empty string; default return value is "." ...
   * return this in our own buffer, regenerated by wide char transform,
   * in case the caller trashed it after a previous call.
   */
  retfail = realloc (retfail, len = 1 + wcstombs (NULL, L".", 0));
  wcstombs (retfail, L".", len);
  /* restore caller's locale, clean up, and return the default dirname.  */
  setlocale (LC_CTYPE, locale);
  free (locale);
  return retfail;
}

Generated by  Doxygen 1.6.0   Back to index