tools/cyrus-imapd-makedepend/include.c

/* $XConsortium: include.c,v 1.16 94/04/17 20:10:34 gildea Exp $ */

/*
 * Copyright (c) 1998-2003 Carnegie Mellon University.  All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer. 
 *
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * 3. The name "Carnegie Mellon University" must not be used to
 *    endorse or promote products derived from this software without
 *    prior written permission. For permission or any other legal
 *    details, please contact  
 *      Office of Technology Transfer
 *      Carnegie Mellon University
 *      5000 Forbes Avenue
 *      Pittsburgh, PA  15213-3890
 *      (412) 268-4387, fax: (412) 268-7395
 *      tech-transfer@andrew.cmu.edu
 *
 * 4. Redistributions of any form whatsoever must retain the following
 *    acknowledgment:
 *    "This product includes software developed by Computing Services
 *     at Carnegie Mellon University (http://www.cmu.edu/computing/)."
 *
 * CARNEGIE MELLON UNIVERSITY DISCLAIMS ALL WARRANTIES WITH REGARD TO
 * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
 * AND FITNESS, IN NO EVENT SHALL CARNEGIE MELLON UNIVERSITY BE LIABLE
 * FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
 * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
 * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 *
 */
/*

Copyright (c) 1993, 1994  X Consortium

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

Except as contained in this notice, the name of the X Consortium shall not be
used in advertising or otherwise to promote the sale, use or other dealings
in this Software without prior written authorization from the X Consortium.

*/


#include "def.h"

extern struct   inclist inclist[ MAXFILES ],
                        *inclistp;
extern char     *includedirs[ ];
extern char     *notdotdot[ ];
extern boolean show_where_not;
extern boolean warn_multiple;

struct inclist *inc_path(file, include, dot)
        register char   *file,
                        *include;
        boolean dot;
{
        static char     path[ BUFSIZ ];
        register char           **pp, *p;
        register struct inclist *ip;
        struct stat     st;
        boolean found = FALSE;

        /*
         * Check all previously found include files for a path that
         * has already been expanded.
         */
        for (ip = inclist; ip->i_file; ip++)
            if ((strcmp(ip->i_incstring, include) == 0) && !ip->i_included_sym)
            {
                found = TRUE;
                break;
            }

        /*
         * If the path was surrounded by "" or is an absolute path,
         * then check the exact path provided.
         */
        if (!found && (dot || *include == '/')) {
                if (stat(include, &st) == 0) {
                        ip = newinclude(include, include);
                        found = TRUE;
                }
                else if (show_where_not)
                        warning1("\tnot in %s\n", include);
        }

        /*
         * See if this include file is in the directory of the
         * file being compiled.
         */
        if (!found) {
                for (p=file+strlen(file); p>file; p--)
                        if (*p == '/')
                                break;
                if (p == file)
                        strcpy(path, include);
                else {
                        strncpy(path, file, (p-file) + 1);
                        path[ (p-file) + 1 ] = '\0';
                        strcpy(path + (p-file) + 1, include);
                }
                remove_dotdot(path);
                if (stat(path, &st) == 0) {
                        ip = newinclude(path, include);
                        found = TRUE;
                }
                else if (show_where_not)
                        warning1("\tnot in %s\n", path);
        }

        /*
         * Check the include directories specified. (standard include dir
         * should be at the end.)
         */
        if (!found)
                for (pp = includedirs; *pp; pp++) {
                        sprintf(path, "%s/%s", *pp, include);
                        remove_dotdot(path);
                        if (stat(path, &st) == 0) {
                                ip = newinclude(path, include);
                                found = TRUE;
                                break;
                        }
                        else if (show_where_not)
                                warning1("\tnot in %s\n", path);
                }

        if (!found)
                ip = NULL;
        return(ip);
}

/*
 * Ocaisionally, pathnames are created that look like ../x/../y
 * Any of the 'x/..' sequences within the name can be eliminated.
 * (but only if 'x' is not a symbolic link!!)
 */
