pathunix.c

   1 /*
   2  * Copyright 1993-2002 Christopher Seiwald and Perforce Software, Inc.
   3  *
   4  * This file is part of Jam - see jam.c for Copyright information.
   5  */
   6
   7 /*
   8  * pathunix.c - manipulate file names on UNIX, NT, OS2, AmigaOS
   9  *
  10  * External routines:
  11  *
  12  *  path_parse() - split a file name into dir/base/suffix/member
  13  *  path_build() - build a filename given dir/base/suffix/member
  14  *  path_parent() - make a PATHNAME point to its parent dir
  15  *
  16  * File_parse() and path_build() just manipuate a string and a structure;
  17  * they do not make system calls.
  18  *
  19  * 04/08/94 (seiwald) - Coherent/386 support added.
  20  * 12/26/93 (seiwald) - handle dir/.suffix properly in path_build()
  21  * 12/19/94 (mikem) - solaris string table insanity support
  22  * 12/21/94 (wingerd) Use backslashes for pathnames - the NT way.
  23  * 02/14/95 (seiwald) - parse and build /xxx properly
  24  * 02/23/95 (wingerd) Compilers on NT can handle "/" in pathnames, so we
  25  *                    should expect hdr searches to come up with strings
  26  *                    like "thing/thing.h". So we need to test for "/" as
  27  *                    well as "\" when parsing pathnames.
  28  * 03/16/95 (seiwald) - fixed accursed typo on line 69.
  29  * 05/03/96 (seiwald) - split from filent.c, fileunix.c
  30  * 12/20/96 (seiwald) - when looking for the rightmost . in a file name,
  31  *          don't include the archive member name.
  32  * 01/13/01 (seiwald) - turn off \ handling on UNIX, on by accident
  33  * 11/04/02 (seiwald) - const-ing for string literals
  34  */
  35
  36 # include "jam.h"
  37 # include "pathsys.h"
  38
  39 # ifdef USE_PATHUNIX
  40
  41 /*
  42  * path_parse() - split a file name into dir/base/suffix/member
  43  */
  44
  45 void
  46 path_parse(
  47   const char *file,
  48   PATHNAME *f )
  49 {
  50   const char *p, *q;
  51   const char *end;
  52
  53   memset( (char *)f, 0, sizeof( *f ) );
  54
  55   /* Look for <grist> */
  56
  57   if( file[0] == '<' && ( p = strchr( file, '>' ) ) )
  58   {
  59       f->f_grist.ptr = file;
  60       f->f_grist.len = p - file;
  61       file = p + 1;
  62   }
  63
  64   /* Look for dir/ */
  65
  66   p = strrchr( file, '/' );
  67
  68 # if PATH_DELIM == '\\'
  69   /* On NT, look for dir\ as well */
  70   {
  71       char *p1 = strrchr( file, '\\' );
  72       p = p1 > p ? p1 : p;
  73   }
  74 # endif
  75
  76   if( p )
  77   {
  78       f->f_dir.ptr = file;
  79       f->f_dir.len = p - file;
  80
  81       /* Special case for / - dirname is /, not "" */
  82
  83       if( !f->f_dir.len )
  84     f->f_dir.len = 1;
  85
  86 # if PATH_DELIM == '\\'
  87       /* Special case for D:/ - dirname is D:/, not "D:" */
  88
  89       if( f->f_dir.len == 2 && file[1] == ':' )
  90     f->f_dir.len = 3;
  91 # endif
  92
  93       file = p + 1;
  94   }
  95
  96   end = file + strlen( file );
  97
  98   /* Look for (member) */
  99
 100   if( ( p = strchr( file, '(' ) ) && end[-1] == ')' )
 101   {
 102       f->f_member.ptr = p + 1;
 103       f->f_member.len = end - p - 2;
 104       end = p;
 105   }
 106
 107   /* Look for .suffix */
 108   /* This would be memrchr() */
 109
 110   p = 0;
 111   q = file;
 112
 113   while( q = (char *)memchr( q, '.', end - q ) )
 114       p = q++;
 115
 116   if( p )
 117   {
 118       f->f_suffix.ptr = p;
 119       f->f_suffix.len = end - p;
 120       end = p;
 121   }
 122
 123   /* Leaves base */
 124
 125   f->f_base.ptr = file;
 126   f->f_base.len = end - file;
 127 }
 128
 129 /*
 130  * path_build() - build a filename given dir/base/suffix/member
 131  */
 132
 133 void
 134 path_build(
 135   PATHNAME *f,
 136   char  *file,
 137   int binding )
 138 {
 139   /* Start with the grist.  If the current grist isn't */
 140   /* surrounded by <>'s, add them. */
 141
 142   if( f->f_grist.len )
 143   {
 144       if( f->f_grist.ptr[0] != '<' ) *file++ = '<';
 145       memcpy( file, f->f_grist.ptr, f->f_grist.len );
 146       file += f->f_grist.len;
 147       if( file[-1] != '>' ) *file++ = '>';
 148   }
 149
 150   /* Don't prepend root if it's . or directory is rooted */
 151
 152 # if PATH_DELIM == '/'
 153
 154   if( f->f_root.len
 155       && !( f->f_root.len == 1 && f->f_root.ptr[0] == '.' )
 156       && !( f->f_dir.len && f->f_dir.ptr[0] == '/' ) )
 157
 158 # else /* unix */
 159
 160   if( f->f_root.len
 161       && !( f->f_root.len == 1 && f->f_root.ptr[0] == '.' )
 162       && !( f->f_dir.len && f->f_dir.ptr[0] == '/' )
 163       && !( f->f_dir.len && f->f_dir.ptr[0] == '\\' )
 164       && !( f->f_dir.len && f->f_dir.ptr[1] == ':' ) )
 165
 166 # endif /* unix */
 167
 168   {
 169       memcpy( file, f->f_root.ptr, f->f_root.len );
 170       file += f->f_root.len;
 171       *file++ = PATH_DELIM;
 172   }
 173
 174   if( f->f_dir.len )
 175   {
 176       memcpy( file, f->f_dir.ptr, f->f_dir.len );
 177       file += f->f_dir.len;
 178   }
 179
 180   /* UNIX: Put / between dir and file */
 181   /* NT:   Put \ between dir and file */
 182
 183   if( f->f_dir.len && ( f->f_base.len || f->f_suffix.len ) )
 184   {
 185       /* UNIX: Special case for dir \ : don't add another \ */
 186       /* NT:   Special case for dir / : don't add another / */
 187
 188 # if PATH_DELIM == '\\'
 189       if( !( f->f_dir.len == 3 && f->f_dir.ptr[1] == ':' ) )
 190 # endif
 191     if( !( f->f_dir.len == 1 && f->f_dir.ptr[0] == PATH_DELIM ) )
 192         *file++ = PATH_DELIM;
 193   }
 194
 195   if( f->f_base.len )
 196   {
 197       memcpy( file, f->f_base.ptr, f->f_base.len );
 198       file += f->f_base.len;
 199   }
 200
 201   if( f->f_suffix.len )
 202   {
 203       memcpy( file, f->f_suffix.ptr, f->f_suffix.len );
 204       file += f->f_suffix.len;
 205   }
 206
 207   if( f->f_member.len )
 208   {
 209       *file++ = '(';
 210       memcpy( file, f->f_member.ptr, f->f_member.len );
 211       file += f->f_member.len;
 212       *file++ = ')';
 213   }
 214   *file = 0;
 215 }
 216
 217 /*
 218  *  path_parent() - make a PATHNAME point to its parent dir
 219  */
 220
 221 void
 222 path_parent( PATHNAME *f )
 223 {
 224   /* just set everything else to nothing */
 225
 226   f->f_base.ptr =
 227   f->f_suffix.ptr =
 228   f->f_member.ptr = "";
 229
 230   f->f_base.len =
 231   f->f_suffix.len =
 232   f->f_member.len = 0;
 233 }
 234
 235 # endif /* unix, NT, OS/2, AmigaOS */