Annotation of src/usr.bin/make/arch.c, Revision 1.1.1.1
1.1 deraadt 1: /* $NetBSD: arch.c,v 1.9 1995/06/14 15:18:46 christos Exp $ */
2:
3: /*
4: * Copyright (c) 1988, 1989, 1990 The Regents of the University of California.
5: * Copyright (c) 1988, 1989 by Adam de Boor
6: * Copyright (c) 1989 by Berkeley Softworks
7: * All rights reserved.
8: *
9: * This code is derived from software contributed to Berkeley by
10: * Adam de Boor.
11: *
12: * Redistribution and use in source and binary forms, with or without
13: * modification, are permitted provided that the following conditions
14: * are met:
15: * 1. Redistributions of source code must retain the above copyright
16: * notice, this list of conditions and the following disclaimer.
17: * 2. Redistributions in binary form must reproduce the above copyright
18: * notice, this list of conditions and the following disclaimer in the
19: * documentation and/or other materials provided with the distribution.
20: * 3. All advertising materials mentioning features or use of this software
21: * must display the following acknowledgement:
22: * This product includes software developed by the University of
23: * California, Berkeley and its contributors.
24: * 4. Neither the name of the University nor the names of its contributors
25: * may be used to endorse or promote products derived from this software
26: * without specific prior written permission.
27: *
28: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
29: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
30: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
31: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
32: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
33: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
34: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
35: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
36: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
37: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
38: * SUCH DAMAGE.
39: */
40:
41: #ifndef lint
42: #if 0
43: static char sccsid[] = "@(#)arch.c 5.7 (Berkeley) 12/28/90";
44: #else
45: static char rcsid[] = "$NetBSD: arch.c,v 1.9 1995/06/14 15:18:46 christos Exp $";
46: #endif
47: #endif /* not lint */
48:
49: /*-
50: * arch.c --
51: * Functions to manipulate libraries, archives and their members.
52: *
53: * Once again, cacheing/hashing comes into play in the manipulation
54: * of archives. The first time an archive is referenced, all of its members'
55: * headers are read and hashed and the archive closed again. All hashed
56: * archives are kept on a list which is searched each time an archive member
57: * is referenced.
58: *
59: * The interface to this module is:
60: * Arch_ParseArchive Given an archive specification, return a list
61: * of GNode's, one for each member in the spec.
62: * FAILURE is returned if the specification is
63: * invalid for some reason.
64: *
65: * Arch_Touch Alter the modification time of the archive
66: * member described by the given node to be
67: * the current time.
68: *
69: * Arch_TouchLib Update the modification time of the library
70: * described by the given node. This is special
71: * because it also updates the modification time
72: * of the library's table of contents.
73: *
74: * Arch_MTime Find the modification time of a member of
75: * an archive *in the archive*. The time is also
76: * placed in the member's GNode. Returns the
77: * modification time.
78: *
79: * Arch_MemTime Find the modification time of a member of
80: * an archive. Called when the member doesn't
81: * already exist. Looks in the archive for the
82: * modification time. Returns the modification
83: * time.
84: *
85: * Arch_FindLib Search for a library along a path. The
86: * library name in the GNode should be in
87: * -l<name> format.
88: *
89: * Arch_LibOODate Special function to decide if a library node
90: * is out-of-date.
91: *
92: * Arch_Init Initialize this module.
93: *
94: * Arch_End Cleanup this module.
95: */
96:
97: #include <sys/types.h>
98: #include <sys/stat.h>
99: #include <sys/time.h>
100: #include <sys/param.h>
101: #include <ctype.h>
102: #include <ar.h>
103: #include <ranlib.h>
104: #include <stdio.h>
105: #include <stdlib.h>
106: #include "make.h"
107: #include "hash.h"
108: #include "dir.h"
109: #include "config.h"
110:
111: static Lst archives; /* Lst of archives we've already examined */
112:
113: typedef struct Arch {
114: char *name; /* Name of archive */
115: Hash_Table members; /* All the members of the archive described
116: * by <name, struct ar_hdr *> key/value pairs */
117: } Arch;
118:
119: static int ArchFindArchive __P((ClientData, ClientData));
120: static void ArchFree __P((ClientData));
121: static struct ar_hdr *ArchStatMember __P((char *, char *, Boolean));
122: static FILE *ArchFindMember __P((char *, char *, struct ar_hdr *, char *));
123:
124: /*-
125: *-----------------------------------------------------------------------
126: * ArchFree --
127: * Free memory used by an archive
128: *
129: * Results:
130: * None.
131: *
132: * Side Effects:
133: * None.
134: *
135: *-----------------------------------------------------------------------
136: */
137: static void
138: ArchFree(ap)
139: ClientData ap;
140: {
141: Arch *a = (Arch *) ap;
142: Hash_Search search;
143: Hash_Entry *entry;
144:
145: /* Free memory from hash entries */
146: for (entry = Hash_EnumFirst(&a->members, &search);
147: entry != (Hash_Entry *)NULL;
148: entry = Hash_EnumNext(&search))
149: free((Address) Hash_GetValue (entry));
150:
151: free(a->name);
152: Hash_DeleteTable(&a->members);
153: free((Address) a);
154: }
155:
156:
157:
158: /*-
159: *-----------------------------------------------------------------------
160: * Arch_ParseArchive --
161: * Parse the archive specification in the given line and find/create
162: * the nodes for the specified archive members, placing their nodes
163: * on the given list.
164: *
165: * Results:
166: * SUCCESS if it was a valid specification. The linePtr is updated
167: * to point to the first non-space after the archive spec. The
168: * nodes for the members are placed on the given list.
169: *
170: * Side Effects:
171: * Some nodes may be created. The given list is extended.
172: *
173: *-----------------------------------------------------------------------
174: */
175: ReturnStatus
176: Arch_ParseArchive (linePtr, nodeLst, ctxt)
177: char **linePtr; /* Pointer to start of specification */
178: Lst nodeLst; /* Lst on which to place the nodes */
179: GNode *ctxt; /* Context in which to expand variables */
180: {
181: register char *cp; /* Pointer into line */
182: GNode *gn; /* New node */
183: char *libName; /* Library-part of specification */
184: char *memName; /* Member-part of specification */
185: char nameBuf[MAKE_BSIZE]; /* temporary place for node name */
186: char saveChar; /* Ending delimiter of member-name */
187: Boolean subLibName; /* TRUE if libName should have/had
188: * variable substitution performed on it */
189:
190: libName = *linePtr;
191:
192: subLibName = FALSE;
193:
194: for (cp = libName; *cp != '(' && *cp != '\0'; cp++) {
195: if (*cp == '$') {
196: /*
197: * Variable spec, so call the Var module to parse the puppy
198: * so we can safely advance beyond it...
199: */
200: int length;
201: Boolean freeIt;
202: char *result;
203:
204: result=Var_Parse(cp, ctxt, TRUE, &length, &freeIt);
205: if (result == var_Error) {
206: return(FAILURE);
207: } else {
208: subLibName = TRUE;
209: }
210:
211: if (freeIt) {
212: free(result);
213: }
214: cp += length-1;
215: }
216: }
217:
218: *cp++ = '\0';
219: if (subLibName) {
220: libName = Var_Subst(NULL, libName, ctxt, TRUE);
221: }
222:
223:
224: for (;;) {
225: /*
226: * First skip to the start of the member's name, mark that
227: * place and skip to the end of it (either white-space or
228: * a close paren).
229: */
230: Boolean doSubst = FALSE; /* TRUE if need to substitute in memName */
231:
232: while (*cp != '\0' && *cp != ')' && isspace (*cp)) {
233: cp++;
234: }
235: memName = cp;
236: while (*cp != '\0' && *cp != ')' && !isspace (*cp)) {
237: if (*cp == '$') {
238: /*
239: * Variable spec, so call the Var module to parse the puppy
240: * so we can safely advance beyond it...
241: */
242: int length;
243: Boolean freeIt;
244: char *result;
245:
246: result=Var_Parse(cp, ctxt, TRUE, &length, &freeIt);
247: if (result == var_Error) {
248: return(FAILURE);
249: } else {
250: doSubst = TRUE;
251: }
252:
253: if (freeIt) {
254: free(result);
255: }
256: cp += length;
257: } else {
258: cp++;
259: }
260: }
261:
262: /*
263: * If the specification ends without a closing parenthesis,
264: * chances are there's something wrong (like a missing backslash),
265: * so it's better to return failure than allow such things to happen
266: */
267: if (*cp == '\0') {
268: printf("No closing parenthesis in archive specification\n");
269: return (FAILURE);
270: }
271:
272: /*
273: * If we didn't move anywhere, we must be done
274: */
275: if (cp == memName) {
276: break;
277: }
278:
279: saveChar = *cp;
280: *cp = '\0';
281:
282: /*
283: * XXX: This should be taken care of intelligently by
284: * SuffExpandChildren, both for the archive and the member portions.
285: */
286: /*
287: * If member contains variables, try and substitute for them.
288: * This will slow down archive specs with dynamic sources, of course,
289: * since we'll be (non-)substituting them three times, but them's
290: * the breaks -- we need to do this since SuffExpandChildren calls
291: * us, otherwise we could assume the thing would be taken care of
292: * later.
293: */
294: if (doSubst) {
295: char *buf;
296: char *sacrifice;
297: char *oldMemName = memName;
298:
299: memName = Var_Subst(NULL, memName, ctxt, TRUE);
300:
301: /*
302: * Now form an archive spec and recurse to deal with nested
303: * variables and multi-word variable values.... The results
304: * are just placed at the end of the nodeLst we're returning.
305: */
306: buf = sacrifice = emalloc(strlen(memName)+strlen(libName)+3);
307:
308: sprintf(buf, "%s(%s)", libName, memName);
309:
310: if (strchr(memName, '$') && strcmp(memName, oldMemName) == 0) {
311: /*
312: * Must contain dynamic sources, so we can't deal with it now.
313: * Just create an ARCHV node for the thing and let
314: * SuffExpandChildren handle it...
315: */
316: gn = Targ_FindNode(buf, TARG_CREATE);
317:
318: if (gn == NILGNODE) {
319: free(buf);
320: return(FAILURE);
321: } else {
322: gn->type |= OP_ARCHV;
323: (void)Lst_AtEnd(nodeLst, (ClientData)gn);
324: }
325: } else if (Arch_ParseArchive(&sacrifice, nodeLst, ctxt)!=SUCCESS) {
326: /*
327: * Error in nested call -- free buffer and return FAILURE
328: * ourselves.
329: */
330: free(buf);
331: return(FAILURE);
332: }
333: /*
334: * Free buffer and continue with our work.
335: */
336: free(buf);
337: } else if (Dir_HasWildcards(memName)) {
338: Lst members = Lst_Init(FALSE);
339: char *member;
340:
341: Dir_Expand(memName, dirSearchPath, members);
342: while (!Lst_IsEmpty(members)) {
343: member = (char *)Lst_DeQueue(members);
344:
345: sprintf(nameBuf, "%s(%s)", libName, member);
346: free(member);
347: gn = Targ_FindNode (nameBuf, TARG_CREATE);
348: if (gn == NILGNODE) {
349: return (FAILURE);
350: } else {
351: /*
352: * We've found the node, but have to make sure the rest of
353: * the world knows it's an archive member, without having
354: * to constantly check for parentheses, so we type the
355: * thing with the OP_ARCHV bit before we place it on the
356: * end of the provided list.
357: */
358: gn->type |= OP_ARCHV;
359: (void) Lst_AtEnd (nodeLst, (ClientData)gn);
360: }
361: }
362: Lst_Destroy(members, NOFREE);
363: } else {
364: sprintf(nameBuf, "%s(%s)", libName, memName);
365: gn = Targ_FindNode (nameBuf, TARG_CREATE);
366: if (gn == NILGNODE) {
367: return (FAILURE);
368: } else {
369: /*
370: * We've found the node, but have to make sure the rest of the
371: * world knows it's an archive member, without having to
372: * constantly check for parentheses, so we type the thing with
373: * the OP_ARCHV bit before we place it on the end of the
374: * provided list.
375: */
376: gn->type |= OP_ARCHV;
377: (void) Lst_AtEnd (nodeLst, (ClientData)gn);
378: }
379: }
380: if (doSubst) {
381: free(memName);
382: }
383:
384: *cp = saveChar;
385: }
386:
387: /*
388: * If substituted libName, free it now, since we need it no longer.
389: */
390: if (subLibName) {
391: free(libName);
392: }
393:
394: /*
395: * We promised the pointer would be set up at the next non-space, so
396: * we must advance cp there before setting *linePtr... (note that on
397: * entrance to the loop, cp is guaranteed to point at a ')')
398: */
399: do {
400: cp++;
401: } while (*cp != '\0' && isspace (*cp));
402:
403: *linePtr = cp;
404: return (SUCCESS);
405: }
406:
407: /*-
408: *-----------------------------------------------------------------------
409: * ArchFindArchive --
410: * See if the given archive is the one we are looking for. Called
411: * From ArchStatMember and ArchFindMember via Lst_Find.
412: *
413: * Results:
414: * 0 if it is, non-zero if it isn't.
415: *
416: * Side Effects:
417: * None.
418: *
419: *-----------------------------------------------------------------------
420: */
421: static int
422: ArchFindArchive (ar, archName)
423: ClientData ar; /* Current list element */
424: ClientData archName; /* Name we want */
425: {
426: return (strcmp ((char *) archName, ((Arch *) ar)->name));
427: }
428:
429: /*-
430: *-----------------------------------------------------------------------
431: * ArchStatMember --
432: * Locate a member of an archive, given the path of the archive and
433: * the path of the desired member.
434: *
435: * Results:
436: * A pointer to the current struct ar_hdr structure for the member. Note
437: * That no position is returned, so this is not useful for touching
438: * archive members. This is mostly because we have no assurances that
439: * The archive will remain constant after we read all the headers, so
440: * there's not much point in remembering the position...
441: *
442: * Side Effects:
443: *
444: *-----------------------------------------------------------------------
445: */
446: static struct ar_hdr *
447: ArchStatMember (archive, member, hash)
448: char *archive; /* Path to the archive */
449: char *member; /* Name of member. If it is a path, only the
450: * last component is used. */
451: Boolean hash; /* TRUE if archive should be hashed if not
452: * already so. */
453: {
454: #define AR_MAX_NAME_LEN (sizeof(arh.ar_name)-1)
455: FILE * arch; /* Stream to archive */
456: int size; /* Size of archive member */
457: char *cp; /* Useful character pointer */
458: char magic[SARMAG];
459: LstNode ln; /* Lst member containing archive descriptor */
460: Arch *ar; /* Archive descriptor */
461: Hash_Entry *he; /* Entry containing member's description */
462: struct ar_hdr arh; /* archive-member header for reading archive */
463: char memName[MAXPATHLEN+1];
464: /* Current member name while hashing. */
465:
466: /*
467: * Because of space constraints and similar things, files are archived
468: * using their final path components, not the entire thing, so we need
469: * to point 'member' to the final component, if there is one, to make
470: * the comparisons easier...
471: */
472: cp = strrchr (member, '/');
473: if (cp != (char *) NULL) {
474: member = cp + 1;
475: }
476:
477: ln = Lst_Find (archives, (ClientData) archive, ArchFindArchive);
478: if (ln != NILLNODE) {
479: ar = (Arch *) Lst_Datum (ln);
480:
481: he = Hash_FindEntry (&ar->members, member);
482:
483: if (he != (Hash_Entry *) NULL) {
484: return ((struct ar_hdr *) Hash_GetValue (he));
485: } else {
486: /* Try truncated name */
487: char copy[AR_MAX_NAME_LEN+1];
488: int len = strlen (member);
489:
490: if (len > AR_MAX_NAME_LEN) {
491: len = AR_MAX_NAME_LEN;
492: strncpy(copy, member, AR_MAX_NAME_LEN);
493: copy[AR_MAX_NAME_LEN] = '\0';
494: }
495: if (he = Hash_FindEntry (&ar->members, copy))
496: return ((struct ar_hdr *) Hash_GetValue (he));
497: return ((struct ar_hdr *) NULL);
498: }
499: }
500:
501: if (!hash) {
502: /*
503: * Caller doesn't want the thing hashed, just use ArchFindMember
504: * to read the header for the member out and close down the stream
505: * again. Since the archive is not to be hashed, we assume there's
506: * no need to allocate extra room for the header we're returning,
507: * so just declare it static.
508: */
509: static struct ar_hdr sarh;
510:
511: arch = ArchFindMember(archive, member, &sarh, "r");
512:
513: if (arch == (FILE *)NULL) {
514: return ((struct ar_hdr *)NULL);
515: } else {
516: fclose(arch);
517: return (&sarh);
518: }
519: }
520:
521: /*
522: * We don't have this archive on the list yet, so we want to find out
523: * everything that's in it and cache it so we can get at it quickly.
524: */
525: arch = fopen (archive, "r");
526: if (arch == (FILE *) NULL) {
527: return ((struct ar_hdr *) NULL);
528: }
529:
530: /*
531: * We use the ARMAG string to make sure this is an archive we
532: * can handle...
533: */
534: if ((fread (magic, SARMAG, 1, arch) != 1) ||
535: (strncmp (magic, ARMAG, SARMAG) != 0)) {
536: fclose (arch);
537: return ((struct ar_hdr *) NULL);
538: }
539:
540: ar = (Arch *)emalloc (sizeof (Arch));
541: ar->name = strdup (archive);
542: Hash_InitTable (&ar->members, -1);
543: memName[AR_MAX_NAME_LEN] = '\0';
544:
545: while (fread ((char *)&arh, sizeof (struct ar_hdr), 1, arch) == 1) {
546: if (strncmp ( arh.ar_fmag, ARFMAG, sizeof (arh.ar_fmag)) != 0) {
547: /*
548: * The header is bogus, so the archive is bad
549: * and there's no way we can recover...
550: */
551: fclose (arch);
552: Hash_DeleteTable (&ar->members);
553: free ((Address)ar);
554: return ((struct ar_hdr *) NULL);
555: } else {
556: (void) strncpy (memName, arh.ar_name, sizeof(arh.ar_name));
557: for (cp = &memName[AR_MAX_NAME_LEN]; *cp == ' '; cp--) {
558: continue;
559: }
560: cp[1] = '\0';
561:
562: #ifdef AR_EFMT1
563: /*
564: * BSD 4.4 extended AR format: #1/<namelen>, with name as the
565: * first <namelen> bytes of the file
566: */
567: if (strncmp(memName, AR_EFMT1, sizeof(AR_EFMT1) - 1) == 0 &&
568: isdigit(memName[sizeof(AR_EFMT1) - 1])) {
569:
570: unsigned int elen = atoi(&memName[sizeof(AR_EFMT1)-1]);
571:
572: if (elen > MAXPATHLEN) {
573: fclose (arch);
574: Hash_DeleteTable (&ar->members);
575: free ((Address)ar);
576: return ((struct ar_hdr *) NULL);
577: }
578: if (fread (memName, elen, 1, arch) != 1) {
579: fclose (arch);
580: Hash_DeleteTable (&ar->members);
581: free ((Address)ar);
582: return ((struct ar_hdr *) NULL);
583: }
584: memName[elen] = '\0';
585: fseek (arch, -elen, 1);
586: if (DEBUG(ARCH) || DEBUG(MAKE)) {
587: printf("ArchStat: Extended format entry for %s\n", memName);
588: }
589: }
590: #endif
591:
592: he = Hash_CreateEntry (&ar->members, memName, (Boolean *)NULL);
593: Hash_SetValue (he, (ClientData)emalloc (sizeof (struct ar_hdr)));
594: memcpy ((Address)Hash_GetValue (he), (Address)&arh,
595: sizeof (struct ar_hdr));
596: }
597: /*
598: * We need to advance the stream's pointer to the start of the
599: * next header. Files are padded with newlines to an even-byte
600: * boundary, so we need to extract the size of the file from the
601: * 'size' field of the header and round it up during the seek.
602: */
603: arh.ar_size[sizeof(arh.ar_size)-1] = '\0';
604: size = (int) strtol(arh.ar_size, NULL, 10);
605: fseek (arch, (size + 1) & ~1, 1);
606: }
607:
608: fclose (arch);
609:
610: (void) Lst_AtEnd (archives, (ClientData) ar);
611:
612: /*
613: * Now that the archive has been read and cached, we can look into
614: * the hash table to find the desired member's header.
615: */
616: he = Hash_FindEntry (&ar->members, member);
617:
618: if (he != (Hash_Entry *) NULL) {
619: return ((struct ar_hdr *) Hash_GetValue (he));
620: } else {
621: return ((struct ar_hdr *) NULL);
622: }
623: }
624:
625: /*-
626: *-----------------------------------------------------------------------
627: * ArchFindMember --
628: * Locate a member of an archive, given the path of the archive and
629: * the path of the desired member. If the archive is to be modified,
630: * the mode should be "r+", if not, it should be "r".
631: *
632: * Results:
633: * An FILE *, opened for reading and writing, positioned at the
634: * start of the member's struct ar_hdr, or NULL if the member was
635: * nonexistent. The current struct ar_hdr for member.
636: *
637: * Side Effects:
638: * The passed struct ar_hdr structure is filled in.
639: *
640: *-----------------------------------------------------------------------
641: */
642: static FILE *
643: ArchFindMember (archive, member, arhPtr, mode)
644: char *archive; /* Path to the archive */
645: char *member; /* Name of member. If it is a path, only the
646: * last component is used. */
647: struct ar_hdr *arhPtr; /* Pointer to header structure to be filled in */
648: char *mode; /* The mode for opening the stream */
649: {
650: FILE * arch; /* Stream to archive */
651: int size; /* Size of archive member */
652: char *cp; /* Useful character pointer */
653: char magic[SARMAG];
654: int len, tlen;
655:
656: arch = fopen (archive, mode);
657: if (arch == (FILE *) NULL) {
658: return ((FILE *) NULL);
659: }
660:
661: /*
662: * We use the ARMAG string to make sure this is an archive we
663: * can handle...
664: */
665: if ((fread (magic, SARMAG, 1, arch) != 1) ||
666: (strncmp (magic, ARMAG, SARMAG) != 0)) {
667: fclose (arch);
668: return ((FILE *) NULL);
669: }
670:
671: /*
672: * Because of space constraints and similar things, files are archived
673: * using their final path components, not the entire thing, so we need
674: * to point 'member' to the final component, if there is one, to make
675: * the comparisons easier...
676: */
677: cp = strrchr (member, '/');
678: if (cp != (char *) NULL) {
679: member = cp + 1;
680: }
681: len = tlen = strlen (member);
682: if (len > sizeof (arhPtr->ar_name)) {
683: tlen = sizeof (arhPtr->ar_name);
684: }
685:
686: while (fread ((char *)arhPtr, sizeof (struct ar_hdr), 1, arch) == 1) {
687: if (strncmp(arhPtr->ar_fmag, ARFMAG, sizeof (arhPtr->ar_fmag) ) != 0) {
688: /*
689: * The header is bogus, so the archive is bad
690: * and there's no way we can recover...
691: */
692: fclose (arch);
693: return ((FILE *) NULL);
694: } else if (strncmp (member, arhPtr->ar_name, tlen) == 0) {
695: /*
696: * If the member's name doesn't take up the entire 'name' field,
697: * we have to be careful of matching prefixes. Names are space-
698: * padded to the right, so if the character in 'name' at the end
699: * of the matched string is anything but a space, this isn't the
700: * member we sought.
701: */
702: if (tlen != sizeof(arhPtr->ar_name) && arhPtr->ar_name[tlen] != ' '){
703: goto skip;
704: } else {
705: /*
706: * To make life easier, we reposition the file at the start
707: * of the header we just read before we return the stream.
708: * In a more general situation, it might be better to leave
709: * the file at the actual member, rather than its header, but
710: * not here...
711: */
712: fseek (arch, -sizeof(struct ar_hdr), 1);
713: return (arch);
714: }
715: } else
716: #ifdef AR_EFMT1
717: /*
718: * BSD 4.4 extended AR format: #1/<namelen>, with name as the
719: * first <namelen> bytes of the file
720: */
721: if (strncmp(arhPtr->ar_name, AR_EFMT1,
722: sizeof(AR_EFMT1) - 1) == 0 &&
723: isdigit(arhPtr->ar_name[sizeof(AR_EFMT1) - 1])) {
724:
725: unsigned int elen = atoi(&arhPtr->ar_name[sizeof(AR_EFMT1)-1]);
726: char ename[MAXPATHLEN];
727:
728: if (elen > MAXPATHLEN) {
729: fclose (arch);
730: return NULL;
731: }
732: if (fread (ename, elen, 1, arch) != 1) {
733: fclose (arch);
734: return NULL;
735: }
736: ename[elen] = '\0';
737: if (DEBUG(ARCH) || DEBUG(MAKE)) {
738: printf("ArchFind: Extended format entry for %s\n", ename);
739: }
740: if (strncmp(ename, member, len) == 0) {
741: /* Found as extended name */
742: fseek (arch, -sizeof(struct ar_hdr) - elen, 1);
743: return (arch);
744: }
745: fseek (arch, -elen, 1);
746: goto skip;
747: } else
748: #endif
749: {
750: skip:
751: /*
752: * This isn't the member we're after, so we need to advance the
753: * stream's pointer to the start of the next header. Files are
754: * padded with newlines to an even-byte boundary, so we need to
755: * extract the size of the file from the 'size' field of the
756: * header and round it up during the seek.
757: */
758: arhPtr->ar_size[sizeof(arhPtr->ar_size)-1] = '\0';
759: size = (int) strtol(arhPtr->ar_size, NULL, 10);
760: fseek (arch, (size + 1) & ~1, 1);
761: }
762: }
763:
764: /*
765: * We've looked everywhere, but the member is not to be found. Close the
766: * archive and return NULL -- an error.
767: */
768: fclose (arch);
769: return ((FILE *) NULL);
770: }
771:
772: /*-
773: *-----------------------------------------------------------------------
774: * Arch_Touch --
775: * Touch a member of an archive.
776: *
777: * Results:
778: * The 'time' field of the member's header is updated.
779: *
780: * Side Effects:
781: * The modification time of the entire archive is also changed.
782: * For a library, this could necessitate the re-ranlib'ing of the
783: * whole thing.
784: *
785: *-----------------------------------------------------------------------
786: */
787: void
788: Arch_Touch (gn)
789: GNode *gn; /* Node of member to touch */
790: {
791: FILE * arch; /* Stream open to archive, positioned properly */
792: struct ar_hdr arh; /* Current header describing member */
793: char *p1, *p2;
794:
795: arch = ArchFindMember(Var_Value (ARCHIVE, gn, &p1),
796: Var_Value (TARGET, gn, &p2),
797: &arh, "r+");
798: if (p1)
799: free(p1);
800: if (p2)
801: free(p2);
802: sprintf(arh.ar_date, "%-12ld", (long) now);
803:
804: if (arch != (FILE *) NULL) {
805: (void)fwrite ((char *)&arh, sizeof (struct ar_hdr), 1, arch);
806: fclose (arch);
807: }
808: }
809:
810: /*-
811: *-----------------------------------------------------------------------
812: * Arch_TouchLib --
813: * Given a node which represents a library, touch the thing, making
814: * sure that the table of contents also is touched.
815: *
816: * Results:
817: * None.
818: *
819: * Side Effects:
820: * Both the modification time of the library and of the RANLIBMAG
821: * member are set to 'now'.
822: *
823: *-----------------------------------------------------------------------
824: */
825: void
826: Arch_TouchLib (gn)
827: GNode *gn; /* The node of the library to touch */
828: {
829: FILE * arch; /* Stream open to archive */
830: struct ar_hdr arh; /* Header describing table of contents */
831: struct timeval times[2]; /* Times for utimes() call */
832:
833: arch = ArchFindMember (gn->path, RANLIBMAG, &arh, "r+");
834: sprintf(arh.ar_date, "%-12ld", (long) now);
835:
836: if (arch != (FILE *) NULL) {
837: (void)fwrite ((char *)&arh, sizeof (struct ar_hdr), 1, arch);
838: fclose (arch);
839:
840: times[0].tv_sec = times[1].tv_sec = now;
841: times[0].tv_usec = times[1].tv_usec = 0;
842: utimes(gn->path, times);
843: }
844: }
845:
846: /*-
847: *-----------------------------------------------------------------------
848: * Arch_MTime --
849: * Return the modification time of a member of an archive.
850: *
851: * Results:
852: * The modification time (seconds).
853: *
854: * Side Effects:
855: * The mtime field of the given node is filled in with the value
856: * returned by the function.
857: *
858: *-----------------------------------------------------------------------
859: */
860: int
861: Arch_MTime (gn)
862: GNode *gn; /* Node describing archive member */
863: {
864: struct ar_hdr *arhPtr; /* Header of desired member */
865: int modTime; /* Modification time as an integer */
866: char *p1, *p2;
867:
868: arhPtr = ArchStatMember (Var_Value (ARCHIVE, gn, &p1),
869: Var_Value (TARGET, gn, &p2),
870: TRUE);
871: if (p1)
872: free(p1);
873: if (p2)
874: free(p2);
875:
876: if (arhPtr != (struct ar_hdr *) NULL) {
877: modTime = (int) strtol(arhPtr->ar_date, NULL, 10);
878: } else {
879: modTime = 0;
880: }
881:
882: gn->mtime = modTime;
883: return (modTime);
884: }
885:
886: /*-
887: *-----------------------------------------------------------------------
888: * Arch_MemMTime --
889: * Given a non-existent archive member's node, get its modification
890: * time from its archived form, if it exists.
891: *
892: * Results:
893: * The modification time.
894: *
895: * Side Effects:
896: * The mtime field is filled in.
897: *
898: *-----------------------------------------------------------------------
899: */
900: int
901: Arch_MemMTime (gn)
902: GNode *gn;
903: {
904: LstNode ln;
905: GNode *pgn;
906: char *nameStart,
907: *nameEnd;
908:
909: if (Lst_Open (gn->parents) != SUCCESS) {
910: gn->mtime = 0;
911: return (0);
912: }
913: while ((ln = Lst_Next (gn->parents)) != NILLNODE) {
914: pgn = (GNode *) Lst_Datum (ln);
915:
916: if (pgn->type & OP_ARCHV) {
917: /*
918: * If the parent is an archive specification and is being made
919: * and its member's name matches the name of the node we were
920: * given, record the modification time of the parent in the
921: * child. We keep searching its parents in case some other
922: * parent requires this child to exist...
923: */
924: nameStart = strchr (pgn->name, '(') + 1;
925: nameEnd = strchr (nameStart, ')');
926:
927: if (pgn->make &&
928: strncmp(nameStart, gn->name, nameEnd - nameStart) == 0) {
929: gn->mtime = Arch_MTime(pgn);
930: }
931: } else if (pgn->make) {
932: /*
933: * Something which isn't a library depends on the existence of
934: * this target, so it needs to exist.
935: */
936: gn->mtime = 0;
937: break;
938: }
939: }
940:
941: Lst_Close (gn->parents);
942:
943: return (gn->mtime);
944: }
945:
946: /*-
947: *-----------------------------------------------------------------------
948: * Arch_FindLib --
949: * Search for a library along the given search path.
950: *
951: * Results:
952: * None.
953: *
954: * Side Effects:
955: * The node's 'path' field is set to the found path (including the
956: * actual file name, not -l...). If the system can handle the -L
957: * flag when linking (or we cannot find the library), we assume that
958: * the user has placed the .LIBRARIES variable in the final linking
959: * command (or the linker will know where to find it) and set the
960: * TARGET variable for this node to be the node's name. Otherwise,
961: * we set the TARGET variable to be the full path of the library,
962: * as returned by Dir_FindFile.
963: *
964: *-----------------------------------------------------------------------
965: */
966: void
967: Arch_FindLib (gn, path)
968: GNode *gn; /* Node of library to find */
969: Lst path; /* Search path */
970: {
971: char *libName; /* file name for archive */
972:
973: libName = (char *)emalloc (strlen (gn->name) + 6 - 2);
974: sprintf(libName, "lib%s.a", &gn->name[2]);
975:
976: gn->path = Dir_FindFile (libName, path);
977:
978: free (libName);
979:
980: #ifdef LIBRARIES
981: Var_Set (TARGET, gn->name, gn);
982: #else
983: Var_Set (TARGET, gn->path == (char *) NULL ? gn->name : gn->path, gn);
984: #endif LIBRARIES
985: }
986:
987: /*-
988: *-----------------------------------------------------------------------
989: * Arch_LibOODate --
990: * Decide if a node with the OP_LIB attribute is out-of-date. Called
991: * from Make_OODate to make its life easier.
992: *
993: * There are several ways for a library to be out-of-date that are
994: * not available to ordinary files. In addition, there are ways
995: * that are open to regular files that are not available to
996: * libraries. A library that is only used as a source is never
997: * considered out-of-date by itself. This does not preclude the
998: * library's modification time from making its parent be out-of-date.
999: * A library will be considered out-of-date for any of these reasons,
1000: * given that it is a target on a dependency line somewhere:
1001: * Its modification time is less than that of one of its
1002: * sources (gn->mtime < gn->cmtime).
1003: * Its modification time is greater than the time at which the
1004: * make began (i.e. it's been modified in the course
1005: * of the make, probably by archiving).
1006: * The modification time of one of its sources is greater than
1007: * the one of its RANLIBMAG member (i.e. its table of contents
1008: * is out-of-date). We don't compare of the archive time
1009: * vs. TOC time because they can be too close. In my
1010: * opinion we should not bother with the TOC at all since
1011: * this is used by 'ar' rules that affect the data contents
1012: * of the archive, not by ranlib rules, which affect the
1013: * TOC.
1014: *
1015: * Results:
1016: * TRUE if the library is out-of-date. FALSE otherwise.
1017: *
1018: * Side Effects:
1019: * The library will be hashed if it hasn't been already.
1020: *
1021: *-----------------------------------------------------------------------
1022: */
1023: Boolean
1024: Arch_LibOODate (gn)
1025: GNode *gn; /* The library's graph node */
1026: {
1027: Boolean oodate;
1028:
1029: if (OP_NOP(gn->type) && Lst_IsEmpty(gn->children)) {
1030: oodate = FALSE;
1031: } else if ((gn->mtime > now) || (gn->mtime < gn->cmtime)) {
1032: oodate = TRUE;
1033: } else {
1034: struct ar_hdr *arhPtr; /* Header for __.SYMDEF */
1035: int modTimeTOC; /* The table-of-contents's mod time */
1036:
1037: arhPtr = ArchStatMember (gn->path, RANLIBMAG, FALSE);
1038:
1039: if (arhPtr != (struct ar_hdr *)NULL) {
1040: modTimeTOC = (int) strtol(arhPtr->ar_date, NULL, 10);
1041:
1042: if (DEBUG(ARCH) || DEBUG(MAKE)) {
1043: printf("%s modified %s...", RANLIBMAG, Targ_FmtTime(modTimeTOC));
1044: }
1045: oodate = (gn->cmtime > modTimeTOC);
1046: } else {
1047: /*
1048: * A library w/o a table of contents is out-of-date
1049: */
1050: if (DEBUG(ARCH) || DEBUG(MAKE)) {
1051: printf("No t.o.c....");
1052: }
1053: oodate = TRUE;
1054: }
1055: }
1056: return (oodate);
1057: }
1058:
1059: /*-
1060: *-----------------------------------------------------------------------
1061: * Arch_Init --
1062: * Initialize things for this module.
1063: *
1064: * Results:
1065: * None.
1066: *
1067: * Side Effects:
1068: * The 'archives' list is initialized.
1069: *
1070: *-----------------------------------------------------------------------
1071: */
1072: void
1073: Arch_Init ()
1074: {
1075: archives = Lst_Init (FALSE);
1076: }
1077:
1078:
1079:
1080: /*-
1081: *-----------------------------------------------------------------------
1082: * Arch_End --
1083: * Cleanup things for this module.
1084: *
1085: * Results:
1086: * None.
1087: *
1088: * Side Effects:
1089: * The 'archives' list is freed
1090: *
1091: *-----------------------------------------------------------------------
1092: */
1093: void
1094: Arch_End ()
1095: {
1096: Lst_Destroy(archives, ArchFree);
1097: }
![[BACK]](/icons/back.gif){kind=icon}
Return to arch.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / src / usr.bin / make