soltools/mkdepend/include.c

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /* $XConsortium: include.c,v 1.17 94/12/05 19:33:08 gildea Exp $ */
   3 /*
   4
   5 Copyright (c) 1993, 1994  X Consortium
   6
   7 Permission is hereby granted, free of charge, to any person obtaining a copy
   8 of this software and associated documentation files (the "Software"), to deal
   9 in the Software without restriction, including without limitation the rights
  10 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  11 copies of the Software, and to permit persons to whom the Software is
  12 furnished to do so, subject to the following conditions:
  13
  14 The above copyright notice and this permission notice shall be included in
  15 all copies or substantial portions of the Software.
  16
  17 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  18 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  19 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
  20 X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
  21 AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  22 CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  23
  24 Except as contained in this notice, the name of the X Consortium shall not be
  25 used in advertising or otherwise to promote the sale, use or other dealings
  26 in this Software without prior written authorization from the X Consortium.
  27
  28 */
  29
  30
  31 #include "def.h"
  32 #include <string.h>
  33
  34 void remove_dotdot( char * );
  35 int isdot( char const * );
  36 int isdotdot( char const * );
  37 int issymbolic(char * dir, char * component);
  38 int exists_path(struct IncludesCollection*, char*);
  39
  40
  41 extern struct inclist inclist[ MAXFILES ];
  42 extern char *includedirs[ ];
  43 extern char *notdotdot[ ];
  44
  45 struct inclist *inc_path(char *file, char *include, boolean dot, struct IncludesCollection *incCollection)
  46 {
  47     static char path[ BUFSIZ ];
  48     char   **pp, *p;
  49     struct inclist *ip;
  50     struct stat st;
  51     boolean found = FALSE;
  52     (void)dot;
  53
  54     /*
  55      * Check all previously found include files for a path that
  56      * has already been expanded.
  57      */
  58     for (ip = inclist; ip->i_file; ip++)
  59         if ((strcmp(ip->i_incstring, include) == 0) && !ip->i_included_sym)
  60         {
  61           found = TRUE;
  62           break;
  63         }
  64
  65     /*
  66      * If the path was surrounded by "" or is an absolute path,
  67      * then check the exact path provided.
  68      */
  69 // FIXME: creates duplicates in the dependency files if absolute paths are
  70 // given, which certainly is not the intended behavior. Also it slows down
  71 // makedepend performance considerably.
  72 //  if (!found && (dot || *include == '/')) {
  73 //
  74 //      if ((exists_path(incCollection, include)) && stat(include, &st) == 0 && !( st.st_mode & S_IFDIR)) {
  75 //          ip = newinclude(include, include);
  76 //          found = TRUE;
  77 //      }
  78 //      else if (show_where_not)
  79 //          warning1("\tnot in %s\n", include);
  80 //  }
  81
  82     /*
  83      * See if this include file is in the directory of the
  84      * file being compiled.
  85      */
  86     if (!found) {
  87         for (p=file+strlen(file); p>file; p--)
  88             if (*p == '/')
  89                 break;
  90         if (p == file)
  91         {
  92             if(strlen(include) >= BUFSIZ )
  93             {
  94                 fatalerr("include filename too long \"%s\"\n", include);
  95             }
  96             else
  97             {
  98                 strcpy(path, include);
  99             }
 100         }
 101         else
 102         {
 103             int partial = (p - file);
 104             size_t inc_len = strlen(include);
 105             if(inc_len + partial >= BUFSIZ )
 106             {
 107                 fatalerr("include filename too long \"%s\"\n", include);
 108             }
 109             else
 110             {
 111                 memcpy(path, file, partial);
 112                 memcpy(path + partial, include, inc_len);
 113                 path[partial + inc_len] = 0;
 114             }
 115         }
 116         remove_dotdot(path);
 117         if ((exists_path(incCollection, path)) && stat(path, &st) == 0 && !( st.st_mode & S_IFDIR)) {
 118             ip = newinclude(path, include);
 119             found = TRUE;
 120         }
 121         else if (show_where_not)
 122             warning1("\tnot in %s\n", path);
 123     }
 124
 125     /*
 126      * Check the include directories specified. (standard include dir
 127      * should be at the end.)
 128      */
 129     if (!found)
 130         for (pp = includedirs; *pp; pp++) {
 131             sprintf(path, "%s/%s", *pp, include);
 132             remove_dotdot(path);
 133             if ((exists_path(incCollection, path)) && stat(path, &st) == 0 && !(st.st_mode & S_IFDIR)) {
 134                 ip = newinclude(path, include);
 135                 found = TRUE;
 136                 break;
 137             }
 138             else if (show_where_not)
 139                 warning1("\tnot in %s\n", path);
 140         }
 141
 142     if (!found)
 143         ip = NULL;
 144     return ip;
 145 }
 146
 147 int exists_path(struct IncludesCollection *incCollection, char *path)
 148 {
 149     convert_slashes(path);
 150     return call_IncludesCollection_exists(incCollection, path);
 151 }
 152
 153 /*
 154  * Occasionally, pathnames are created that look like .../x/../y
 155  * Any of the 'x/..' sequences within the name can be eliminated.
 156  * (but only if 'x' is not a symbolic link!!)
 157  */
 158 void remove_dotdot(char *path)
 159 {
 160     char    *end, *from, *to, **cp;
 161     char    *components[ MAXFILES ],
 162             newpath[ BUFSIZ ];
 163     boolean     component_copied;
 164
 165     /*
 166      * slice path up into components.
 167      */
 168     to = newpath;
 169     if (*path == '/')
 170         *to++ = '/';
 171     *to = '\0';
 172     cp = components;
 173     for (from=end=path; *end; end++)
 174         if (*end == '/') {
 175             while (*end == '/')
 176                 *end++ = '\0';
 177             if (*from)
 178                 *cp++ = from;
 179             from = end;
 180         }
 181     *cp++ = from;
 182     *cp = NULL;
 183
 184     /*
 185      * Recursively remove all 'x/..' component pairs.
 186      */
 187     cp = components;
 188     while(*cp) {
 189         if (!isdot(*cp) && !isdotdot(*cp) && isdotdot(*(cp+1))
 190             && !issymbolic(newpath, *cp))
 191         {
 192             char **fp = cp + 2;
 193             char **tp = cp;
 194
 195             do {
 196               *tp++ = *fp; /* move all the pointers down */
 197             } while (*fp++);
 198             if (cp != components)
 199             cp--;   /* go back and check for nested ".." */
 200         } else {
 201             cp++;
 202         }
 203     }
 204     /*
 205      * Concatenate the remaining path elements.
 206      */
 207     cp = components;
 208     component_copied = FALSE;
 209     while(*cp) {
 210         if (component_copied)
 211             *to++ = '/';
 212         component_copied = TRUE;
 213         for (from = *cp; *from; )
 214             *to++ = *from++;
 215         *to = '\0';
 216         cp++;
 217     }
 218     *to++ = '\0';
 219
 220     /*
 221      * copy the reconstituted path back to our pointer.
 222      */
 223     strcpy(path, newpath);
 224 }
 225
 226 int isdot(char const *p)
 227 {
 228     if(p && p[0] == '.' && p[1] == '\0')
 229         return TRUE;
 230     return FALSE;
 231 }
 232
 233 int isdotdot(char const *p)
 234 {
 235     if(p && p[0] == '.' && p[1] == '.' && p[2] == '\0')
 236         return TRUE;
 237     return FALSE;
 238 }
 239
 240 int issymbolic(char *dir, char *component)
 241 {
 242 #ifdef S_IFLNK
 243     struct stat st;
 244     char    buf[ BUFSIZ ], **pp;
 245
 246     sprintf(buf, "%s%s%s", dir, *dir ? "/" : "", component);
 247     for (pp=notdotdot; *pp; pp++)
 248         if (strcmp(*pp, buf) == 0)
 249             return TRUE;
 250     if (lstat(buf, &st) == 0
 251     && (st.st_mode & S_IFMT) == S_IFLNK) {
 252         *pp++ = copy(buf);
 253         if (pp >= &notdotdot[ MAXDIRS ])
 254             fatalerr("out of .. dirs, increase MAXDIRS\n");
 255         return TRUE;
 256     }
 257 #else
 258     (void)dir; (void)component;
 259 #endif
 260     return FALSE;
 261 }
 262
 263 /*
 264  * Add an include file to the list of those included by 'file'.
 265  */
 266 struct inclist *newinclude(char const *newfile, char const *incstring)
 267 {
 268     struct inclist *ip;
 269
 270     /*
 271      * First, put this file on the global list of include files.
 272      */
 273     ip = inclistp++;
 274     if (inclistp == inclist + MAXFILES - 1)
 275         fatalerr("out of space: increase MAXFILES\n");
 276     ip->i_file = copy(newfile);
 277     ip->i_included_sym = FALSE;
 278     if (incstring == NULL)
 279         ip->i_incstring = ip->i_file;
 280     else
 281         ip->i_incstring = copy(incstring);
 282
 283     return ip;
 284 }
 285
 286 void included_by(struct inclist *ip, struct inclist *newfile)
 287 {
 288     int i;
 289
 290     if (ip == NULL)
 291         return;
 292     /*
 293      * Put this include file (newfile) on the list of files included
 294      * by 'file'.  If 'file' is NULL, then it is not an include
 295      * file itself (i.e. was probably mentioned on the command line).
 296      * If it is already on the list, don't stick it on again.
 297      */
 298     if (ip->i_list == NULL)
 299         ip->i_list = (struct inclist **)
 300             malloc(sizeof(struct inclist *) * ++ip->i_listlen);
 301     else {
 302         for (i=0; i<ip->i_listlen; i++)
 303             if (ip->i_list[ i ] == newfile) {
 304                 i = (int)strlen(newfile->i_file);
 305                 if (!ip->i_included_sym &&
 306                 !(i > 2 &&
 307                   newfile->i_file[i-1] == 'c' &&
 308                   newfile->i_file[i-2] == '.'))
 309                 {
 310                 /* only complain if ip has */
 311                 /* no #include SYMBOL lines  */
 312                 /* and is not a .c file */
 313                 if (warn_multiple)
 314                 {
 315                     warning("%s includes %s more than once!\n",
 316                         ip->i_file, newfile->i_file);
 317                     warning1("Already have\n");
 318                     for (i=0; i<ip->i_listlen; i++)
 319                         warning1("\t%s\n", ip->i_list[i]->i_file);
 320                 }
 321                 }
 322                 return;
 323             }
 324         ip->i_list = (struct inclist **) realloc(ip->i_list,
 325             sizeof(struct inclist *) * ++ip->i_listlen);
 326     }
 327     ip->i_list[ ip->i_listlen-1 ] = newfile;
 328 }
 329
 330 void inc_clean (void)
 331 {
 332     struct inclist *ip;
 333
 334     for (ip = inclist; ip < inclistp; ip++) {
 335         ip->i_marked = FALSE;
 336     }
 337 }
 338
 339 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */