![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cp-xref.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / GNUtools / cc|
Return to cp-xref.c CVS log | Up to [Apple XNU] / GNUtools / cc |
1.1 root 1: /* Code for handling XREF output from GNU C++.
2: Copyright (C) 1992, 1993 Free Software Foundation, Inc.
3: Contributed by Michael Tiemann ([email protected])
4:
5: This file is part of GNU CC.
6:
7: GNU CC is free software; you can redistribute it and/or modify
8: it under the terms of the GNU General Public License as published by
9: the Free Software Foundation; either version 2, or (at your option)
10: any later version.
11:
12: GNU CC is distributed in the hope that it will be useful,
13: but WITHOUT ANY WARRANTY; without even the implied warranty of
14: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15: GNU General Public License for more details.
16:
17: You should have received a copy of the GNU General Public License
18: along with GNU CC; see the file COPYING. If not, write to
19: the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
20:
21:
22: #include "config.h"
23: #include "tree.h"
24: #include <stdio.h>
25: #include "cp-tree.h"
26: #include "input.h"
27:
28: #include <ctype.h>
29:
30: extern char *getpwd ();
31:
32: extern char *index ();
33: extern char *rindex ();
34:
35: /* The character(s) used to join a directory specification (obtained with
36: getwd or equivalent) with a non-absolute file name. */
37:
38: #ifndef FILE_NAME_JOINER
39: #define FILE_NAME_JOINER "/"
40: #endif
41:
42: /* Nonzero if NAME as a file name is absolute. */
43: #ifndef FILE_NAME_ABSOLUTE_P
44: #define FILE_NAME_ABSOLUTE_P(NAME) (NAME[0] == '/')
45: #endif
46:
47: /* For cross referencing. */
48:
49: int flag_gnu_xref;
50:
51: /************************************************************************/
52: /* */
53: /* Common definitions */
54: /* */
55: /************************************************************************/
56:
57: #ifndef TRUE
58: #define TRUE 1
59: #endif
60: #ifndef FALSE
61: #define FALSE 0
62: #endif
63: #ifndef NULL
64: #define NULL 0
65: #endif
66:
67: #define PALLOC(typ) ((typ *) calloc(1,sizeof(typ)))
68:
69:
70: /* Return a malloc'd copy of STR. */
71: #define SALLOC(str) \
72: ((char *) ((str) == NULL ? NULL \
73: : (char *) strcpy ((char *) malloc (strlen ((str)) + 1), (str))))
74: #define SFREE(str) (str != NULL && (free(str),0))
75:
76: #define STREQL(s1,s2) (strcmp((s1),(s2)) == 0)
77: #define STRNEQ(s1,s2) (strcmp((s1),(s2)) != 0)
78: #define STRLSS(s1,s2) (strcmp((s1),(s2)) < 0)
79: #define STRLEQ(s1,s2) (strcmp((s1),(s2)) <= 0)
80: #define STRGTR(s1,s2) (strcmp((s1),(s2)) > 0)
81: #define STRGEQ(s1,s2) (strcmp((s1),(s2)) >= 0)
82:
83: /************************************************************************/
84: /* */
85: /* Type definitions */
86: /* */
87: /************************************************************************/
88:
89:
90: typedef struct _XREF_FILE * XREF_FILE;
91: typedef struct _XREF_SCOPE * XREF_SCOPE;
92:
93: typedef struct _XREF_FILE
94: {
95: char *name;
96: char *outname;
97: XREF_FILE next;
98: } XREF_FILE_INFO;
99:
100: typedef struct _XREF_SCOPE
101: {
102: int gid;
103: int lid;
104: XREF_FILE file;
105: int start;
106: XREF_SCOPE outer;
107: } XREF_SCOPE_INFO;
108:
109: /************************************************************************/
110: /* */
111: /* Local storage */
112: /* */
113: /************************************************************************/
114:
115: static char doing_xref = 0;
116: static FILE * xref_file = NULL;
117: static char xref_name[1024];
118: static XREF_FILE all_files = NULL;
119: static char * wd_name = NULL;
120: static XREF_SCOPE cur_scope = NULL;
121: static int scope_ctr = 0;
122: static XREF_FILE last_file = NULL;
123: static tree last_fndecl = NULL;
124:
125: /************************************************************************/
126: /* */
127: /* Forward definitions */
128: /* */
129: /************************************************************************/
130:
131: extern void GNU_xref_begin();
132: extern void GNU_xref_end();
133: extern void GNU_xref_file();
134: extern void GNU_xref_start_scope();
135: extern void GNU_xref_end_scope();
136: extern void GNU_xref_ref();
137: extern void GNU_xref_decl();
138: extern void GNU_xref_call();
139: extern void GNU_xref_function();
140: extern void GNU_xref_assign();
141: extern void GNU_xref_hier();
142: extern void GNU_xref_member();
143:
144: static void gen_assign();
145: static XREF_FILE find_file();
146: static char * filename();
147: static char * fctname();
148: static char * declname();
149: static void simplify_type();
150: static char * fixname();
151: static void open_xref_file();
152:
153: extern char * type_as_string();
154:
155: /* Start cross referencing. FILE is the name of the file we xref. */
156:
157: void
158: GNU_xref_begin (file)
159: char *file;
160: {
161: doing_xref = 1;
162:
163: if (file != NULL && STRNEQ (file,"-"))
164: {
165: open_xref_file(file);
166: GNU_xref_file(file);
167: }
168: }
169:
170: /* Finish cross-referencing. ERRCNT is the number of errors
171: we encountered. */
172:
173: void
174: GNU_xref_end (ect)
175: int ect;
176: {
177: XREF_FILE xf;
178:
179: if (!doing_xref) return;
180:
181: xf = find_file (input_filename);
182: if (xf == NULL) return;
183:
184: while (cur_scope != NULL)
185: GNU_xref_end_scope(cur_scope->gid,0,0,0,0);
186:
187: doing_xref = 0;
188:
189: if (xref_file == NULL) return;
190:
191: fclose (xref_file);
192:
193: xref_file = NULL;
194: all_files = NULL;
195:
196: if (ect > 0) unlink (xref_name);
197: }
198:
199: /* Write out xref for file named NAME. */
200:
201: void
202: GNU_xref_file (name)
203: char *name;
204: {
205: XREF_FILE xf;
206:
207: if (!doing_xref || name == NULL) return;
208:
209: if (xref_file == NULL)
210: {
211: open_xref_file (name);
212: if (!doing_xref) return;
213: }
214:
215: if (all_files == NULL)
216: fprintf(xref_file,"SCP * 0 0 0 0 RESET\n");
217:
218: xf = find_file (name);
219: if (xf != NULL) return;
220:
221: xf = PALLOC (XREF_FILE_INFO);
222: xf->name = SALLOC (name);
223: xf->next = all_files;
224: all_files = xf;
225:
226: if (wd_name == NULL)
227: wd_name = getpwd ();
228:
229: if (FILE_NAME_ABSOLUTE_P (name) || ! wd_name)
230: xf->outname = xf->name;
231: else
232: {
233: char *nmbuf
234: = (char *) malloc (strlen (wd_name) + strlen (FILE_NAME_JOINER)
235: + strlen (name) + 1);
236: sprintf (nmbuf, "%s%s%s", wd_name, FILE_NAME_JOINER, name);
237: name = nmbuf;
238: xf->outname = nmbuf;
239: }
240:
241: fprintf (xref_file, "FIL %s %s 0\n", name, wd_name);
242:
243: filename (xf);
244: fctname (NULL);
245: }
246:
247: /* Start a scope identified at level ID. */
248:
249: void
250: GNU_xref_start_scope (id)
251: HOST_WIDE_INT id;
252: {
253: XREF_SCOPE xs;
254: XREF_FILE xf;
255:
256: if (!doing_xref) return;
257: xf = find_file (input_filename);
258:
259: xs = PALLOC (XREF_SCOPE_INFO);
260: xs->file = xf;
261: xs->start = lineno;
262: if (xs->start <= 0) xs->start = 1;
263: xs->gid = id;
264: xs->lid = ++scope_ctr;
265: xs->outer = cur_scope;
266: cur_scope = xs;
267: }
268:
269: /* Finish a scope at level ID.
270: INID is ???
271: PRM is ???
272: KEEP is nonzero iff this scope is retained (nonzero if it's
273: a compiler-generated invisible scope).
274: TRNS is ??? */
275:
276: void
277: GNU_xref_end_scope (id,inid,prm,keep,trns)
278: HOST_WIDE_INT id;
279: HOST_WIDE_INT inid;
280: int prm,keep,trns;
281: {
282: XREF_FILE xf;
283: XREF_SCOPE xs,lxs,oxs;
284: char *stype;
285:
286: if (!doing_xref) return;
287: xf = find_file (input_filename);
288: if (xf == NULL) return;
289:
290: lxs = NULL;
291: for (xs = cur_scope; xs != NULL; xs = xs->outer)
292: {
293: if (xs->gid == id) break;
294: lxs = xs;
295: }
296: if (xs == NULL) return;
297:
298: if (inid != 0) {
299: for (oxs = cur_scope; oxs != NULL; oxs = oxs->outer) {
300: if (oxs->gid == inid) break;
301: }
302: if (oxs == NULL) return;
303: inid = oxs->lid;
304: }
305:
306: if (prm == 2) stype = "SUE";
307: else if (prm != 0) stype = "ARGS";
308: else if (keep == 2 || inid != 0) stype = "INTERN";
309: else stype = "EXTERN";
310:
311: fprintf (xref_file,"SCP %s %d %d %d %d %s\n",
312: filename (xf), xs->start, lineno,xs->lid, inid, stype);
313:
314: if (lxs == NULL) cur_scope = xs->outer;
315: else lxs->outer = xs->outer;
316:
317: free (xs);
318: }
319:
320: /* Output a reference to NAME in FNDECL. */
321:
322: void
323: GNU_xref_ref (fndecl,name)
324: tree fndecl;
325: char *name;
326: {
327: XREF_FILE xf;
328:
329: if (!doing_xref) return;
330: xf = find_file (input_filename);
331: if (xf == NULL) return;
332:
333: fprintf (xref_file, "REF %s %d %s %s\n",
334: filename (xf), lineno, fctname (fndecl), name);
335: }
336:
337: /* Output a reference to DECL in FNDECL. */
338:
339: void
340: GNU_xref_decl (fndecl,decl)
341: tree fndecl;
342: tree decl;
343: {
344: XREF_FILE xf,xf1;
345: char *cls;
346: char *name;
347: char buf[10240];
348: int uselin;
349:
350: if (!doing_xref) return;
351: xf = find_file (input_filename);
352: if (xf == NULL) return;
353:
354: uselin = FALSE;
355:
356: if (TREE_CODE (decl) == TYPE_DECL) cls = "TYPEDEF";
357: else if (TREE_CODE (decl) == FIELD_DECL) cls = "FIELD";
358: else if (TREE_CODE (decl) == VAR_DECL)
359: {
360: if (fndecl == NULL && TREE_STATIC(decl)
361: && TREE_READONLY(decl) && DECL_INITIAL(decl) != 0
362: && !TREE_PUBLIC(decl) && !DECL_EXTERNAL(decl)
363: && DECL_MODE(decl) != BLKmode) cls = "CONST";
364: else if (DECL_EXTERNAL(decl)) cls = "EXTERN";
365: else if (TREE_PUBLIC(decl)) cls = "EXTDEF";
366: else if (TREE_STATIC(decl)) cls = "STATIC";
367: else if (DECL_REGISTER(decl)) cls = "REGISTER";
368: else cls = "AUTO";
369: }
370: else if (TREE_CODE (decl) == PARM_DECL) cls = "PARAM";
371: else if (TREE_CODE (decl) == FIELD_DECL) cls = "FIELD";
372: else if (TREE_CODE (decl) == CONST_DECL) cls = "CONST";
373: else if (TREE_CODE (decl) == FUNCTION_DECL)
374: {
375: if (DECL_EXTERNAL (decl)) cls = "EXTERN";
376: else if (TREE_PUBLIC (decl)) cls = "EFUNCTION";
377: else cls = "SFUNCTION";
378: }
379: else if (TREE_CODE (decl) == LABEL_DECL) cls = "LABEL";
380: else if (TREE_CODE (decl) == UNION_TYPE)
381: {
382: cls = "UNIONID";
383: decl = TYPE_NAME (decl);
384: uselin = TRUE;
385: }
386: else if (TREE_CODE (decl) == RECORD_TYPE)
387: {
388: if (CLASSTYPE_DECLARED_CLASS (decl)) cls = "CLASSID";
389: else cls = "STRUCTID";
390: decl = TYPE_NAME (decl);
391: uselin = TRUE;
392: }
393: else if (TREE_CODE (decl) == ENUMERAL_TYPE)
394: {
395: cls = "ENUMID";
396: decl = TYPE_NAME (decl);
397: uselin = TRUE;
398: }
399: else cls = "UNKNOWN";
400:
401: if (decl == NULL || DECL_NAME (decl) == NULL) return;
402:
403: if (uselin && decl->decl.linenum > 0 && decl->decl.filename != NULL)
404: {
405: xf1 = find_file (decl->decl.filename);
406: if (xf1 != NULL)
407: {
408: lineno = decl->decl.linenum;
409: xf = xf1;
410: }
411: }
412:
413: if (DECL_ASSEMBLER_NAME (decl))
414: name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
415: else
416: name = IDENTIFIER_POINTER (DECL_NAME (decl));
417:
418: strcpy (buf, type_as_string (TREE_TYPE (decl), 0));
419: simplify_type (buf);
420:
421: fprintf (xref_file, "DCL %s %d %s %d %s %s %s\n",
422: filename(xf), lineno, name,
423: (cur_scope != NULL ? cur_scope->lid : 0),
424: cls, fctname(fndecl), buf);
425:
426: if (STREQL (cls, "STRUCTID") || STREQL (cls, "UNIONID"))
427: {
428: cls = "CLASSID";
429: fprintf (xref_file, "DCL %s %d %s %d %s %s %s\n",
430: filename(xf), lineno,name,
431: (cur_scope != NULL ? cur_scope->lid : 0),
432: cls, fctname(fndecl), buf);
433: }
434: }
435:
436: /* Output a reference to a call to NAME in FNDECL. */
437:
438: void
439: GNU_xref_call (fndecl, name)
440: tree fndecl;
441: char *name;
442: {
443: XREF_FILE xf;
444: char buf[1024];
445: char *s;
446:
447: if (!doing_xref) return;
448: xf = find_file (input_filename);
449: if (xf == NULL) return;
450: name = fixname (name, buf);
451:
452: for (s = name; *s != 0; ++s)
453: if (*s == '_' && s[1] == '_') break;
454: if (*s != 0) GNU_xref_ref (fndecl, name);
455:
456: fprintf (xref_file, "CAL %s %d %s %s\n",
457: filename (xf), lineno, name, fctname (fndecl));
458: }
459:
460: /* Output cross-reference info about FNDECL. If non-NULL,
461: ARGS are the arguments for the function (i.e., before the FUNCTION_DECL
462: has been fully built). */
463:
464: void
465: GNU_xref_function (fndecl, args)
466: tree fndecl;
467: tree args;
468: {
469: XREF_FILE xf;
470: int ct;
471: char buf[1024];
472:
473: if (!doing_xref) return;
474: xf = find_file (input_filename);
475: if (xf == NULL) return;
476:
477: ct = 0;
478: buf[0] = 0;
479: if (args == NULL) args = DECL_ARGUMENTS (fndecl);
480:
481: GNU_xref_decl (NULL, fndecl);
482:
483: for ( ; args != NULL; args = TREE_CHAIN (args))
484: {
485: GNU_xref_decl (fndecl,args);
486: if (ct != 0) strcat (buf,",");
487: strcat (buf, declname (args));
488: ++ct;
489: }
490:
491: fprintf (xref_file, "PRC %s %d %s %d %d %s\n",
492: filename(xf), lineno, declname(fndecl),
493: (cur_scope != NULL ? cur_scope->lid : 0),
494: ct, buf);
495: }
496:
497: /* Output cross-reference info about an assignment to NAME. */
498:
499: void
500: GNU_xref_assign(name)
501: tree name;
502: {
503: XREF_FILE xf;
504:
505: if (!doing_xref) return;
506: xf = find_file(input_filename);
507: if (xf == NULL) return;
508:
509: gen_assign(xf, name);
510: }
511:
512: static void
513: gen_assign(xf, name)
514: XREF_FILE xf;
515: tree name;
516: {
517: char *s;
518:
519: s = NULL;
520:
521: switch (TREE_CODE (name))
522: {
523: case IDENTIFIER_NODE :
524: s = IDENTIFIER_POINTER(name);
525: break;
526: case VAR_DECL :
527: s = declname(name);
528: break;
529: case COMPONENT_REF :
530: gen_assign(xf, TREE_OPERAND(name, 0));
531: gen_assign(xf, TREE_OPERAND(name, 1));
532: break;
533: case INDIRECT_REF :
534: case OFFSET_REF :
535: case ARRAY_REF :
536: case BUFFER_REF :
537: gen_assign(xf, TREE_OPERAND(name, 0));
538: break;
539: case COMPOUND_EXPR :
540: gen_assign(xf, TREE_OPERAND(name, 1));
541: break;
542: default :
543: break;
544: }
545:
546: if (s != NULL)
547: fprintf(xref_file, "ASG %s %d %s\n", filename(xf), lineno, s);
548: }
549:
550: /* Output cross-reference info about a class hierarchy.
551: CLS is the class type of interest. BASE is a baseclass
552: for CLS. PUB and VIRT give the visibility info about
553: the class derivation. FRND is nonzero iff BASE is a friend
554: of CLS.
555:
556: ??? Needs to handle nested classes. */
557: void
558: GNU_xref_hier(cls, base, pub, virt, frnd)
559: char *cls;
560: char *base;
561: int pub;
562: int virt;
563: int frnd;
564: {
565: XREF_FILE xf;
566:
567: if (!doing_xref) return;
568: xf = find_file(input_filename);
569: if (xf == NULL) return;
570:
571: fprintf(xref_file, "HIE %s %d %s %s %d %d %d\n",
572: filename(xf), lineno, cls, base, pub, virt, frnd);
573: }
574:
575: /* Output cross-reference info about class members. CLS
576: is the containing type; FLD is the class member. */
577:
578: void
579: GNU_xref_member(cls, fld)
580: tree cls;
581: tree fld;
582: {
583: XREF_FILE xf;
584: char *prot;
585: int confg, pure;
586: char *d;
587: int i;
588: char buf[1024], bufa[1024];
589:
590: if (!doing_xref) return;
591: xf = find_file(fld->decl.filename);
592: if (xf == NULL) return;
593:
594: if (TREE_PRIVATE (fld)) prot = "PRIVATE";
595: else if (TREE_PROTECTED(fld)) prot = "PROTECTED";
596: else prot = "PUBLIC";
597:
598: confg = 0;
599: if (TREE_CODE (fld) == FUNCTION_DECL && DECL_CONST_MEMFUNC_P(fld))
600: confg = 1;
601: else if (TREE_CODE (fld) == CONST_DECL)
602: confg = 1;
603:
604: pure = 0;
605: if (TREE_CODE (fld) == FUNCTION_DECL && DECL_ABSTRACT_VIRTUAL_P(fld))
606: pure = 1;
607:
608: d = IDENTIFIER_POINTER(cls);
609: sprintf(buf, "%d%s", strlen(d), d);
610: i = strlen(buf);
611: strcpy(bufa, declname(fld));
612:
613: #ifdef XREF_SHORT_MEMBER_NAMES
614: for (p = &bufa[1]; *p != 0; ++p)
615: {
616: if (p[0] == '_' && p[1] == '_' && p[2] >= '0' && p[2] <= '9') {
617: if (strncmp(&p[2], buf, i) == 0) *p = 0;
618: break;
619: }
620: else if (p[0] == '_' && p[1] == '_' && p[2] == 'C' && p[3] >= '0' && p[3] <= '9') {
621: if (strncmp(&p[3], buf, i) == 0) *p = 0;
622: break;
623: }
624: }
625: #endif
626:
627: fprintf(xref_file, "MEM %s %d %s %s %s %d %d %d %d %d %d %d\n",
628: filename(xf), fld->decl.linenum, d, bufa, prot,
629: (TREE_CODE (fld) == FUNCTION_DECL ? 0 : 1),
630: (DECL_INLINE (fld) ? 1 : 0),
631: (DECL_FRIEND_P(fld) ? 1 : 0),
632: (DECL_VINDEX(fld) ? 1 : 0),
633: (TREE_STATIC(fld) ? 1 : 0),
634: pure, confg);
635: }
636:
637: /* Find file entry given name. */
638:
639: static XREF_FILE
640: find_file(name)
641: char *name;
642: {
643: XREF_FILE xf;
644:
645: for (xf = all_files; xf != NULL; xf = xf->next) {
646: if (STREQL(name, xf->name)) break;
647: }
648:
649: return xf;
650: }
651:
652: /* Return filename for output purposes. */
653:
654: static char *
655: filename(xf)
656: XREF_FILE xf;
657: {
658: if (xf == NULL) {
659: last_file = NULL;
660: return "*";
661: }
662:
663: if (last_file == xf) return "*";
664:
665: last_file = xf;
666:
667: return xf->outname;
668: }
669:
670: /* Return function name for output purposes. */
671:
672: static char *
673: fctname(fndecl)
674: tree fndecl;
675: {
676: static char fctbuf[1024];
677: char *s;
678:
679: if (fndecl == NULL && last_fndecl == NULL) return "*";
680:
681: if (fndecl == NULL)
682: {
683: last_fndecl = NULL;
684: return "*TOP*";
685: }
686:
687: if (fndecl == last_fndecl) return "*";
688:
689: last_fndecl = fndecl;
690:
691: s = declname(fndecl);
692: s = fixname(s, fctbuf);
693:
694: return s;
695: }
696:
697: /* Return decl name for output purposes. */
698:
699: static char *
700: declname(dcl)
701: tree dcl;
702: {
703: if (DECL_NAME (dcl) == NULL) return "?";
704:
705: if (DECL_ASSEMBLER_NAME (dcl))
706: return IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (dcl));
707: else
708: return IDENTIFIER_POINTER (DECL_NAME (dcl));
709: }
710:
711: /* Simplify a type string by removing unneeded parenthesis. */
712:
713: static void
714: simplify_type(typ)
715: char *typ;
716: {
717: char *s;
718: int lvl, i;
719:
720: i = strlen(typ);
721: while (i > 0 && isspace(typ[i-1])) typ[--i] = 0;
722:
723: if (i > 7 && STREQL(&typ[i-5], "const"))
724: {
725: typ[i-5] = 0;
726: i -= 5;
727: }
728:
729: if (typ[i-1] != ')') return;
730:
731: s = &typ[i-2];
732: lvl = 1;
733: while (*s != 0) {
734: if (*s == ')') ++lvl;
735: else if (*s == '(')
736: {
737: --lvl;
738: if (lvl == 0)
739: {
740: s[1] = ')';
741: s[2] = 0;
742: break;
743: }
744: }
745: --s;
746: }
747:
748: if (*s != 0 && s[-1] == ')')
749: {
750: --s;
751: --s;
752: if (*s == '(') s[2] = 0;
753: else if (*s == ':') {
754: while (*s != '(') --s;
755: s[1] = ')';
756: s[2] = 0;
757: }
758: }
759: }
760:
761: /* Fixup a function name (take care of embedded spaces). */
762:
763: static char *
764: fixname(nam, buf)
765: char *nam;
766: char *buf;
767: {
768: char *s, *t;
769: int fg;
770:
771: s = nam;
772: t = buf;
773: fg = 0;
774:
775: while (*s != 0)
776: {
777: if (*s == ' ')
778: {
779: *t++ = '\36';
780: ++fg;
781: }
782: else *t++ = *s;
783: ++s;
784: }
785: *t = 0;
786:
787: if (fg == 0) return nam;
788:
789: return buf;
790: }
791:
792: /* Open file for xrefing. */
793:
794: static void
795: open_xref_file(file)
796: char *file;
797: {
798: char *s, *t;
799:
800: #ifdef XREF_FILE_NAME
801: XREF_FILE_NAME (xref_name, file);
802: #else
803: s = rindex (file, '/');
804: if (s == NULL)
805: sprintf (xref_name, ".%s.gxref", file);
806: else
807: {
808: ++s;
809: strcpy (xref_name, file);
810: t = rindex (xref_name, '/');
811: ++t;
812: *t++ = '.';
813: strcpy (t, s);
814: strcat (t, ".gxref");
815: }
816: #endif /* no XREF_FILE_NAME */
817:
818: xref_file = fopen(xref_name, "w");
819:
820: if (xref_file == NULL)
821: {
822: error("Can't create cross-reference file `%s'", xref_name);
823: doing_xref = 0;
824: }
825: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.