chiark - git - mdw - disorder/blob - lib/filepart.c

   1 /*
   2  * This file is part of DisOrder
   3  * Copyright (C) 2005, 2007 Richard Kettlewell
   4  *
   5  * This program is free software: you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation, either version 3 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17  */
  18 /** @file lib/filepart.c
  19  * @brief Filename parsing
  20  */
  21
  22 #include "common.h"
  23
  24 #include "filepart.h"
  25 #include "mem.h"
  26
  27 /** @brief Parse a filename
  28  * @param path Filename to parse
  29  * @param dirnamep Where to put directory name, or NULL
  30  * @param basenamep Where to put basename, or NULL
  31  */
  32 static void parse_filename(const char *path,
  33                            char **dirnamep,
  34                            char **basenamep) {
  35   const char *s, *e = path + strlen(path);
  36
  37   /* Strip trailing slashes.  We never take these into account. */
  38   while(e > path && e[-1] == '/')
  39     --e;
  40   if(e == path) {
  41     /* The path is empty or contains only slashes */
  42     if(*path) {
  43       if(dirnamep)
  44         *dirnamep = xstrdup("/");
  45       if(basenamep)
  46         *basenamep = xstrdup("/");
  47     } else {
  48       if(dirnamep)
  49         *dirnamep = xstrdup("");
  50       if(basenamep)
  51         *basenamep = xstrdup("");
  52     }
  53   } else {
  54     /* The path isn't empty and has more than just slashes.  e therefore now
  55      * points at the end of the basename. */
  56     s = e;
  57     while(s > path && s[-1] != '/')
  58       --s;
  59     /* Now s points at the start of the basename */
  60     if(basenamep)
  61       *basenamep = xstrndup(s, e - s);
  62     if(s > path) {
  63       --s;
  64       /* s must now be pointing at a '/' before the basename */
  65       assert(*s == '/');
  66       while(s > path && s[-1] == '/')
  67         --s;
  68       /* Now s must be pointing at the last '/' after the dirname */
  69       assert(*s == '/');
  70       if(s == path) {
  71         /* If we reached the start we must be at the root */
  72         if(dirnamep)
  73           *dirnamep = xstrdup("/");
  74       } else {
  75         /* There's more than just the root here */
  76         if(dirnamep)
  77           *dirnamep = xstrndup(path, s - path);
  78       }
  79     } else {
  80       /* There wasn't a slash */
  81       if(dirnamep)
  82         *dirnamep = xstrdup(".");
  83     }
  84   }
  85 }
  86
  87 /** @brief Return the directory part of @p path
  88  * @param path Path to parse
  89  * @return Directory part of @p path
  90  *
  91  * Extracts the directory part of @p path.  This is a simple lexical
  92  * transformation and no canonicalization is performed.  The result will only
  93  * ever end "/" if it is the root directory.  The result will be "." if there
  94  * is no directory part.
  95  */
  96 char *d_dirname(const char *path) {
  97   char *d = 0;
  98
  99   parse_filename(path, &d, 0);
 100   assert(d != 0);
 101   return d;
 102 }
 103
 104 /** @brief Return the basename part of @p path
 105  * @param path Path to parse
 106  * @return Base part of @p path
 107  *
 108  * Extracts the base part of @p path.  This is a simple lexical transformation
 109  * and no canonicalization is performed.  The result is always newly allocated
 110  * even if compares equal to @p path.
 111  */
 112 char *d_basename(const char *path) {
 113   char *b = 0;
 114
 115   parse_filename(path, 0, &b);
 116   assert(b != 0);
 117   return b;
 118 }
 119
 120 /** @brief Find the extension part of @p path
 121  * @param path Path to parse
 122  * @return Start of extension in @p path, or NULL
 123  *
 124  * The return value points into @p path and points at the "." at the start of
 125  * the path.  If the basename has no extension the result is NULL.  Extensions
 126  * are assumed to only contain the ASCII digits and letters.
 127  *
 128  * See also extension().
 129  */
 130 static const char *find_extension(const char *path) {
 131   const char *q = path + strlen(path);
 132
 133   while(q > path && strchr("abcdefghijklmnopqrstuvwxyz"
 134                         "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
 135                         "0123456789", *q))
 136     --q;
 137   return *q == '.' ? q : 0;
 138 }
 139
 140 /** @brief Strip the extension from @p path
 141  * @param path Path to parse
 142  * @return @p path with extension removed, or @p path
 143  *
 144  * The extension is defined exactly as for find_extension().  The result might
 145  * or might not point into @p path.
 146  */
 147 const char *strip_extension(const char *path) {
 148   const char *q = find_extension(path);
 149
 150   return q ? xstrndup(path, q - path) : path;
 151 }
 152
 153 /** @brief Find the extension part of @p path
 154  * @param path Path to parse
 155  * @return Start of extension in @p path, or ""
 156  *
 157  * The return value may points into @p path and if so points at the "." at the
 158  * start of the path.  If the basename has no extension the result is "".
 159  * Extensions are assumed to only contain the ASCII digits and letters.
 160  *
 161  * See also find_extension().
 162  */
 163 const char *extension(const char *path) {
 164   const char *q = find_extension(path);
 165
 166   return q ? q : "";
 167 }
 168
 169 /*
 170 Local Variables:
 171 c-basic-offset:2
 172 comment-column:40
 173 fill-column:79
 174 indent-tabs-mode:nil
 175 End:
 176 */