![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to include.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv9 / X11 / src / X.V11R1 / util / makedepend|
Return to include.c CVS log | Up to [Research Unix] / researchv9 / X11 / src / X.V11R1 / util / makedepend |
1.1 root 1: /*
2: * $Header: include.c,v 1.3 87/08/14 18:14:41 toddb Exp $
3: *
4: * $Log: include.c,v $
5: * Revision 1.3 87/08/14 18:14:41 toddb
6: * Add the routine inc_clean(). This will "un-mark" all nodes after traversal,
7: * so that during traversal, no node is printed more than once.
8: *
9: * Revision 1.2 87/08/06 17:40:34 toddb
10: * Bug in removing .. (removedotdot).
11: *
12: * Revision 1.1 87/08/06 17:34:55 toddb
13: * Initial revision
14: *
15: * Revision 1.1 87/04/08 16:40:43 rich
16: * Initial revision
17: *
18: * Revision 1.1 86/04/15 08:34:26 toddb
19: * Initial revision
20: *
21: */
22: #include "def.h"
23:
24: extern struct inclist inclist[ MAXFILES ],
25: *inclistp;
26: extern char *includedirs[ ];
27: extern char *notdotdot[ ];
28: extern boolean show_where_not;
29:
30: struct inclist *inc_path(file, include, dot)
31: register char *file,
32: *include;
33: boolean dot;
34: {
35: static char path[ BUFSIZ ];
36: register char **pp, *p;
37: register struct inclist *ip;
38: struct stat st;
39: boolean found = FALSE;
40:
41: /*
42: * Check all previously found include files for a path that
43: * has already been expanded.
44: */
45: for (ip = inclist; ip->i_file; ip++)
46: if (strcmp(ip->i_incstring, include) == 0) {
47: found = TRUE;
48: break;
49: }
50:
51: /*
52: * If the path was surrounded by "", then check the absolute
53: * path provided.
54: */
55: if (!found && dot) {
56: if (stat(include, &st) == 0) {
57: ip = newinclude(include, include);
58: found = TRUE;
59: }
60: else if (show_where_not)
61: log("\tnot in %s\n", include);
62: }
63:
64: /*
65: * See if this include file is in the directory of the
66: * file being compiled.
67: */
68: if (!found) {
69: for (p=file+strlen(file); p>file; p--)
70: if (*p == '/')
71: break;
72: if (p == file)
73: strcpy(path, include);
74: else {
75: strncpy(path, file, (p-file) + 1);
76: path[ (p-file) + 1 ] = '\0';
77: strcpy(path + (p-file) + 1, include);
78: }
79: remove_dotdot(path);
80: if (stat(path, &st) == 0) {
81: ip = newinclude(path, include);
82: found = TRUE;
83: }
84: else if (show_where_not)
85: log("\tnot in %s\n", path);
86: }
87:
88: /*
89: * Check the include directories specified. (standard include dir
90: * should be at the end.)
91: */
92: if (!found)
93: for (pp = includedirs; *pp; pp++) {
94: sprintf(path, "%s/%s", *pp, include);
95: remove_dotdot(path);
96: if (stat(path, &st) == 0) {
97: ip = newinclude(path, include);
98: found = TRUE;
99: break;
100: }
101: else if (show_where_not)
102: log("\tnot in %s\n", path);
103: }
104:
105: if (!found) {
106: /*
107: * If we've announced where it's not include it anyway so
108: * it gets on the dependency list.
109: */
110: if (show_where_not)
111: ip = newinclude(include, include);
112: else
113: ip = NULL;
114: }
115: return(ip);
116: }
117:
118: /*
119: * Ocaisionally, pathnames are created that look like ../x/../y
120: * Any of the 'x/..' sequences within the name can be eliminated.
121: * (but only if 'x' is not a symbolic link!!)
122: */
123: remove_dotdot(path)
124: char *path;
125: {
126: register char *end, *from, *to, **cp;
127: char *components[ MAXFILES ],
128: newpath[ BUFSIZ ];
129: boolean component_copied;
130:
131: /*
132: * slice path up into components.
133: */
134: to = newpath;
135: if (*path == '/')
136: *to++ = '/';
137: *to = '\0';
138: cp = components;
139: for (from=end=path; *end; end++)
140: if (*end == '/') {
141: while (*end == '/')
142: *end++ = '\0';
143: if (*from)
144: *cp++ = from;
145: from = end;
146: }
147: *cp++ = from;
148: *cp = NULL;
149:
150: /*
151: * Now copy the path, removing all 'x/..' components.
152: */
153: cp = components;
154: component_copied = FALSE;
155: while(*cp) {
156: if (!isdot(*cp) && !isdotdot(*cp) && isdotdot(*(cp+1))) {
157: if (issymbolic(newpath, *cp))
158: goto dont_remove;
159: cp++;
160: } else {
161: dont_remove:
162: if (component_copied)
163: *to++ = '/';
164: component_copied = TRUE;
165: for (from = *cp; *from; )
166: *to++ = *from++;
167: *to = '\0';
168: }
169: cp++;
170: }
171: *to++ = '\0';
172:
173: /*
174: * copy the reconstituted path back to our pointer.
175: */
176: strcpy(path, newpath);
177: }
178:
179: isdot(p)
180: register char *p;
181: {
182: if(p && *p++ == '.' && *p++ == '\0')
183: return(TRUE);
184: return(FALSE);
185: }
186:
187: isdotdot(p)
188: register char *p;
189: {
190: if(p && *p++ == '.' && *p++ == '.' && *p++ == '\0')
191: return(TRUE);
192: return(FALSE);
193: }
194:
195: issymbolic(dir, component)
196: register char *dir, *component;
197: {
198: struct stat st;
199: char buf[ BUFSIZ ], **pp;
200:
201: sprintf(buf, "%s%s%s", dir, *dir ? "/" : "", component);
202: for (pp=notdotdot; *pp; pp++)
203: if (strcmp(*pp, buf) == 0)
204: return (TRUE);
205: if (lstat(buf, &st) == 0
206: && (st.st_mode & S_IFMT) == S_IFLNK) {
207: *pp++ = copy(buf);
208: if (pp >= ¬dotdot[ MAXDIRS ])
209: log_fatal("out of .. dirs, increase MAXDIRS\n");
210: return(TRUE);
211: }
212: return(FALSE);
213: }
214:
215: /*
216: * Add an include file to the list of those included by 'file'.
217: */
218: struct inclist *newinclude(newfile, incstring)
219: register char *newfile, *incstring;
220: {
221: register struct inclist *ip;
222:
223: /*
224: * First, put this file on the global list of include files.
225: */
226: ip = inclistp++;
227: if (inclistp == inclist + MAXFILES - 1)
228: log_fatal("out of space: increase MAXFILES\n");
229: ip->i_file = copy(newfile);
230: if (incstring == NULL)
231: ip->i_incstring = ip->i_file;
232: else
233: ip->i_incstring = copy(incstring);
234:
235: return(ip);
236: }
237:
238: included_by(ip, newfile)
239: register struct inclist *ip, *newfile;
240: {
241: register i;
242:
243: if (ip == NULL)
244: return;
245: /*
246: * Put this include file (newfile) on the list of files included
247: * by 'file'. If 'file' is NULL, then it is not an include
248: * file itself (i.e. was probably mentioned on the command line).
249: * If it is already on the list, don't stick it on again.
250: */
251: if (ip->i_list == NULL)
252: ip->i_list = (struct inclist **)
253: malloc(sizeof(struct inclist *) * ++ip->i_listlen);
254: else {
255: for (i=0; i<ip->i_listlen; i++)
256: if (ip->i_list[ i ] == newfile) {
257: log("%s includes %s more than once!\n",
258: ip->i_file, newfile->i_file);
259: log("Already have\n");
260: for (i=0; i<ip->i_listlen; i++)
261: log("\t%s\n", ip->i_list[i]->i_file);
262: return;
263: }
264: ip->i_list = (struct inclist **) realloc(ip->i_list,
265: sizeof(struct inclist *) * ++ip->i_listlen);
266: }
267: ip->i_list[ ip->i_listlen-1 ] = newfile;
268: }
269:
270: inc_clean ()
271: {
272: register struct inclist *ip;
273:
274: for (ip = inclist; ip < inclistp; ip++) {
275: ip->i_marked = FALSE;
276: }
277: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.