![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to rcsfnms.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / contrib / rcs / src|
Return to rcsfnms.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / rcs / src |
1.1 root 1: /*
2: * RCS file name handling
3: */
4: #ifndef lint
5: static char
6: rcsid[]= "$Id: rcsfnms.c,v 3.12 89/08/15 21:38:10 bostic Exp $ Purdue CS";
7: #endif
8: /****************************************************************************
9: * creation and deletion of semaphorefile,
10: * creation of temporary filenames and cleanup()
11: * pairing of RCS file names and working file names.
12: * Testprogram: define PAIRTEST
13: ****************************************************************************
14: */
15:
16: /* Copyright (C) 1982, 1988, 1989 Walter Tichy
17: * All rights reserved.
18: *
19: * Redistribution and use in source and binary forms are permitted
20: * provided that the above copyright notice and this paragraph are
21: * duplicated in all such forms and that any documentation,
22: * advertising materials, and other materials related to such
23: * distribution and use acknowledge that the software was developed
24: * by Walter Tichy.
25: * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
26: * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
27: * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
28: *
29: * Report all problems and direct all questions to:
30: * [email protected]
31: *
32:
33:
34:
35:
36:
37:
38:
39: */
40:
41:
42:
43:
44: /* $Log: rcsfnms.c,v $
45: * Revision 3.12 89/08/15 21:38:10 bostic
46: * Version 4 from Tom Narten at Purdue
47: *
48: * Revision 4.8 89/05/01 15:09:41 narten
49: * changed getwd to not stat empty directories.
50: *
51: * Revision 4.7 88/11/08 12:01:22 narten
52: * changes from [email protected] (Paul Eggert)
53: *
54: * Revision 4.7 88/08/09 19:12:53 eggert
55: * Fix troff macro comment leader bug; add Prolog; allow cc -R; remove lint.
56: *
57: * Revision 4.6 87/12/18 11:40:23 narten
58: * additional file types added from 4.3 BSD version, and SPARC assembler
59: * comment character added. Also, more lint cleanups. (Guy Harris)
60: *
61: * Revision 4.5 87/10/18 10:34:16 narten
62: * Updating version numbers. Changes relative to 1.1 actually relative
63: * to verion 4.3
64: *
65: * Revision 1.3 87/03/27 14:22:21 jenkins
66: * Port to suns
67: *
68: * Revision 1.2 85/06/26 07:34:28 svb
69: * Comment leader '% ' for '*.tex' files added.
70: *
71: * Revision 1.1 84/01/23 14:50:24 kcs
72: * Initial revision
73: *
74: * Revision 4.3 83/12/15 12:26:48 wft
75: * Added check for KDELIM in file names to pairfilenames().
76: *
77: * Revision 4.2 83/12/02 22:47:45 wft
78: * Added csh, red, and sl file name suffixes.
79: *
80: * Revision 4.1 83/05/11 16:23:39 wft
81: * Added initialization of Dbranch to InitAdmin(). Canged pairfilenames():
82: * 1. added copying of path from workfile to RCS file, if RCS file is omitted;
83: * 2. added getting the file status of RCS and working files;
84: * 3. added ignoring of directories.
85: *
86: * Revision 3.7 83/05/11 15:01:58 wft
87: * Added comtable[] which pairs file name suffixes with comment leaders;
88: * updated InitAdmin() accordingly.
89: *
90: * Revision 3.6 83/04/05 14:47:36 wft
91: * fixed Suffix in InitAdmin().
92: *
93: * Revision 3.5 83/01/17 18:01:04 wft
94: * Added getwd() and rename(); these can be removed by defining
95: * V4_2BSD, since they are not needed in 4.2 bsd.
96: * Changed sys/param.h to sys/types.h.
97: *
98: * Revision 3.4 82/12/08 21:55:20 wft
99: * removed unused variable.
100: *
101: * Revision 3.3 82/11/28 20:31:37 wft
102: * Changed mktempfile() to store the generated file names.
103: * Changed getfullRCSname() to store the file and pathname, and to
104: * delete leading "../" and "./".
105: *
106: * Revision 3.2 82/11/12 14:29:40 wft
107: * changed pairfilenames() to handle file.sfx,v; also deleted checkpathnosfx(),
108: * checksuffix(), checkfullpath(). Semaphore name generation updated.
109: * mktempfile() now checks for nil path; freefilename initialized properly.
110: * Added Suffix .h to InitAdmin. Added testprogram PAIRTEST.
111: * Moved rmsema, trysema, trydiraccess, getfullRCSname from rcsutil.c to here.
112: *
113: * Revision 3.1 82/10/18 14:51:28 wft
114: * InitAdmin() now initializes StrictLocks=STRICT_LOCKING (def. in rcsbase.h).
115: * renamed checkpath() to checkfullpath().
116: */
117:
118:
119: #include "rcsbase.h"
120: #include <sys/types.h>
121: #include <sys/stat.h>
122: #include <sys/dir.h>
123:
124: extern char * rindex();
125: extern char * mktemp();
126: extern FILE * fopen();
127: extern char * getwd(); /* get working directory; forward decl */
128: extern int stat(), fstat();
129:
130: extern FILE * finptr; /* RCS input file descriptor */
131: extern FILE * frewrite; /* New RCS file descriptor */
132: extern char * RCSfilename, * workfilename; /* filenames */
133: struct stat RCSstat, workstat; /* file status for RCS file and working file */
134: int haveRCSstat, haveworkstat; /* indicators if status availalble */
135:
136:
137: char tempfilename [NCPFN+10]; /* used for derived file names */
138: char sub1filename [NCPPN]; /* used for files path/file.sfx,v */
139: char sub2filename [NCPPN]; /* used for files path/RCS/file.sfx,v */
140: char semafilename [NCPPN]; /* name of semaphore file */
141: int madesema; /* indicates whether a semaphore file has been set */
142: char * tfnames[10]; /* temp. file names to be unlinked when finished */
143: int freefilename; /* index of next free file name in tfnames[] */
144:
145:
146: struct compair {
147: char * suffix, * comlead;
148: };
149:
150: struct compair comtable[] = {
151: /* comtable pairs each filename suffix with a comment leader. The comment */
152: /* leader is placed before each line generated by the $Log keyword. This */
153: /* table is used to guess the proper comment leader from the working file's */
154: /* suffix during initial ci (see InitAdmin()). Comment leaders are needed */
155: /* for languages without multiline comments; for others they are optional. */
156: "c", " * ", /* C */
157: "csh", "# ", /* shell */
158: "e", "# ", /* efl */
159: "f", "c ", /* fortran */
160: "h", " * ", /* C-header */
161: "l", " * ", /* lex NOTE: conflict between lex and franzlisp*/
162: "mac", "; ", /* macro vms or dec-20 or pdp-11 macro */
163: "me", ".\\\" ",/* me-macros t/nroff*/
164: "mm", ".\\\" ",/* mm-macros t/nroff*/
165: "ms", ".\\\" ",/* ms-macros t/nroff*/
166: "p", " * ", /* pascal */
167: "pl", "% ", /* prolog */
168: "r", "# ", /* ratfor */
169: "red", "% ", /* psl/rlisp */
170:
171: #ifdef sparc
172: "s", "! ", /* assembler */
173: #endif
174: #ifdef mc68000
175: "s", "| ", /* assembler */
176: #endif
177: #ifdef pdp11
178: "s", "/ ", /* assembler */
179: #endif
180: #ifdef vax
181: "s", "# ", /* assembler */
182: #endif
183:
184: "sh", "# ", /* shell */
185: "sl", "% ", /* psl */
186: "red", "% ", /* psl/rlisp */
187: "cl", ";;; ", /* common lisp */
188: "ml", "; ", /* mocklisp */
189: "el", "; ", /* gnulisp */
190: "tex", "% ", /* tex */
191: "y", " * ", /* yacc */
192: "ye", " * ", /* yacc-efl */
193: "yr", " * ", /* yacc-ratfor */
194: "", "# ", /* default for empty suffix */
195: nil, "" /* default for unknown suffix; must always be last */
196: };
197:
198:
199: ffclose(fptr)
200: FILE * fptr;
201: /* Function: checks ferror(fptr) and aborts the program if there were
202: * errors; otherwise closes fptr.
203: */
204: { if (ferror(fptr) || fclose(fptr)==EOF)
205: faterror("File read or write error; file system full?");
206: }
207:
208:
209:
210: int trysema(RCSname,makesema)
211: char * RCSname; int makesema;
212: /* Function: Checks whether a semaphore file exists for RCSname. If yes,
213: * returns false. If not, creates one if makesema==true and returns true
214: * if successful. If a semaphore file was created, madesema is set to true.
215: * The name of the semaphore file is put into variable semafilename.
216: */
217: {
218: register char * tp, *sp, *lp;
219: int fdesc;
220:
221: sp=RCSname;
222: lp = rindex(sp,'/');
223: if (lp==0) {
224: semafilename[0]='.'; semafilename[1]='/';
225: tp= &semafilename[2];
226: } else {
227: /* copy path */
228: tp=semafilename;
229: do *tp++ = *sp++; while (sp<=lp);
230: }
231: /*now insert `,' and append file name */
232: *tp++ = ',';
233: lp = rindex(sp, RCSSEP);
234: while (sp<lp) *tp++ = *sp++;
235: *tp++ = ','; *tp++ = '\0'; /* will be the same length as RCSname*/
236:
237: madesema = false;
238: if (access(semafilename, 0) == 0) {
239: error("RCS file %s is in use",RCSname);
240: return false;
241: }
242: if (makesema) {
243: if ((fdesc=creat(semafilename, 000)) == -1) {
244: error("Can't create semaphore file for RCS file %s",RCSname);
245: return false;
246: } else
247: VOID close(fdesc);
248: madesema=true;
249: }
250: return true;
251: }
252:
253:
254: rmsema()
255: /* Function: delete the semaphore file if madeseam==true;
256: * sets madesema to false.
257: */
258: {
259: if (madesema) {
260: madesema=false;
261: if (unlink(semafilename) == -1) {
262: error("Can't find semaphore file %s",semafilename);
263: }
264: }
265: }
266:
267:
268:
269: InitCleanup()
270: { freefilename = 0; /* initialize pointer */
271: }
272:
273:
274: cleanup()
275: /* Function: closes input file and rewrite file.
276: * Unlinks files in tfnames[], deletes semaphore file.
277: */
278: {
279: register int i;
280:
281: if (finptr!=NULL) VOID fclose(finptr);
282: if (frewrite!=NULL) VOID fclose(frewrite);
283: for (i=0; i<freefilename; i++) {
284: if (tfnames[i][0]!='\0') VOID unlink(tfnames[i]);
285: }
286: InitCleanup();
287: rmsema();
288: }
289:
290:
291: char * mktempfile(fullpath,filename)
292: register char * fullpath, * filename;
293: /* Function: Creates a unique filename using the process id and stores it
294: * into a free slot in tfnames. The filename consists of the path contained
295: * in fullpath concatenated with filename. filename should end in "XXXXXX".
296: * Because of storage in tfnames, cleanup() can unlink the file later.
297: * freefilename indicates the lowest unoccupied slot in tfnames.
298: * Returns a pointer to the filename created.
299: * Example use: mktempfile("/tmp/", somefilename)
300: */
301: {
302: register char * lastslash, *tp;
303: if ((tp=tfnames[freefilename])==nil)
304: tp=tfnames[freefilename] = talloc(NCPPN);
305: if (fullpath!=nil && (lastslash=rindex(fullpath,'/'))!=0) {
306: /* copy path */
307: while (fullpath<=lastslash) *tp++ = *fullpath++;
308: }
309: while (*tp++ = *filename++);
310: return (mktemp(tfnames[freefilename++]));
311: }
312:
313:
314:
315:
316: char * bindex(sp,c)
317: register char * sp, c;
318: /* Function: Finds the last occurrence of character c in string sp
319: * and returns a pointer to the character just beyond it. If the
320: * character doesn't occur in the string, sp is returned.
321: */
322: { register char * r;
323: r = sp;
324: while (*sp) {
325: if (*sp++ == c) r=sp;
326: }
327: return r;
328: }
329:
330:
331:
332:
333:
334: InitAdmin()
335: /* function: initializes an admin node */
336: { register char * Suffix;
337: register int i;
338:
339: Head=Dbranch=nil; AccessList=nil; Symbols=nil; Locks=nil;
340: StrictLocks=STRICT_LOCKING;
341:
342: /* guess the comment leader from the suffix*/
343: Suffix=bindex(workfilename, '.');
344: if (Suffix==workfilename) Suffix= ""; /* empty suffix; will get default*/
345: for (i=0;;i++) {
346: if (comtable[i].suffix==nil) {
347: Comment=comtable[i].comlead; /*default*/
348: break;
349: } elsif (strcmp(Suffix,comtable[i].suffix)==0) {
350: Comment=comtable[i].comlead; /*default*/
351: break;
352: }
353: }
354: Lexinit(); /* Note: if finptr==NULL, reads nothing; only initializes*/
355: }
356:
357:
358:
359: char * findpairfile(argc, argv, fname)
360: int argc; char * argv[], *fname;
361: /* Function: Given a filename fname, findpairfile scans argv for a pathname
362: * ending in fname. If found, returns a pointer to the pathname, and sets
363: * the corresponding pointer in argv to nil. Otherwise returns fname.
364: * argc indicates the number of entries in argv. Some of them may be nil.
365: */
366: {
367: register char * * next, * match;
368: register int count;
369:
370: for (next = argv, count = argc; count>0; next++,count--) {
371: if ((*next != nil) && strcmp(bindex(*next,'/'),fname)==0) {
372: /* bindex finds the beginning of the file name stem */
373: match= *next;
374: *next=nil;
375: return match;
376: }
377: }
378: return fname;
379: }
380:
381:
382: int pairfilenames(argc, argv, mustread, tostdout)
383: int argc; char ** argv; int mustread, tostdout;
384: /* Function: Pairs the filenames pointed to by argv; argc indicates
385: * how many there are.
386: * Places a pointer to the RCS filename into RCSfilename,
387: * and a pointer to the name of the working file into workfilename.
388: * If both the workfilename and the RCS filename are given, and tostdout
389: * is true, a warning is printed.
390: *
391: * If the working file exists, places its status into workstat and
392: * sets haveworkstat to 0; otherwise, haveworkstat is set to -1;
393: * Similarly for the RCS file and the variables RCSstat and haveRCSstat.
394: *
395: * If the RCS file exists, it is opened for reading, the file pointer
396: * is placed into finptr, and the admin-node is read in; returns 1.
397: * If the RCS file does not exist and mustread==true, an error is printed
398: * and 0 returned.
399: * If the RCS file does not exist and mustread==false, the admin node
400: * is initialized to empty (Head, AccessList, Locks, Symbols, StrictLocks, Dbranch)
401: * and -1 returned.
402: *
403: * 0 is returned on all errors. Files that are directories are errors.
404: * Also calls InitCleanup();
405: */
406: {
407: register char * sp, * tp;
408: char * lastsep, * purefname, * pureRCSname;
409: int opened, returncode;
410: char * RCS1;
411: char prefdir[NCPPN];
412:
413: if (*argv == nil) return 0; /* already paired filename */
414: if (rindex(*argv,KDELIM)!=0) {
415: /* KDELIM causes havoc in keyword expansion */
416: error("RCS file name may not contain %c",KDELIM);
417: return 0;
418: }
419: InitCleanup();
420:
421: /* first check suffix to see whether it is an RCS file or not */
422: purefname=bindex(*argv, '/'); /* skip path */
423: lastsep=rindex(purefname, RCSSEP);
424: if (lastsep!= 0 && *(lastsep+1)==RCSSUF && *(lastsep+2)=='\0') {
425: /* RCS file name given*/
426: RCS1=(*argv); pureRCSname=purefname;
427: /* derive workfilename*/
428: sp = purefname; tp=tempfilename;
429: while (sp<lastsep) *tp++ = *sp++; *tp='\0';
430: /* try to find workfile name among arguments */
431: workfilename=findpairfile(argc-1,argv+1,tempfilename);
432: if (strlen(pureRCSname)>NCPFN) {
433: error("RCS file name %s too long",RCS1);
434: return 0;
435: }
436: } else {
437: /* working file given; now try to find RCS file */
438: workfilename= *argv;
439: /* derive RCS file name*/
440: sp=purefname; tp=tempfilename;
441: while (*tp++ = *sp++);
442: *(tp-1)=RCSSEP; *tp++=RCSSUF; *tp++='\0';
443: /* Try to find RCS file name among arguments*/
444: RCS1=findpairfile(argc-1,argv+1,tempfilename);
445: pureRCSname=bindex(RCS1, '/');
446: if (strlen(pureRCSname)>NCPFN) {
447: error("working file name %s too long",workfilename);
448: return 0;
449: }
450: }
451: /* now we have a (tentative) RCS filename in RCS1 and workfilename */
452: /* First, get status of workfilename */
453: haveworkstat=stat(workfilename, &workstat);
454: if ((haveworkstat==0) && ((workstat.st_mode & S_IFDIR) == S_IFDIR)) {
455: diagnose("Directory %s ignored",workfilename);
456: return 0;
457: }
458: /* Second, try to find the right RCS file */
459: if (pureRCSname!=RCS1) {
460: /* a path for RCSfile is given; single RCS file to look for */
461: finptr=fopen(RCSfilename=RCS1, "r");
462: if (finptr!=NULL) {
463: returncode=1;
464: } else { /* could not open */
465: if (access(RCSfilename,0)==0) {
466: error("Can't open existing %s", RCSfilename);
467: return 0;
468: }
469: if (mustread) {
470: error("Can't find %s", RCSfilename);
471: return 0;
472: } else {
473: /* initialize if not mustread */
474: returncode = -1;
475: }
476: }
477: } else {
478: /* no path for RCS file name. Prefix it with path of work */
479: /* file if RCS file omitted. Make a second name including */
480: /* RCSDIR and try to open that one first. */
481: sub1filename[0]=sub2filename[0]= '\0';
482: if (RCS1==tempfilename) {
483: /* RCS file name not given; prepend work path */
484: sp= *argv; tp= sub1filename;
485: while (sp<purefname) *tp++ = *sp ++;
486: *tp='\0';
487: VOID strcpy(sub2filename,sub1filename); /* second one */
488: }
489: VOID strcat(sub1filename,RCSDIR);
490: VOID strcpy(prefdir,sub1filename); /* preferred directory for RCS file*/
491: VOID strcat(sub1filename,RCS1); VOID strcat(sub2filename,RCS1);
492:
493:
494: opened=(
495: ((finptr=fopen(RCSfilename=sub1filename, "r"))!=NULL) ||
496: ((finptr=fopen(RCSfilename=sub2filename,"r"))!=NULL) );
497:
498: if (opened) {
499: /* open succeeded */
500: returncode=1;
501: } else {
502: /* open failed; may be read protected */
503: if ((access(RCSfilename=sub1filename,0)==0) ||
504: (access(RCSfilename=sub2filename,0)==0)) {
505: error("Can't open existing %s",RCSfilename);
506: return 0;
507: }
508: if (mustread) {
509: error("Can't find %s nor %s",sub1filename,sub2filename);
510: return 0;
511: } else {
512: /* initialize new file. Put into ./RCS if possible, strip off suffix*/
513: RCSfilename= (access(prefdir,0)==0)?sub1filename:sub2filename;
514: returncode= -1;
515: }
516: }
517: }
518:
519: if (returncode == 1) { /* RCS file open */
520: haveRCSstat=fstat(fileno(finptr),&RCSstat);
521: if ((haveRCSstat== 0) && ((RCSstat.st_mode & S_IFDIR) == S_IFDIR)) {
522: diagnose("Directory %s ignored",RCSfilename);
523: return 0;
524: }
525: Lexinit(); getadmin();
526: } else { /* returncode == -1; RCS file nonexisting */
527: haveRCSstat = -1;
528: InitAdmin();
529: };
530:
531: if (tostdout&&
532: !(RCS1==tempfilename||workfilename==tempfilename))
533: /*The last term determines whether a pair of */
534: /* file names was given in the argument list */
535: warn("Option -p is set; ignoring output file %s",workfilename);
536:
537: return returncode;
538: }
539:
540:
541: char * getfullRCSname()
542: /* Function: returns a pointer to the full path name of the RCS file.
543: * Calls getwd(), but only once.
544: * removes leading "../" and "./".
545: */
546: { static char pathbuf[NCPPN];
547: static char namebuf[NCPPN];
548: static int pathlength;
549:
550: register char * realname, * lastpathchar;
551: register int dotdotcounter, realpathlength;
552:
553: if (*RCSfilename=='/') {
554: return(RCSfilename);
555: } else {
556: if (pathlength==0) { /*call curdir for the first time*/
557: if (getwd(pathbuf)==NULL)
558: faterror("Can't build current directory path");
559: pathlength=strlen(pathbuf);
560: if (!((pathlength==1) && (pathbuf[0]=='/'))) {
561: pathbuf[pathlength++]='/';
562: /* Check needed because some getwd implementations */
563: /* generate "/" for the root. */
564: }
565: }
566: /*the following must be redone since RCSfilename may change*/
567: /* find how many ../ to remvove from RCSfilename */
568: dotdotcounter =0;
569: realname = RCSfilename;
570: while( realname[0]=='.' &&
571: (realname[1]=='/'||(realname[1]=='.'&&realname[2]=='/'))){
572: if (realname[1]=='/') {
573: /* drop leading ./ */
574: realname += 2;
575: } else {
576: /* drop leading ../ and remember */
577: dotdotcounter++;
578: realname += 3;
579: }
580: }
581: /* now remove dotdotcounter trailing directories from pathbuf*/
582: lastpathchar=pathbuf + pathlength-1;
583: while (dotdotcounter>0 && lastpathchar>pathbuf) {
584: /* move pointer backwards over trailing directory */
585: lastpathchar--;
586: if (*lastpathchar=='/') {
587: dotdotcounter--;
588: }
589: }
590: if (dotdotcounter>0) {
591: error("Can't generate full path name for RCS file");
592: return RCSfilename;
593: } else {
594: /* build full path name */
595: realpathlength=lastpathchar-pathbuf+1;
596: VOID strncpy(namebuf,pathbuf,realpathlength);
597: VOID strcpy(&namebuf[realpathlength],realname);
598: return(namebuf);
599: }
600: }
601: }
602:
603:
604:
605: int trydiraccess(filename)
606: char * filename;
607: /* checks write permission in directory of filename and returns
608: * true if writable, false otherwise
609: */
610: {
611: char pathname[NCPPN];
612: register char * tp, *sp, *lp;
613: lp = rindex(filename,'/');
614: if (lp==0) {
615: /* check current directory */
616: if (access(".",2)==0)
617: return true;
618: else {
619: error("Current directory not writable");
620: return false;
621: }
622: }
623: /* copy path */
624: sp=filename;
625: tp=pathname;
626: do *tp++ = *sp++; while (sp<=lp);
627: *tp='\0';
628: if (access(pathname,2)==0)
629: return true;
630: else {
631: error("Directory %s not writable", pathname);
632: return false;
633: }
634: }
635:
636:
637:
638: #ifndef V4_2BSD
639: /* rename() and getwd() will be provided in bsd 4.2 */
640:
641:
642: int rename(from, to)
643: char * from, *to;
644: /* Function: renames a file with the name given by from to the name given by to.
645: * unlinks the to-file if it already exists. returns -1 on error, 0 otherwise.
646: */
647: { VOID unlink(to); /* no need to check return code; will be caught by link*/
648: /* no harm done if file "to" does not exist */
649: if (link(from,to)<0) return -1;
650: return(unlink(from));
651: }
652:
653:
654:
655: #define dot "."
656: #define dotdot ".."
657:
658:
659:
660: char * getwd(name)
661: char * name;
662: /* Function: places full pathname of current working directory into name and
663: * returns name on success, NULL on failure.
664: * getwd is an adaptation of pwd. May not return to the current directory on
665: * failure.
666: */
667: {
668: FILE *file;
669: struct stat d, dd;
670: char buf[2]; /* to NUL-terminate dir.d_name */
671: struct direct dir;
672:
673: int rdev, rino;
674: int off;
675: register i,j;
676:
677: name[off= 0] = '/';
678: name[1] = '\0';
679: buf[0] = '\0';
680: if (stat("/", &d)<0) return NULL;
681: rdev = d.st_dev;
682: rino = d.st_ino;
683: for (;;) {
684: if (stat(dot, &d)<0) return NULL;
685: if (d.st_ino==rino && d.st_dev==rdev) {
686: if (name[off] == '/') name[off] = '\0';
687: chdir(name); /*change back to current directory*/
688: return name;
689: }
690: if ((file = fopen(dotdot,"r")) == NULL) return NULL;
691: if (fstat(fileno(file), &dd)<0) goto fail;
692: chdir(dotdot);
693: if(d.st_dev == dd.st_dev) {
694: if(d.st_ino == dd.st_ino) {
695: if (name[off] == '/') name[off] = '\0';
696: chdir(name); /*change back to current directory*/
697: VOID fclose(file);
698: return name;
699: }
700: do {
701: if (fread((char *)&dir, sizeof(dir), 1, file) !=1)
702: goto fail;
703: } while (dir.d_ino != d.st_ino);
704: }
705: else do {
706: if(fread((char *)&dir, sizeof(dir), 1, file) != 1) {
707: goto fail;
708: }
709: if (dir.d_ino == 0)
710: dd.st_ino = d.st_ino + 1;
711: else if (stat(dir.d_name, &dd) < 0)
712: goto fail;
713: } while(dd.st_ino != d.st_ino || dd.st_dev != d.st_dev);
714: VOID fclose(file);
715:
716: /* concatenate file name */
717: i = -1;
718: while (dir.d_name[++i] != 0);
719: for(j=off+1; j>0; --j)
720: name[j+i+1] = name[j];
721: off=i+off+1;
722: name[i+1] = '/';
723: for(--i; i>=0; --i)
724: name[i+1] = dir.d_name[i];
725: } /* end for */
726:
727: fail: VOID fclose(file);
728: return NULL;
729: }
730:
731:
732: #endif
733:
734:
735: #ifdef PAIRTEST
736: /* test program for pairfilenames() and getfullRCSname() */
737: char * workfilename, *RCSfilename;
738: extern int quietflag;
739:
740: main(argc, argv)
741: int argc; char *argv[];
742: {
743: int result;
744: int initflag,tostdout;
745: quietflag=tostdout=initflag=false;
746: cmdid="pair";
747:
748: while(--argc, ++argv, argc>=1 && ((*argv)[0] == '-')) {
749: switch ((*argv)[1]) {
750:
751: case 'p': tostdout=true;
752: break;
753: case 'i': initflag=true;
754: break;
755: case 'q': quietflag=true;
756: break;
757: default: error("unknown option: %s", *argv);
758: break;
759: }
760: }
761:
762: do {
763: RCSfilename=workfilename=nil;
764: result=pairfilenames(argc,argv,!initflag,tostdout);
765: if (result!=0) {
766: diagnose("RCSfile: %s; working file: %s",RCSfilename,workfilename);
767: diagnose("Full RCS file name: %s", getfullRCSname());
768: }
769: switch (result) {
770: case 0: continue; /* already paired file */
771:
772: case 1: if (initflag) {
773: error("RCS file %s exists already",RCSfilename);
774: } else {
775: diagnose("RCS file %s exists",RCSfilename);
776: }
777: VOID fclose(finptr);
778: break;
779:
780: case -1:diagnose("RCS file does not exist");
781: break;
782: }
783:
784: } while (++argv, --argc>=1);
785:
786: }
787: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.