gnu/usr.bin/g++/cc1plus/cplus-field.c

   1 /************************************************************************/
   2 /*                                                                      */
   3 /*              cplus-field.c                                           */
   4 /*                                                                      */
   5 /*      Code for handling XREF output from g++                          */
   6 /*                                                                      */
   7 /************************************************************************/
   8
   9
  10 #ifdef FIELD_XREF
  11
  12 #include "config.h"
  13 #include "tree.h"
  14 #include "cplus-tree.h"
  15 #include "input.h"
  16
  17 #include <stdio.h>
  18 #include <ctype.h>
  19 #include <strings.h>
  20
  21
  22
  23
  24 /************************************************************************/
  25 /*                                                                      */
  26 /*      Common definitions                                              */
  27 /*                                                                      */
  28 /************************************************************************/
  29
  30 typedef int     Integer;
  31 typedef char *  String;
  32
  33
  34 #ifndef TRUE
  35 #define TRUE 1
  36 #endif
  37 #ifndef FALSE
  38 #define FALSE 0
  39 #endif
  40 #ifndef NULL
  41 #define NULL 0
  42 #endif
  43
  44
  45 #define PALLOC(typ) ((typ *) calloc(1,sizeof(typ)))
  46
  47
  48 #define SALLOC(str) ((String) ((str == NULL) ? NULL : (strcpy(malloc(strlen(str)+1),str))))
  49 #define SFREE(str) (str != NULL && (free(str),0))
  50
  51 #define STREQL(s1,s2) (strcmp((s1),(s2)) == 0)
  52 #define STRNEQ(s1,s2) (strcmp((s1),(s2)) != 0)
  53 #define STRLSS(s1,s2) (strcmp((s1),(s2)) < 0)
  54 #define STRLEQ(s1,s2) (strcmp((s1),(s2)) <= 0)
  55 #define STRGTR(s1,s2) (strcmp((s1),(s2)) > 0)
  56 #define STRGEQ(s1,s2) (strcmp((s1),(s2)) >= 0)
  57
  58
  59
  60
  61
  62 /************************************************************************/
  63 /*                                                                      */
  64 /*      Type definitions                                                */
  65 /*                                                                      */
  66 /************************************************************************/
  67
  68
  69 typedef struct _XREF_FILE *     XREF_FILE;
  70 typedef struct _XREF_SCOPE *    XREF_SCOPE;
  71
  72
  73
  74 typedef struct _XREF_FILE {
  75    String name;
  76    XREF_FILE next;
  77 } XREF_FILE_INFO;
  78
  79
  80
  81
  82
  83 typedef struct _XREF_SCOPE {
  84    Integer gid;
  85    Integer lid;
  86    XREF_FILE file;
  87    Integer start;
  88    XREF_SCOPE outer;
  89 } XREF_SCOPE_INFO;
  90
  91
  92
  93
  94
  95
  96 /************************************************************************/
  97 /*                                                                      */
  98 /*      Local storage                                                   */
  99 /*                                                                      */
 100 /************************************************************************/
 101
 102
 103 static  char            doing_xref = 0;
 104 static  FILE *          xref_file = NULL;
 105 static  char            xref_name[1024];
 106 static  XREF_FILE       all_files = NULL;
 107 static  String          wd_name = NULL;
 108 static  XREF_SCOPE      cur_scope = NULL;
 109 static  Integer         scope_ctr = 0;
 110 static  XREF_FILE       last_file = NULL;
 111 static  tree            last_fct = NULL;
 112
 113
 114
 115
 116 /************************************************************************/
 117 /*                                                                      */
 118 /*      Forward definitions                                             */
 119 /*                                                                      */
 120 /************************************************************************/
 121
 122
 123 extern  void            FIELD_xref_begin();
 124 extern  void            FIELD_xref_end();
 125 extern  void            FIELD_xref_file();
 126 extern  void            FIELD_xref_start_scope();
 127 extern  void            FIELD_xref_end_scope();
 128 extern  void            FIELD_xref_ref();
 129 extern  void            FIELD_xref_decl();
 130 extern  void            FIELD_xref_call();
 131 extern  void            FIELD_xref_function();
 132 extern  void            FIELD_xref_assign();
 133 extern  void            FIELD_xref_hier();
 134 extern  void            FIELD_xref_member();
 135
 136
 137 static  void            gen_assign();
 138 static  XREF_FILE       find_file();
 139 static  String          filename();
 140 static  String          fctname();
 141 static  String          declname();
 142 static  void            simplify_type();
 143 static  String          fixname();
 144 static  void            open_xref_file();
 145
 146 extern  char *          type_as_string();
 147
 148
 149
 150
 151 /************************************************************************/
 152 /*                                                                      */
 153 /*      FIELD_xref_begin -- start cross referencing                     */
 154 /*                                                                      */
 155 /************************************************************************/
 156
 157
 158 void
 159 FIELD_xref_begin(file)
 160    String file;
 161 {
 162    String s,t;
 163
 164    doing_xref = 1;
 165
 166    if (file != NULL && STRNEQ(file,"-")) {
 167       open_xref_file(file);
 168       FIELD_xref_file(file);
 169     };
 170 };
 171
 172
 173
 174
 175
 176 /************************************************************************/
 177 /*                                                                      */
 178 /*      FIELD_xref_end -- finish cross referencing                      */
 179 /*                                                                      */
 180 /************************************************************************/
 181
 182
 183 void
 184 FIELD_xref_end(ect)
 185    int ect;
 186 {
 187    XREF_FILE xf;
 188
 189    if (!doing_xref) return;
 190
 191    xf = find_file(input_filename);
 192    if (xf == NULL) return;
 193
 194    while (cur_scope != NULL) {
 195       FIELD_xref_end_scope(cur_scope->gid,0,0,0,0);
 196     };
 197
 198    doing_xref = 0;
 199
 200    if (xref_file == NULL) return;
 201
 202    fclose(xref_file);
 203
 204    xref_file = NULL;
 205    all_files = NULL;
 206
 207    if (ect > 0) unlink(xref_name);
 208 };
 209
 210
 211
 212
 213
 214
 215 /************************************************************************/
 216 /*                                                                      */
 217 /*      FIELD_xref_file -- handle file xrefing                          */
 218 /*                                                                      */
 219 /************************************************************************/
 220
 221
 222 void
 223 FIELD_xref_file(name)
 224    String name;
 225 {
 226    XREF_FILE xf;
 227    char wdbuf[1024];
 228
 229    if (!doing_xref || name == NULL) return;
 230
 231    if (xref_file == NULL) {
 232       open_xref_file(name);
 233       if (!doing_xref) return;
 234     };
 235
 236    if (all_files == NULL) {
 237       fprintf(xref_file,"SCP * 0 0 0 0 RESET\n");
 238     };
 239
 240    xf = find_file(name);
 241    if (xf != NULL) return;
 242
 243    xf = PALLOC(XREF_FILE_INFO);
 244    xf->name = SALLOC(name);
 245    xf->next = all_files;
 246    all_files = xf;
 247
 248    if (wd_name == NULL) {
 249       getwd(wdbuf);
 250       wd_name = SALLOC(wdbuf);
 251     };
 252
 253    fprintf(xref_file,"FIL %s %s 0\n",name,wd_name);
 254
 255    filename(xf);
 256    fctname(NULL);
 257 };
 258
 259
 260
 261
 262
 263
 264 /************************************************************************/
 265 /*                                                                      */
 266 /*      FIELD_xref_start_scope -- begin a scope                         */
 267 /*      FIELD_xref_end_scope -- finish a scope                          */
 268 /*                                                                      */
 269 /************************************************************************/
 270
 271
 272 void
 273 FIELD_xref_start_scope(id)
 274    Integer id;
 275 {
 276    XREF_SCOPE xs;
 277    XREF_FILE xf;
 278
 279    if (!doing_xref) return;
 280    xf = find_file(input_filename);
 281
 282    xs = PALLOC(XREF_SCOPE_INFO);
 283    xs->file = xf;
 284    xs->start = lineno;
 285    if (xs->start <= 0) xs->start = 1;
 286    xs->gid = id;
 287    xs->lid = ++scope_ctr;
 288    xs->outer = cur_scope;
 289    cur_scope = xs;
 290 };
 291
 292
 293
 294
 295
 296 void
 297 FIELD_xref_end_scope(id,inid,prm,keep,trns)
 298    Integer id;
 299    Integer inid;
 300    Integer prm,keep,trns;
 301 {
 302    XREF_FILE xf;
 303    XREF_SCOPE xs,lxs,oxs;
 304    String stype;
 305
 306    if (!doing_xref) return;
 307    xf = find_file(input_filename);
 308    if (xf == NULL) return;
 309
 310    lxs = NULL;
 311    for (xs = cur_scope; xs != NULL; xs = xs->outer) {
 312       if (xs->gid == id) break;
 313       lxs = xs;
 314     };
 315    if (xs == NULL) return;
 316
 317    if (inid != 0) {
 318       for (oxs = cur_scope; oxs != NULL; oxs = oxs->outer) {
 319          if (oxs->gid == inid) break;
 320        };
 321       if (oxs == NULL) return;
 322       inid = oxs->lid;
 323     };
 324
 325    if (prm == 2) stype = "SUE";
 326    else if (prm != 0) stype = "ARGS";
 327    else if (keep == 2 || inid != 0) stype = "INTERN";
 328    else stype = "EXTERN";
 329
 330    fprintf(xref_file,"SCP %s %d %d %d %d %s\n",
 331               filename(xf),xs->start,lineno,xs->lid,inid,stype);
 332
 333    if (lxs == NULL) cur_scope = xs->outer;
 334    else lxs->outer = xs->outer;
 335
 336    free(xs);
 337 };
 338
 339
 340
 341
 342
 343 /************************************************************************/
 344 /*                                                                      */
 345 /*      FIELD_xref_ref -- handle reference                              */
 346 /*                                                                      */
 347 /************************************************************************/
 348
 349
 350 void
 351 FIELD_xref_ref(fct,name)
 352    tree fct;
 353    String name;
 354 {
 355    XREF_FILE xf;
 356
 357    if (!doing_xref) return;
 358    xf = find_file(input_filename);
 359    if (xf == NULL) return;
 360
 361    fprintf(xref_file,"REF %s %d %s %s\n",
 362               filename(xf),lineno,fctname(fct),name);
 363 };
 364
 365
 366
 367
 368
 369
 370 /************************************************************************/
 371 /*                                                                      */
 372 /*      FIELD_xref_decl -- handle declaration                           */
 373 /*                                                                      */
 374 /************************************************************************/
 375
 376
 377 void
 378 FIELD_xref_decl(fct,decl)
 379    tree fct;
 380    tree decl;
 381 {
 382    XREF_FILE xf;
 383    String cls;
 384    String name;
 385    char buf[10240];
 386
 387    if (!doing_xref) return;
 388    xf = find_file(input_filename);
 389    if (xf == NULL) return;
 390
 391    if (DECL_NAME(decl) == NULL) return;
 392
 393    if (TREE_CODE(decl) == TYPE_DECL) cls = "TYPEDEF";
 394    else if (TREE_CODE(decl) == FIELD_DECL) cls = "FIELD";
 395    else if (TREE_CODE(decl) == VAR_DECL) {
 396       if (fct == NULL && TREE_STATIC(decl) &&
 397              TREE_READONLY(decl) && DECL_INITIAL(decl) != 0 &&
 398              !TREE_PUBLIC(decl) && !TREE_EXTERNAL(decl) &&
 399              DECL_MODE(decl) != BLKmode) cls = "CONST";
 400       else if (TREE_EXTERNAL(decl)) cls = "EXTERN";
 401       else if (TREE_PUBLIC(decl)) cls = "EXTDEF";
 402       else if (TREE_STATIC(decl)) cls = "STATIC";
 403       else if (TREE_REGDECL(decl)) cls = "REGISTER";
 404       else cls = "AUTO";
 405     }
 406    else if (TREE_CODE(decl) == PARM_DECL) cls = "PARAM";
 407    else if (TREE_CODE(decl) == FIELD_DECL) cls = "FIELD";
 408    else if (TREE_CODE(decl) == CONST_DECL) cls = "CONST";
 409    else if (TREE_CODE(decl) == FUNCTION_DECL) {
 410       if (TREE_EXTERNAL(decl)) cls = "EXTERN";
 411       else if (TREE_PUBLIC(decl)) cls = "EFUNCTION";
 412       else cls = "SFUNCTION";
 413     }
 414    else if (TREE_CODE(decl) == LABEL_DECL) cls = "LABEL";
 415    else if (TREE_CODE(decl) == UNION_TYPE) {
 416       cls = "UNIONID";
 417       decl = TYPE_NAME(decl);
 418     }
 419    else if (TREE_CODE(decl) == RECORD_TYPE) {
 420       if (CLASSTYPE_DECLARED_CLASS(decl)) cls = "CLASSID";
 421       else cls = "STRUCTID";
 422       decl = TYPE_NAME(decl);
 423     }
 424    else if (TREE_CODE(decl) == ENUMERAL_TYPE) {
 425       cls = "ENUMID";
 426       decl = TYPE_NAME(decl);
 427     }
 428    else cls = "UNKNOWN";
 429
 430    name = IDENTIFIER_POINTER(DECL_NAME(decl));
 431
 432    type_as_string(buf,TREE_TYPE(decl));
 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(fct),buf);
 439 };
 440
 441
 442
 443
 444
 445
 446 /************************************************************************/
 447 /*                                                                      */
 448 /*      FIELD_xref_call -- handle call                                  */
 449 /*                                                                      */
 450 /************************************************************************/
 451
 452
 453 void
 454 FIELD_xref_call(fct,name)
 455    tree fct;
 456    String name;
 457 {
 458    XREF_FILE xf;
 459    char buf[1024];
 460
 461    if (!doing_xref) return;
 462    xf = find_file(input_filename);
 463    if (xf == NULL) return;
 464    name = fixname(name,buf);
 465
 466    fprintf(xref_file,"CAL %s %d %s %s\n",
 467               filename(xf),lineno,name,fctname(fct));
 468 };
 469
 470
 471
 472
 473
 474
 475 /************************************************************************/
 476 /*                                                                      */
 477 /*      FIELD_xref_function -- handle functions                         */
 478 /*                                                                      */
 479 /************************************************************************/
 480
 481
 482 void
 483 FIELD_xref_function(fct,args)
 484    tree fct;
 485    tree args;
 486 {
 487    XREF_FILE xf;
 488    int ct;
 489    char buf[1024];
 490
 491    if (!doing_xref) return;
 492    xf = find_file(input_filename);
 493    if (xf == NULL) return;
 494
 495    ct = 0;
 496    buf[0] = 0;
 497    if (args == NULL) args = DECL_ARGUMENTS(fct);
 498
 499    FIELD_xref_decl(NULL,fct);
 500
 501    for ( ; args != NULL; args = TREE_CHAIN(args)) {
 502       FIELD_xref_decl(fct,args);
 503       if (ct != 0) strcat(buf,",");
 504       strcat(buf,declname(args));
 505       ++ct;
 506     };
 507
 508    fprintf(xref_file,"PRC %s %d %s %d %d %s\n",
 509               filename(xf),lineno,declname(fct),
 510               (cur_scope != NULL ? cur_scope->lid : 0),
 511               ct,buf);
 512 };
 513
 514
 515
 516
 517
 518
 519 /************************************************************************/
 520 /*                                                                      */
 521 /*      FIELD_xref_assign -- handle assignment                          */
 522 /*                                                                      */
 523 /************************************************************************/
 524
 525
 526 void
 527 FIELD_xref_assign(name)
 528    tree name;
 529 {
 530    XREF_FILE xf;
 531
 532    if (!doing_xref) return;
 533    xf = find_file(input_filename);
 534    if (xf == NULL) return;
 535
 536    gen_assign(xf,name);
 537 };
 538
 539
 540
 541 static void
 542 gen_assign(xf,name)
 543    XREF_FILE xf;
 544    tree name;
 545 {
 546    String s;
 547
 548    s = NULL;
 549
 550    switch (TREE_CODE(name)) {
 551       case IDENTIFIER_NODE :
 552          s = IDENTIFIER_POINTER(name);
 553          break;
 554       case VAR_DECL :
 555          s = declname(name);
 556          break;
 557       case COMPONENT_REF :
 558          gen_assign(xf,TREE_OPERAND(name,0));
 559          gen_assign(xf,TREE_OPERAND(name,1));
 560          break;
 561       case INDIRECT_REF :
 562       case OFFSET_REF :
 563       case ARRAY_REF :
 564       case BUFFER_REF :
 565          gen_assign(xf,TREE_OPERAND(name,0));
 566          break;
 567       case COMPOUND_EXPR :
 568          gen_assign(xf,TREE_OPERAND(name,1));
 569          break;
 570       default :
 571          break;
 572     };
 573
 574    if (s != NULL) {
 575       fprintf(xref_file,"ASG %s %d %s\n",filename(xf),lineno,s);
 576     };
 577 };
 578
 579
 580
 581
 582
 583 /************************************************************************/
 584 /*                                                                      */
 585 /*      FIELD_xref_hier -- handle hierarchy                             */
 586 /*                                                                      */
 587 /************************************************************************/
 588
 589
 590 void
 591 FIELD_xref_hier(cls,base,pub,virt,frnd)
 592    String cls;
 593    String base;
 594    int pub;
 595    int virt;
 596    int frnd;
 597 {
 598    XREF_FILE xf;
 599
 600    if (!doing_xref) return;
 601    xf = find_file(input_filename);
 602    if (xf == NULL) return;
 603
 604    fprintf(xref_file,"HIE %s %d %s %s %d %d %d\n",
 605               filename(xf),lineno,cls,base,pub,virt,frnd);
 606 };
 607
 608
 609
 610
 611
 612 /************************************************************************/
 613 /*                                                                      */
 614 /*      FIELD_xref_member -- handle member                              */
 615 /*                                                                      */
 616 /************************************************************************/
 617
 618
 619 void
 620 FIELD_xref_member(cls,fld)
 621    tree cls;
 622    tree fld;
 623 {
 624    XREF_FILE xf;
 625    String prot;
 626    Integer confg,pure;
 627    String d,p;
 628    Integer i;
 629    char buf[1024],bufa[1024];
 630
 631    if (!doing_xref) return;
 632    xf = find_file(fld->decl.filename);
 633    if (xf == NULL) return;
 634
 635    if (TREE_PRIVATE(fld)) prot = "PRIVATE";
 636    else if (TREE_PROTECTED(fld)) prot = "PROTECTED";
 637    else prot = "PUBLIC";
 638
 639    confg = 0;
 640    if (TREE_CODE(fld) == FUNCTION_DECL && DECL_CONST_MEMFUNC_P(fld)) confg = 1;
 641    else if (TREE_CODE(fld) == CONST_DECL) confg = 1;
 642
 643    pure = 0;
 644    if (TREE_CODE(fld) == FUNCTION_DECL && DECL_ABSTRACT_VIRTUAL_P(fld)) pure = 1;
 645
 646    d = IDENTIFIER_POINTER(cls);
 647    sprintf(buf,"%d%s",strlen(d),d);
 648    i = strlen(buf);
 649    strcpy(bufa,declname(fld));
 650    for (p = &bufa[1]; *p != 0; ++p) {
 651       if (p[0] == '_' && p[1] == '_' && p[2] >= '0' && p[2] <= '9') {
 652          if (strncmp(&p[2],buf,i) == 0) *p = 0;
 653          break;
 654        }
 655       else if (p[0] == '_' && p[1] == '_' && p[2] == 'C' && p[3] >= '0' && p[3] <= '9') {
 656          if (strncmp(&p[3],buf,i) == 0) *p = 0;
 657          break;
 658        };
 659     };
 660
 661    fprintf(xref_file,"MEM %s %d %s %s %s %d %d %d %d %d %d %d\n",
 662               filename(xf),fld->decl.linenum,d,
 663               bufa,
 664               prot,
 665               (TREE_CODE(fld) == FUNCTION_DECL ? 0 : 1),
 666               (TREE_INLINE(fld) ? 1 : 0),
 667               (DECL_FRIEND_P(fld) ? 1 : 0),
 668               (DECL_VIRTUAL_P(fld) ? 1 : 0),
 669               (TREE_STATIC(fld) ? 1 : 0),
 670               pure,confg);
 671 };
 672
 673
 674
 675
 676
 677
 678 /************************************************************************/
 679 /*                                                                      */
 680 /*      find_file -- find file entry given name                         */
 681 /*                                                                      */
 682 /************************************************************************/
 683
 684
 685
 686 static XREF_FILE
 687 find_file(name)
 688    String name;
 689 {
 690    XREF_FILE xf;
 691
 692    for (xf = all_files; xf != NULL; xf = xf->next) {
 693       if (STREQL(name,xf->name)) break;
 694     };
 695
 696    return xf;
 697 };
 698
 699
 700
 701
 702
 703 /************************************************************************/
 704 /*                                                                      */
 705 /*      filename -- return name for output                              */
 706 /*                                                                      */
 707 /************************************************************************/
 708
 709
 710 static String
 711 filename(xf)
 712    XREF_FILE xf;
 713 {
 714    if (xf == NULL) {
 715       last_file = NULL;
 716       return "*";
 717     };
 718
 719    if (last_file == xf) return "*";
 720
 721    last_file = xf;
 722
 723    return xf->name;
 724 };
 725
 726
 727
 728
 729
 730
 731 /************************************************************************/
 732 /*                                                                      */
 733 /*      fctname -- return name for function                             */
 734 /*                                                                      */
 735 /************************************************************************/
 736
 737
 738 static String
 739 fctname(fct)
 740    tree fct;
 741 {
 742    extern char * declname();
 743    static char fctbuf[1024];
 744    String s;
 745
 746    if (fct == NULL && last_fct == NULL) return "*";
 747
 748    if (fct == NULL) {
 749       last_fct = NULL;
 750       return "*TOP*";
 751     };
 752
 753    if (fct == last_fct) return "*";
 754
 755    last_fct = fct;
 756
 757    s = declname(fct);
 758    s = fixname(s,fctbuf);
 759
 760    return s;
 761 };
 762
 763
 764
 765
 766
 767
 768 /************************************************************************/
 769 /*                                                                      */
 770 /*      declname -- print name for declaration                          */
 771 /*                                                                      */
 772 /************************************************************************/
 773
 774
 775 static String
 776 declname(dcl)
 777    tree dcl;
 778 {
 779    if (DECL_NAME(dcl) == NULL) return "?";
 780
 781    return IDENTIFIER_POINTER (DECL_NAME (dcl));
 782 }
 783
 784
 785
 786
 787
 788 /************************************************************************/
 789 /*                                                                      */
 790 /*      simplify_type -- simplify a type string                         */
 791 /*                                                                      */
 792 /************************************************************************/
 793
 794
 795 static void
 796 simplify_type(typ)
 797    String typ;
 798 {
 799    String s;
 800    Integer lvl,i;
 801
 802    i = strlen(typ);
 803    while (i > 0 && isspace(typ[i-1])) typ[--i] = 0;
 804
 805    if (i > 7 && STREQL(&typ[i-5],"const")) {
 806       typ[i-5] = 0;
 807       i -= 5;
 808     };
 809
 810    if (typ[i-1] != ')') return;
 811
 812    s = &typ[i-2];
 813    lvl = 1;
 814    while (*s != 0) {
 815       if (*s == ')') ++lvl;
 816       else if (*s == '(') {
 817          --lvl;
 818          if (lvl == 0) {
 819             s[1] = ')';
 820             s[2] = 0;
 821             break;
 822           };
 823        };
 824       --s;
 825     };
 826
 827    if (*s != 0 && s[-1] == ')') {
 828       --s;
 829       --s;
 830       if (*s == '(') s[2] = 0;
 831       else if (*s == ':') {
 832          while (*s != '(') --s;
 833          s[1] = ')';
 834          s[2] = 0;
 835        };
 836     };
 837 };
 838
 839
 840
 841
 842
 843 /************************************************************************/
 844 /*                                                                      */
 845 /*      fixname -- fixup a function name (take care of embedded spaces  */
 846 /*                                                                      */
 847 /************************************************************************/
 848
 849
 850 static String
 851 fixname(nam,buf)
 852    String nam;
 853    String buf;
 854 {
 855    String s,t;
 856    int fg;
 857
 858    s = nam;
 859    t = buf;
 860    fg = 0;
 861
 862    while (*s != 0) {
 863       if (*s == ' ') {
 864          *t++ = '\36';
 865          ++fg;
 866        }
 867       else *t++ = *s;
 868       ++s;
 869     };
 870
 871    if (fg == 0) return nam;
 872
 873    return buf;
 874 };
 875
 876
 877
 878
 879
 880 /************************************************************************/
 881 /*                                                                      */
 882 /*      open_xref_file -- open file for xrefing                         */
 883 /*                                                                      */
 884 /************************************************************************/
 885
 886
 887 static void
 888 open_xref_file(file)
 889    String file;
 890 {
 891    String s,t;
 892
 893    s = rindex(file,'/');
 894    if (s == NULL) sprintf(xref_name,".%s.gxref",file);
 895    else {
 896       ++s;
 897       strcpy(xref_name,file);
 898       t = rindex(xref_name,'/');
 899       ++t;
 900       *t++ = '.';
 901       strcpy(t,s);
 902       strcat(t,".gxref");
 903     };
 904
 905    xref_file = fopen(xref_name,"w");
 906
 907    if (xref_file == NULL) {
 908       error("Can't create cross-reference file `%s'",xref_name);
 909       doing_xref = 0;
 910     };
 911 };
 912
 913
 914
 915 #endif
 916
 917
 918 /* end of cplus-field.c */