remove_dotdot(path)
        char    *path;
{
        register char   *end, *from, *to, **cp;
        char            *components[ MAXFILES ],
                        newpath[ BUFSIZ ];
        boolean         component_copied;

        /*
         * slice path up into components.
         */
        to = newpath;
        if (*path == '/')
                *to++ = '/';
        *to = '\0';
        cp = components;
        for (from=end=path; *end; end++)
                if (*end == '/') {
                        while (*end == '/')
                                *end++ = '\0';
                        if (*from)
                                *cp++ = from;
                        from = end;
                }
        *cp++ = from;
        *cp = NULL;

        /*
         * Now copy the path, removing all 'x/..' components.
         */
        cp = components;
        component_copied = FALSE;
        while(*cp) {
                if (!isdot(*cp) && !isdotdot(*cp) && isdotdot(*(cp+1))) {
                        if (issymbolic(newpath, *cp))
                                goto dont_remove;
                        cp++;
                } else {
                dont_remove:
                        if (component_copied)
                                *to++ = '/';
                        component_copied = TRUE;
                        for (from = *cp; *from; )
                                *to++ = *from++;
                        *to = '\0';
                }
                cp++;
        }
        *to++ = '\0';

        /*
         * copy the reconstituted path back to our pointer.
         */
        strcpy(path, newpath);
}

isdot(p)
        register char   *p;
{
        if(p && *p++ == '.' && *p++ == '\0')
                return(TRUE);
        return(FALSE);
}

isdotdot(p)
        register char   *p;
{
        if(p && *p++ == '.' && *p++ == '.' && *p++ == '\0')
                return(TRUE);
        return(FALSE);
}

issymbolic(dir, component)
        register char   *dir, *component;
{
#ifdef S_IFLNK
        struct stat     st;
        char    buf[ BUFSIZ ], **pp;

        sprintf(buf, "%s%s%s", dir, *dir ? "/" : "", component);
        for (pp=notdotdot; *pp; pp++)
                if (strcmp(*pp, buf) == 0)
                        return (TRUE);
        if (lstat(buf, &st) == 0
        && (st.st_mode & S_IFMT) == S_IFLNK) {
                *pp++ = copy(buf);
                if (pp >= &notdotdot[ MAXDIRS ])
                        fatalerr("out of .. dirs, increase MAXDIRS\n");
                return(TRUE);
        }
#endif
        return(FALSE);
}

/*
 * Add an include file to the list of those included by 'file'.
 */
struct inclist *newinclude(newfile, incstring)
        register char   *newfile, *incstring;
{
        register struct inclist *ip;

        /*
         * First, put this file on the global list of include files.
         */
        ip = inclistp++;
        if (inclistp == inclist + MAXFILES - 1)
                fatalerr("out of space: increase MAXFILES\n");
        ip->i_file = copy(newfile);
        ip->i_included_sym = FALSE;
        if (incstring == NULL)
                ip->i_incstring = ip->i_file;
        else
                ip->i_incstring = copy(incstring);

        return(ip);
}

included_by(ip, newfile)
        register struct inclist *ip, *newfile;
{
        register i;

        if (ip == NULL)
                return;
        /*
         * Put this include file (newfile) on the list of files included
         * by 'file'.  If 'file' is NULL, then it is not an include
         * file itself (i.e. was probably mentioned on the command line).
         * If it is already on the list, don't stick it on again.
         */
        if (ip->i_list == NULL)
                ip->i_list = (struct inclist **)
                        malloc(sizeof(struct inclist *) * ++ip->i_listlen);
        else {
                for (i=0; i<ip->i_listlen; i++)
                        if (ip->i_list[ i ] == newfile) {
                            i = strlen(newfile->i_file);
                            if (!ip->i_included_sym &&
                                !(i > 2 &&
                                  newfile->i_file[i-1] == 'c' &&
                                  newfile->i_file[i-2] == '.'))
                            {
                                /* only bitch if ip has */
                                /* no #include SYMBOL lines  */
                                /* and is not a .c file */
                                if (warn_multiple)
                                {
                                        warning("%s includes %s more than once!\n",
                                                ip->i_file, newfile->i_file);
                                        warning1("Already have\n");
                                        for (i=0; i<ip->i_listlen; i++)
                                                warning1("\t%s\n", ip->i_list[i]->i_file);
                                }
                            }
                            return;
                        }
                ip->i_list = (struct inclist **) realloc(ip->i_list,
                        sizeof(struct inclist *) * ++ip->i_listlen);
        }
        ip->i_list[ ip->i_listlen-1 ] = newfile;
}

inc_clean ()
{
        register struct inclist *ip;

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