tools/cxref/query/input.c

   1 /***************************************
   2   $Header$
   3
   4   C Cross Referencing & Documentation tool. Version 1.5b.
   5   ******************/ /******************
   6   Written by Andrew M. Bishop
   7
   8   This file Copyright 1995,96,97,99 Andrew M. Bishop
   9   It may be distributed under the GNU Public License, version 2, or
  10   any higher version.  See section COPYING of the GNU Public license
  11   for conditions under which this file may be redistributed.
  12   ***************************************/
  13
  14 #include <stdio.h>
  15 #include <stdlib.h>
  16 #include <string.h>
  17 #include <limits.h>
  18
  19 #define TYPE_MAX_LEN 256        /*+ The maximum type definition length +*/
  20 #define FUNC_MAX_LEN 64         /*+ The maximum function name length. +*/
  21 #if defined(PATH_MAX) && defined(NAME_MAX)
  22 #define FILE_MAX_LEN (PATH_MAX+NAME_MAX) /*+ The maximum filename length. +*/
  23 #elif defined(PATH_MAX)
  24 #define FILE_MAX_LEN (PATH_MAX+256) /*+ The maximum filename length. +*/
  25 #else
  26 #define FILE_MAX_LEN 512        /*+ The maximum filename length. +*/
  27 #endif
  28
  29 #include "../memory.h"
  30 #include "../datatype.h"
  31 #include "../cxref.h"
  32 #include "query.h"
  33
  34 /*+ The names of the function cross reference files. +*/
  35 #define XREF_FUNC_FILE   ".function"
  36
  37 /*+ The names of the variable cross reference files. +*/
  38 #define XREF_VAR_FILE    ".variable"
  39
  40 /*+ The names of the include cross reference files. +*/
  41 #define XREF_INC_FILE    ".include"
  42
  43 /*+ The names of the type cross reference files. +*/
  44 #define XREF_TYPE_FILE   ".typedef"
  45
  46 /*+ The command line switch that sets the amount of cross referencing to do. +*/
  47 extern int option_xref;
  48
  49 /*+ The command line switch for the output name, +*/
  50 extern char *option_odir,       /*+ The directory to use. +*/
  51             *option_name;       /*+ The base part of the name. +*/
  52
  53 extern File *files;             /*+ The files that are queried. +*/
  54 extern int n_files;             /*+ The number of files referenced. +*/
  55
  56 extern Function *functions;     /*+ The functions that are queried. +*/
  57 extern int n_functions;         /*+ The number of functions referenced. +*/
  58
  59 extern Variable *variables;     /*+ The variables that are queried. +*/
  60 extern int n_variables;         /*+ The number of variables referenced. +*/
  61
  62 extern Typedef *typedefs;       /*+ The type definitions that are queried. +*/
  63 extern int n_typedefs;          /*+ The number of typedefs referenced. +*/
  64
  65 /* Local functions */
  66
  67 static void cross_reference_files(void);
  68 static void cross_reference_functions(void);
  69 static void cross_reference_variables(void);
  70
  71 /*++++++++++++++++++++++++++++++++++++++
  72   Read in all the information from the cross reference files.
  73   ++++++++++++++++++++++++++++++++++++++*/
  74
  75 void LoadInCrossRefs(void)
  76 {
  77  FILE *in;
  78  char *ifile;
  79
  80  /* Format: filename [[%]include1] [[%]include2] ... : Files include1, include2, ... are included in filename;
  81     those with a % are local. */
  82
  83  /* First do the files */
  84    {
  85     char include[FILE_MAX_LEN],filename[FILE_MAX_LEN+1],ch;
  86
  87     ifile=ConcatStrings(4,option_odir,"/",option_name,XREF_INC_FILE);
  88
  89     in =fopen(ifile,"r");
  90
  91     if(!in)
  92       {fprintf(stderr,"cxref-query: Failed to open the include cross reference file '%s'\n",ifile);exit(1);}
  93
  94     while(fscanf(in,"%s%c",filename,&ch)==2)
  95       {
  96        if(n_files)
  97           files=(File*)Realloc(files,(n_files+1)*sizeof(File*));
  98        else
  99           files=(File*)Malloc(sizeof(File*));
 100
 101        files[n_files]=(File)Calloc(1,sizeof(struct _File));
 102        files[n_files]->name=MallocString(filename);
 103        files[n_files]->inc_in=NewStringList();
 104        files[n_files]->f_refs=NewStringList2();
 105        files[n_files]->v_refs=NewStringList2();
 106
 107        while(ch==' ')
 108          {
 109           Include inc=(Include)Calloc(1,sizeof(struct _Include));
 110
 111           fscanf(in,"%s%c",include,&ch);
 112
 113           if(include[0]=='%')
 114              {inc->scope=LOCAL;
 115               inc->name=MallocString(&include[1]);}
 116           else
 117              {inc->scope=GLOBAL;
 118               inc->name=MallocString(include);}
 119
 120           AddToLinkedList(files[n_files]->includes,Include,inc);
 121          }
 122        n_files++;
 123       }
 124
 125     cross_reference_files();
 126
 127     fclose(in);
 128    }
 129
 130  /* Format: filename funcname scope [[%][&]funcname1] [[%][&]funcname2] ... : The function funcname in file filename
 131     calls or references functions funcname1, funcname2 ... ; those with a % are local, with a & are references. */
 132  /* Format: filename $ 0 [[%]&funcname1] [[%]&funcname2] ... : The file references functions funcname1, funcname2 ... ;
 133     those with a % are local.  */
 134
 135  /* Now do the functions */
 136    {
 137     char ch,funcname[FUNC_MAX_LEN+1],filename[FILE_MAX_LEN+1],called[FUNC_MAX_LEN+1];
 138     int scope;
 139
 140     ifile=ConcatStrings(4,option_odir,"/",option_name,XREF_FUNC_FILE);
 141
 142     in =fopen(ifile,"r");
 143
 144     if(!in)
 145       {fprintf(stderr,"cxref-query: Failed to open the functional cross reference file '%s'\n",ifile);exit(1);}
 146
 147     while(fscanf(in,"%s %s %d%c",filename,funcname,&scope,&ch)==4)
 148       {
 149        int i;
 150        StringList2 f_refs;
 151
 152        for(i=0;i<n_files;i++)
 153           if(!strcmp(files[i]->name,filename))
 154              break;
 155
 156        if(funcname[0]=='$')
 157           f_refs=files[i]->f_refs;
 158        else
 159          {
 160           if(n_functions)
 161              functions=(Function*)Realloc(functions,(n_functions+1)*sizeof(Function*));
 162           else
 163              functions=(Function*)Malloc(sizeof(Function*));
 164
 165           functions[n_functions]=(Function)Calloc(1,sizeof(struct _Function));
 166
 167           AddToLinkedList(files[i]->functions,Function,functions[n_functions]);
 168
 169           functions[n_functions]->comment=MallocString(filename); /* Use comment field for filename */
 170           functions[n_functions]->name=MallocString(funcname);
 171           functions[n_functions]->scope=scope;
 172           functions[n_functions]->used=NewStringList2();
 173           functions[n_functions]->calls=NewStringList2();
 174           functions[n_functions]->called=NewStringList2();
 175           functions[n_functions]->f_refs=NewStringList2();
 176           functions[n_functions]->v_refs=NewStringList2();
 177
 178           f_refs=functions[n_functions]->f_refs;
 179          }
 180
 181        while(ch==' ')
 182          {
 183           char* c;
 184           fscanf(in,"%s%c",called,&ch);
 185
 186           c=called;
 187           if(c[0]=='%') c++;
 188           if(c[0]=='&')
 189             {
 190              if(c==called)
 191                 AddToStringList2(f_refs,c+1,NULL,1,1);
 192              else
 193                 AddToStringList2(f_refs,c+1,filename,1,1);
 194             }
 195           else
 196             {
 197              if(c==called)
 198                 AddToStringList2(functions[n_functions]->calls,c,NULL,1,1);
 199              else
 200                 AddToStringList2(functions[n_functions]->calls,c,filename,1,1);
 201             }
 202          }
 203
 204        if(funcname[0]!='$')
 205           n_functions++;
 206       }
 207
 208     cross_reference_functions();
 209
 210     fclose(in);
 211    }
 212
 213  /* Format: filename varname scope [$] [[%]funcname1] [[%]funcname2] ... : variable varname is used in
 214     the file filename if $, and functions funcname1, funcname2 ... Those with a % are local.  */
 215
 216  /* Now do the variables */
 217    {
 218     char varname[FUNC_MAX_LEN+1],filename[FILE_MAX_LEN+1],funcname[FUNC_MAX_LEN+1],ch;
 219     int scope;
 220
 221     ifile=ConcatStrings(4,option_odir,"/",option_name,XREF_VAR_FILE);
 222
 223     in =fopen(ifile,"r");
 224
 225     if(!in)
 226       {fprintf(stderr,"cxref-query: Failed to open the variable cross reference file '%s'\n",ifile);exit(1);}
 227
 228     while(fscanf(in,"%s %s %d%c",filename,varname,&scope,&ch)==4)
 229       {
 230        int i;
 231
 232        if(n_variables)
 233           variables=(Variable*)Realloc(variables,(n_variables+1)*sizeof(Variable*));
 234        else
 235           variables=(Variable*)Malloc(sizeof(Variable*));
 236
 237        variables[n_variables]=(Variable)Calloc(1,sizeof(struct _Variable));
 238
 239        for(i=0;i<n_files;i++)
 240           if(!strcmp(files[i]->name,filename))
 241              AddToLinkedList(files[i]->variables,Variable,variables[n_variables]);
 242
 243        variables[n_variables]->comment=MallocString(filename); /* Use comment field for filename */
 244        variables[n_variables]->name=MallocString(varname);
 245        variables[n_variables]->visible=NewStringList2();
 246        variables[n_variables]->used=NewStringList2();
 247        variables[n_variables]->scope=scope;
 248
 249        while(ch==' ')
 250          {
 251           fscanf(in,"%s%c",funcname,&ch);
 252
 253           if(funcname[0]=='$')
 254              AddToStringList2(variables[n_variables]->used,"$",filename,1,0);
 255           else
 256              if(funcname[0]=='%')
 257                 AddToStringList2(variables[n_variables]->used,&funcname[1],filename,1,1);
 258              else
 259                 AddToStringList2(variables[n_variables]->used,funcname,NULL,1,1);
 260          }
 261        n_variables++;
 262       }
 263
 264     cross_reference_variables();
 265
 266     fclose(in);
 267    }
 268
 269  /* Format: filename typename type... : For a typedef type.     */
 270  /* Format: filename #        type... : For a non typedef type. */
 271
 272  /* Now do the types */
 273    {
 274     char typename[FILE_MAX_LEN+1],filename[FILE_MAX_LEN+1],typetype[TYPE_MAX_LEN+1];
 275
 276     ifile=ConcatStrings(4,option_odir,"/",option_name,XREF_TYPE_FILE);
 277
 278     in =fopen(ifile,"r");
 279
 280     if(!in)
 281       {fprintf(stderr,"cxref-query: Failed to open the typedef reference file '%s'\n",ifile);exit(1);}
 282
 283     while(fscanf(in,"%s %s",filename,typename)==2)
 284       {
 285        int i;
 286
 287        fgets(typetype,TYPE_MAX_LEN,in);
 288        typetype[strlen(typetype)-1]=0;
 289
 290        if(n_typedefs)
 291           typedefs=(Typedef*)Realloc(typedefs,(n_typedefs+1)*sizeof(Typedef*));
 292        else
 293           typedefs=(Typedef*)Malloc(sizeof(Typedef*));
 294
 295        typedefs[n_typedefs]=(Typedef)Calloc(1,sizeof(struct _Typedef));
 296
 297        for(i=0;i<n_files;i++)
 298           if(!strcmp(files[i]->name,filename))
 299              AddToLinkedList(files[i]->typedefs,Typedef,typedefs[n_typedefs]);
 300
 301        typedefs[n_typedefs]->comment=MallocString(filename); /* Use comment field for filename */
 302
 303        if(typename[0]!='#')
 304          {
 305           typedefs[n_typedefs]->name=MallocString(typename);
 306           typedefs[n_typedefs]->type=MallocString(&typetype[1]);
 307          }
 308        else
 309          {
 310           typedefs[n_typedefs]->name=MallocString(&typetype[1]);
 311           typedefs[n_typedefs]->type=NULL;
 312          }
 313
 314        n_typedefs++;
 315       }
 316
 317     fclose(in);
 318    }
 319
 320 }
 321
 322
 323 /*++++++++++++++++++++++++++++++++++++++
 324   Performs all of the cross referencing between files, includes and included in.
 325   ++++++++++++++++++++++++++++++++++++++*/
 326
 327 static void cross_reference_files(void)
 328 {
 329  int i;
 330
 331  for(i=0;i<n_files;i++)
 332    {
 333     int j;
 334     Include inc=files[i]->includes;
 335
 336     while(inc)
 337       {
 338        for(j=0;j<n_files;j++)
 339           if(!strcmp(inc->name,files[j]->name))
 340             {
 341              inc->includes=files[j]->includes;
 342              AddToStringList(files[j]->inc_in,files[i]->name,1,1);
 343             }
 344        inc=inc->next;
 345       }
 346    }
 347 }
 348
 349
 350 /*++++++++++++++++++++++++++++++++++++++
 351   Performs all of the cross referencing between global functions and functions that they call.
 352   ++++++++++++++++++++++++++++++++++++++*/
 353
 354 static void cross_reference_functions(void)
 355 {
 356  int i1,j1,i2;
 357
 358  for(i1=0;i1<n_functions;i1++)
 359    {
 360     Function func1=functions[i1];
 361
 362     for(j1=0;j1<func1->calls->n;j1++)
 363       {
 364        if(!func1->calls->s2[j1])
 365           for(i2=0;i2<n_functions;i2++)
 366             {
 367              Function func2=functions[i2];
 368
 369              if(!strcmp(func1->calls->s1[j1],func2->name))
 370                {
 371                 func1->calls->s2[j1]=MallocString(func2->comment);
 372                 break;
 373                }
 374             }
 375
 376        if(func1->calls->s2[j1])
 377           for(i2=0;i2<n_functions;i2++)
 378             {
 379              Function func2=functions[i2];
 380
 381              if(!strcmp(func1->calls->s1[j1],func2->name) && !strcmp(func1->calls->s2[j1],func2->comment))
 382                {
 383                 AddToStringList2(func2->called,func1->name,func1->comment,1,1);
 384                 break;
 385                }
 386             }
 387       }
 388
 389     for(j1=0;j1<func1->f_refs->n;j1++)
 390       {
 391        if(!func1->f_refs->s2[j1])
 392           for(i2=0;i2<n_functions;i2++)
 393             {
 394              Function func2=functions[i2];
 395
 396              if(!strcmp(func1->f_refs->s1[j1],func2->name))
 397                {
 398                 func1->f_refs->s2[j1]=MallocString(func2->comment);
 399                 break;
 400                }
 401             }
 402
 403        if(func1->f_refs->s2[j1])
 404           for(i2=0;i2<n_functions;i2++)
 405             {
 406              Function func2=functions[i2];
 407
 408              if(!strcmp(func1->f_refs->s1[j1],func2->name) && !strcmp(func1->f_refs->s2[j1],func2->comment))
 409                {
 410                 AddToStringList2(func2->used,func1->name,func1->comment,1,1);
 411                 break;
 412                }
 413             }
 414       }
 415    }
 416
 417  for(i1=0;i1<n_files;i1++)
 418    {
 419     File file1=files[i1];
 420
 421     for(j1=0;j1<file1->f_refs->n;j1++)
 422       {
 423        if(!file1->f_refs->s2[j1])
 424           for(i2=0;i2<n_functions;i2++)
 425             {
 426              Function func2=functions[i2];
 427
 428              if(!strcmp(file1->f_refs->s1[j1],func2->name))
 429                {
 430                 file1->f_refs->s2[j1]=MallocString(func2->comment);
 431                 break;
 432                }
 433             }
 434
 435        if(file1->f_refs->s2[j1])
 436           for(i2=0;i2<n_functions;i2++)
 437             {
 438              Function func2=functions[i2];
 439
 440              if(!strcmp(file1->f_refs->s1[j1],func2->name) && !strcmp(file1->f_refs->s2[j1],func2->comment))
 441                {
 442                 AddToStringList2(func2->used,"$",file1->name,1,1);
 443                 break;
 444                }
 445             }
 446       }
 447    }
 448 }
 449
 450
 451 /*++++++++++++++++++++++++++++++++++++++
 452   Performs all of the cross referencing between global variables and functions that use them.
 453   ++++++++++++++++++++++++++++++++++++++*/
 454
 455 static void cross_reference_variables(void)
 456 {
 457  int i1,j1,i2;
 458
 459  for(i1=0;i1<n_variables;i1++)
 460    {
 461     Variable var1=variables[i1];
 462
 463     for(j1=0;j1<var1->used->n;j1++)
 464       {
 465        if(var1->used->s1[j1][0]!='$' && !var1->used->s2[j1])
 466           for(i2=0;i2<n_functions;i2++)
 467             {
 468              Function func2=functions[i2];
 469
 470              if(!strcmp(var1->used->s1[j1],func2->name))
 471                {
 472                 var1->used->s2[j1]=MallocString(func2->comment);
 473                 break;
 474                }
 475             }
 476
 477        if(var1->used->s1[j1][0]=='$')
 478           for(i2=0;i2<n_files;i2++)
 479             {
 480              File file2=files[i2];
 481
 482              if(!strcmp(var1->used->s2[j1],file2->name))
 483                {
 484                 AddToStringList2(file2->v_refs,var1->name,var1->comment,1,1);
 485                 break;
 486                }
 487             }
 488        else if(var1->used->s2[j1])
 489           for(i2=0;i2<n_functions;i2++)
 490             {
 491              Function func2=functions[i2];
 492
 493              if(!strcmp(var1->used->s1[j1],func2->name) && !strcmp(var1->used->s2[j1],func2->comment))
 494                {
 495                 AddToStringList2(func2->v_refs,var1->name,var1->comment,1,1);
 496                 break;
 497                }
 498             }
 499       }
 500    }
 501 }