config/mkdepend/include.c

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