Return to xref.c CVS log

Up to [GCC 2.x] / gcc / cp

Annotation of gcc/cp/xref.c, revision 1.1

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 if (IS_SIGNATURE (decl)) cls = "SIGNATUREID";
        !           390:       else cls = "STRUCTID";
        !           391:       decl = TYPE_NAME (decl);
        !           392:       uselin = TRUE;
        !           393:     }
        !           394:   else if (TREE_CODE (decl) == ENUMERAL_TYPE)
        !           395:     {
        !           396:       cls = "ENUMID";
        !           397:       decl = TYPE_NAME (decl);
        !           398:       uselin = TRUE;
        !           399:     }
        !           400:   else if (TREE_CODE (decl) == TEMPLATE_DECL)
        !           401:     {
        !           402:       if (DECL_TEMPLATE_IS_CLASS (decl))
        !           403:        cls = "CLASSTEMP";
        !           404:       else if (TREE_CODE (DECL_RESULT (decl)) == FUNCTION_DECL)
        !           405:        cls = "FUNCTEMP";
        !           406:       else if (TREE_CODE (DECL_RESULT (decl)) == VAR_DECL)
        !           407:        cls = "VARTEMP";
        !           408:       else
        !           409:        my_friendly_abort (358);
        !           410:       uselin = TRUE;
        !           411:     }
        !           412:   else cls = "UNKNOWN";
        !           413: 
        !           414:   if (decl == NULL || DECL_NAME (decl) == NULL) return;
        !           415: 
        !           416:   if (uselin && decl->decl.linenum > 0 && decl->decl.filename != NULL)
        !           417:     {
        !           418:       xf1 = find_file (decl->decl.filename);
        !           419:       if (xf1 != NULL)
        !           420:        {
        !           421:          lineno = decl->decl.linenum;
        !           422:          xf = xf1;
        !           423:        }
        !           424:     }
        !           425: 
        !           426:   if (DECL_ASSEMBLER_NAME (decl))
        !           427:     name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
        !           428:   else
        !           429:     name = IDENTIFIER_POINTER (DECL_NAME (decl));
        !           430: 
        !           431:   strcpy (buf, type_as_string (TREE_TYPE (decl), 0));
        !           432:   simplify_type (buf);
        !           433: 
        !           434:   fprintf (xref_file, "DCL %s %d %s %d %s %s %s\n",
        !           435:           filename(xf), lineno, name,
        !           436:           (cur_scope != NULL ? cur_scope->lid : 0),
        !           437:           cls, fctname(fndecl), buf);
        !           438: 
        !           439:   if (STREQL (cls, "STRUCTID") || STREQL (cls, "UNIONID")
        !           440:       || STREQL (cls, "SIGNATUREID"))
        !           441:     {
        !           442:       cls = "CLASSID";
        !           443:       fprintf (xref_file, "DCL %s %d %s %d %s %s %s\n",
        !           444:               filename(xf), lineno,name,
        !           445:               (cur_scope != NULL ? cur_scope->lid : 0),
        !           446:               cls, fctname(fndecl), buf);
        !           447:     }
        !           448: }
        !           449: 
        !           450: /* Output a reference to a call to NAME in FNDECL.  */
        !           451: 
        !           452: void
        !           453: GNU_xref_call (fndecl, name)
        !           454:    tree fndecl;
        !           455:    char *name;
        !           456: {
        !           457:   XREF_FILE xf;
        !           458:   char buf[1024];
        !           459:   char *s;
        !           460: 
        !           461:   if (!doing_xref) return;
        !           462:   xf = find_file (input_filename);
        !           463:   if (xf == NULL) return;
        !           464:   name = fixname (name, buf);
        !           465: 
        !           466:   for (s = name; *s != 0; ++s)
        !           467:     if (*s == '_' && s[1] == '_') break;
        !           468:   if (*s != 0) GNU_xref_ref (fndecl, name);
        !           469: 
        !           470:   fprintf (xref_file, "CAL %s %d %s %s\n",
        !           471:           filename (xf), lineno, name, fctname (fndecl));
        !           472: }
        !           473: 
        !           474: /* Output cross-reference info about FNDECL.  If non-NULL,
        !           475:    ARGS are the arguments for the function (i.e., before the FUNCTION_DECL
        !           476:    has been fully built).  */
        !           477: 
        !           478: void
        !           479: GNU_xref_function (fndecl, args)
        !           480:    tree fndecl;
        !           481:    tree args;
        !           482: {
        !           483:   XREF_FILE xf;
        !           484:   int ct;
        !           485:   char buf[1024];
        !           486: 
        !           487:   if (!doing_xref) return;
        !           488:   xf = find_file (input_filename);
        !           489:   if (xf == NULL) return;
        !           490: 
        !           491:   ct = 0;
        !           492:   buf[0] = 0;
        !           493:   if (args == NULL) args = DECL_ARGUMENTS (fndecl);
        !           494: 
        !           495:   GNU_xref_decl (NULL, fndecl);
        !           496: 
        !           497:   for ( ; args != NULL; args = TREE_CHAIN (args))
        !           498:     {
        !           499:       GNU_xref_decl (fndecl,args);
        !           500:       if (ct != 0) strcat (buf,",");
        !           501:       strcat (buf, declname (args));
        !           502:       ++ct;
        !           503:     }
        !           504: 
        !           505:   fprintf (xref_file, "PRC %s %d %s %d %d %s\n",
        !           506:           filename(xf), lineno, declname(fndecl),
        !           507:           (cur_scope != NULL ? cur_scope->lid : 0),
        !           508:           ct, buf);
        !           509: }
        !           510: 
        !           511: /* Output cross-reference info about an assignment to NAME.  */
        !           512: 
        !           513: void
        !           514: GNU_xref_assign(name)
        !           515:    tree name;
        !           516: {
        !           517:   XREF_FILE xf;
        !           518: 
        !           519:   if (!doing_xref) return;
        !           520:   xf = find_file(input_filename);
        !           521:   if (xf == NULL) return;
        !           522: 
        !           523:   gen_assign(xf, name);
        !           524: }
        !           525: 
        !           526: static void
        !           527: gen_assign(xf, name)
        !           528:    XREF_FILE xf;
        !           529:    tree name;
        !           530: {
        !           531:   char *s;
        !           532: 
        !           533:   s = NULL;
        !           534: 
        !           535:   switch (TREE_CODE (name))
        !           536:     {
        !           537:     case IDENTIFIER_NODE :
        !           538:       s = IDENTIFIER_POINTER(name);
        !           539:       break;
        !           540:     case VAR_DECL :
        !           541:       s = declname(name);
        !           542:       break;
        !           543:     case COMPONENT_REF :
        !           544:       gen_assign(xf, TREE_OPERAND(name, 0));
        !           545:       gen_assign(xf, TREE_OPERAND(name, 1));
        !           546:       break;
        !           547:     case INDIRECT_REF :
        !           548:     case OFFSET_REF :
        !           549:     case ARRAY_REF :
        !           550:     case BUFFER_REF :
        !           551:       gen_assign(xf, TREE_OPERAND(name, 0));
        !           552:       break;
        !           553:     case COMPOUND_EXPR :
        !           554:       gen_assign(xf, TREE_OPERAND(name, 1));
        !           555:       break;
        !           556:       default :
        !           557:       break;
        !           558:     }
        !           559: 
        !           560:   if (s != NULL)
        !           561:     fprintf(xref_file, "ASG %s %d %s\n", filename(xf), lineno, s);
        !           562: }
        !           563: 
        !           564: /* Output cross-reference info about a class hierarchy.
        !           565:    CLS is the class type of interest.  BASE is a baseclass
        !           566:    for CLS.  PUB and VIRT give the access info about
        !           567:    the class derivation.  FRND is nonzero iff BASE is a friend
        !           568:    of CLS.
        !           569: 
        !           570:    ??? Needs to handle nested classes.  */
        !           571: void
        !           572: GNU_xref_hier(cls, base, pub, virt, frnd)
        !           573:    char *cls;
        !           574:    char *base;
        !           575:    int pub;
        !           576:    int virt;
        !           577:    int frnd;
        !           578: {
        !           579:   XREF_FILE xf;
        !           580: 
        !           581:   if (!doing_xref) return;
        !           582:   xf = find_file(input_filename);
        !           583:   if (xf == NULL) return;
        !           584: 
        !           585:   fprintf(xref_file, "HIE %s %d %s %s %d %d %d\n",
        !           586:          filename(xf), lineno, cls, base, pub, virt, frnd);
        !           587: }
        !           588: 
        !           589: /* Output cross-reference info about class members.  CLS
        !           590:    is the containing type; FLD is the class member.  */
        !           591: 
        !           592: void
        !           593: GNU_xref_member(cls, fld)
        !           594:    tree cls;
        !           595:    tree fld;
        !           596: {
        !           597:   XREF_FILE xf;
        !           598:   char *prot;
        !           599:   int confg, pure;
        !           600:   char *d;
        !           601:   int i;
        !           602:   char buf[1024], bufa[1024];
        !           603: 
        !           604:   if (!doing_xref) return;
        !           605:   xf = find_file(fld->decl.filename);
        !           606:   if (xf == NULL) return;
        !           607: 
        !           608:   if (TREE_PRIVATE (fld)) prot = "PRIVATE";
        !           609:   else if (TREE_PROTECTED(fld)) prot = "PROTECTED";
        !           610:   else prot = "PUBLIC";
        !           611: 
        !           612:   confg = 0;
        !           613:   if (TREE_CODE (fld) == FUNCTION_DECL && DECL_CONST_MEMFUNC_P(fld))
        !           614:     confg = 1;
        !           615:   else if (TREE_CODE (fld) == CONST_DECL)
        !           616:     confg = 1;
        !           617: 
        !           618:   pure = 0;
        !           619:   if (TREE_CODE (fld) == FUNCTION_DECL && DECL_ABSTRACT_VIRTUAL_P(fld))
        !           620:     pure = 1;
        !           621: 
        !           622:   d = IDENTIFIER_POINTER(cls);
        !           623:   sprintf(buf, "%d%s", strlen(d), d);
        !           624:   i = strlen(buf);
        !           625:   strcpy(bufa, declname(fld));
        !           626: 
        !           627: #ifdef XREF_SHORT_MEMBER_NAMES
        !           628:   for (p = &bufa[1]; *p != 0; ++p)
        !           629:     {
        !           630:       if (p[0] == '_' && p[1] == '_' && p[2] >= '0' && p[2] <= '9') {
        !           631:        if (strncmp(&p[2], buf, i) == 0) *p = 0;
        !           632:        break;
        !           633:       }
        !           634:       else if (p[0] == '_' && p[1] == '_' && p[2] == 'C' && p[3] >= '0' && p[3] <= '9') {
        !           635:        if (strncmp(&p[3], buf, i) == 0) *p = 0;
        !           636:        break;
        !           637:       }
        !           638:     }
        !           639: #endif
        !           640: 
        !           641:   fprintf(xref_file, "MEM %s %d %s %s %s %d %d %d %d %d %d %d\n",
        !           642:          filename(xf), fld->decl.linenum, d,  bufa,  prot,
        !           643:          (TREE_CODE (fld) == FUNCTION_DECL ? 0 : 1),
        !           644:          (DECL_INLINE (fld) ? 1 : 0),
        !           645:          (DECL_FRIEND_P(fld) ? 1 : 0),
        !           646:          (DECL_VINDEX(fld) ? 1 : 0),
        !           647:          (TREE_STATIC(fld) ? 1 : 0),
        !           648:          pure, confg);
        !           649: }
        !           650: 
        !           651: /* Find file entry given name.  */
        !           652: 
        !           653: static XREF_FILE
        !           654: find_file(name)
        !           655:    char *name;
        !           656: {
        !           657:   XREF_FILE xf;
        !           658: 
        !           659:   for (xf = all_files; xf != NULL; xf = xf->next) {
        !           660:     if (STREQL(name, xf->name)) break;
        !           661:   }
        !           662: 
        !           663:   return xf;
        !           664: }
        !           665: 
        !           666: /* Return filename for output purposes.  */
        !           667: 
        !           668: static char *
        !           669: filename(xf)
        !           670:    XREF_FILE xf;
        !           671: {
        !           672:   if (xf == NULL) {
        !           673:     last_file = NULL;
        !           674:     return "*";
        !           675:   }
        !           676: 
        !           677:   if (last_file == xf) return "*";
        !           678: 
        !           679:   last_file = xf;
        !           680: 
        !           681:   return xf->outname;
        !           682: }
        !           683: 
        !           684: /* Return function name for output purposes.  */
        !           685: 
        !           686: static char *
        !           687: fctname(fndecl)
        !           688:    tree fndecl;
        !           689: {
        !           690:   static char fctbuf[1024];
        !           691:   char *s;
        !           692: 
        !           693:   if (fndecl == NULL && last_fndecl == NULL) return "*";
        !           694: 
        !           695:   if (fndecl == NULL)
        !           696:     {
        !           697:       last_fndecl = NULL;
        !           698:       return "*TOP*";
        !           699:     }
        !           700: 
        !           701:   if (fndecl == last_fndecl) return "*";
        !           702: 
        !           703:   last_fndecl = fndecl;
        !           704: 
        !           705:   s = declname(fndecl);
        !           706:   s = fixname(s, fctbuf);
        !           707: 
        !           708:   return s;
        !           709: }
        !           710: 
        !           711: /* Return decl name for output purposes.  */
        !           712: 
        !           713: static char *
        !           714: declname(dcl)
        !           715:    tree dcl;
        !           716: {
        !           717:   if (DECL_NAME (dcl) == NULL) return "?";
        !           718: 
        !           719:   if (DECL_ASSEMBLER_NAME (dcl))
        !           720:     return IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (dcl));
        !           721:   else
        !           722:     return IDENTIFIER_POINTER (DECL_NAME (dcl));
        !           723: }
        !           724: 
        !           725: /* Simplify a type string by removing unneeded parenthesis.  */
        !           726: 
        !           727: static void
        !           728: simplify_type(typ)
        !           729:    char *typ;
        !           730: {
        !           731:   char *s;
        !           732:   int lvl, i;
        !           733: 
        !           734:   i = strlen(typ);
        !           735:   while (i > 0 && isspace(typ[i-1])) typ[--i] = 0;
        !           736: 
        !           737:   if (i > 7 && STREQL(&typ[i-5], "const"))
        !           738:     {
        !           739:       typ[i-5] = 0;
        !           740:       i -= 5;
        !           741:     }
        !           742: 
        !           743:   if (typ[i-1] != ')') return;
        !           744: 
        !           745:   s = &typ[i-2];
        !           746:   lvl = 1;
        !           747:   while (*s != 0) {
        !           748:     if (*s == ')') ++lvl;
        !           749:     else if (*s == '(')
        !           750:       {
        !           751:        --lvl;
        !           752:        if (lvl == 0)
        !           753:          {
        !           754:            s[1] = ')';
        !           755:            s[2] = 0;
        !           756:            break;
        !           757:          }
        !           758:       }
        !           759:     --s;
        !           760:   }
        !           761: 
        !           762:   if (*s != 0 && s[-1] == ')')
        !           763:     {
        !           764:       --s;
        !           765:       --s;
        !           766:       if (*s == '(') s[2] = 0;
        !           767:       else if (*s == ':') {
        !           768:        while (*s != '(') --s;
        !           769:        s[1] = ')';
        !           770:        s[2] = 0;
        !           771:       }
        !           772:     }
        !           773: }
        !           774: 
        !           775: /* Fixup a function name (take care of embedded spaces).  */
        !           776: 
        !           777: static char *
        !           778: fixname(nam, buf)
        !           779:    char *nam;
        !           780:    char *buf;
        !           781: {
        !           782:   char *s, *t;
        !           783:   int fg;
        !           784: 
        !           785:   s = nam;
        !           786:   t = buf;
        !           787:   fg = 0;
        !           788: 
        !           789:   while (*s != 0)
        !           790:     {
        !           791:       if (*s == ' ')
        !           792:        {
        !           793:          *t++ = '\36';
        !           794:          ++fg;
        !           795:        }
        !           796:       else *t++ = *s;
        !           797:       ++s;
        !           798:     }
        !           799:   *t = 0;
        !           800: 
        !           801:   if (fg == 0) return nam;
        !           802: 
        !           803:   return buf;
        !           804: }
        !           805: 
        !           806: /* Open file for xrefing.  */
        !           807: 
        !           808: static void
        !           809: open_xref_file(file)
        !           810:    char *file;
        !           811: {
        !           812:   char *s, *t;
        !           813: 
        !           814: #ifdef XREF_FILE_NAME
        !           815:   XREF_FILE_NAME (xref_name, file);
        !           816: #else
        !           817:   s = rindex (file, '/');
        !           818:   if (s == NULL)
        !           819:     sprintf (xref_name, ".%s.gxref", file);
        !           820:   else
        !           821:     {
        !           822:       ++s;
        !           823:       strcpy (xref_name, file);
        !           824:       t = rindex (xref_name, '/');
        !           825:       ++t;
        !           826:       *t++ = '.';
        !           827:       strcpy (t, s);
        !           828:       strcat (t, ".gxref");
        !           829:     }
        !           830: #endif /* no XREF_FILE_NAME */
        !           831: 
        !           832:   xref_file = fopen(xref_name, "w");
        !           833: 
        !           834:   if (xref_file == NULL)
        !           835:     {
        !           836:       error("Can't create cross-reference file `%s'", xref_name);
        !           837:       doing_xref = 0;
        !           838:     }
        !           839: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.