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