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