home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / forut062.zip / ForUtil-0.62 / ffscan / ffscan.l < prev    next >
Text File  |  1996-08-28  |  17KB  |  657 lines
  1. %{
  2. #ifndef lint
  3. static char rcsId[]="$Source: /usr/local/rcs/ForUtil/ffscan/RCS/ffscan.l,v $";
  4. #endif
  5. /*****
  6. * fflow.l : f77 argument checker
  7. *
  8. * This file Version    $Revision: 1.5 $
  9. *
  10. * Creation date:    Wed Jul 17 22:38:31 GMT+0100 1996
  11. * Last modification:     $Date: 1996/08/28 17:50:18 $
  12. * By:            $Author: koen $
  13. * Current State:    $State: Exp $
  14. *
  15. * Author:        koen
  16. * (C)Copyright 1995-1996 Ripley Software Development
  17. * All Rights Reserved
  18. *
  19. * This program has one undocumented switch for debugging purposes:
  20. * -m for memory information under msdos
  21. *****/
  22. /*****
  23. * ChangeLog 
  24. * $Log: ffscan.l,v $
  25. * Revision 1.5  1996/08/28 17:50:18  koen
  26. * Changed verbose options and argument printing in count_args. 
  27. * Added print_version_id.
  28. *
  29. * Revision 1.4  1996/08/27 19:16:48  koen
  30. * Heavy changes: new scanner rules; optimized memory allocations; Moved
  31. * a number of routines to libflow.c
  32. *
  33. * Revision 1.3  1996/08/07 21:14:56  koen
  34. * Updated for MSDOS
  35. *
  36. * Revision 1.2  1996/08/02 14:50:47  koen
  37. * moved all system dependencies to lib/sysdeps.h
  38. *
  39. * Revision 1.1  1996/07/30 02:04:03  koen
  40. * Initial Revision. Based on fflow and scan_commons.
  41. *
  42. *****/
  43. #ifdef HAVE_CONFIG_H
  44. #include "autoconf.h"
  45. #endif
  46.  
  47. #include <stdio.h>
  48. #include <string.h>
  49. #include <ctype.h>
  50.  
  51. #include "forutil.h"
  52. #include "memmacros.h"
  53. #include "version.h"
  54. #include "libflow.h"
  55.  
  56. /**** Private Variables ****/
  57. static char *outfile;
  58. static int verbose, num_diff; 
  59. static int total_routines, total_calls, total_funcs;
  60. static int never_invoked;
  61. static FILE *output_file;
  62.  
  63. static char *usage = {"Usage: %s [-fhnqv] [-Eext] [-Idir] [-ofile] [-xname] [files]\n\n"
  64. " Scans the arguments of calls and compares them with the subroutine definition.\n\n"
  65. " Options\n"
  66. "\t-f: print precise location of filenames. Otherwise print name\n"
  67. "\t    of file only.\n"
  68. "\t-h, --help: print this help\n"
  69. "\t-n: tell what subroutines are never invoked\n"
  70. "\t-q: be really quiet (usefull if called from a script)\n"
  71. "\t-v: be verbose. Additional -v increases verbosiness\n"
  72. "\t--version: display version number\n"
  73. "\t-Eext: extensions to use for retrieving files. Multiple -E allowed.\n"
  74. "\t-Idir: get files from directory dir. Multiple -I allowed\n"
  75. "\t-ofile: file to write flowgraph to, default is stdout\n"
  76. "\t-xname.f: exclude file. Multiple -x allowed\n\n"
  77. "(C)Copyright 1995-1996 by Ripley Software Development\n"};
  78.  
  79. /**** Private Functions ****/
  80. static int set_global_option(char *arg);
  81. static inline void count_args(char *text);
  82. static void cross_check(FILE *file, flowInfo *list);
  83.  
  84. /*****
  85. * On the regular expressions below:
  86. * The routine and program regexps _must_ start with spaces (or tabs) (6 min.)
  87. * at the beginning of a line followed by the name of keyword subroutine or 
  88. * program and followed by a space (or a tab)
  89. * The regexp for call and function is different in that it does not have to 
  90. * start at the beginning of the line.
  91. * It must start with at least one space and may be preceeded by any combination
  92. * of whitespace, characters, digits and delimiters tokens.
  93. * The name of the (function,subroutine,program) may _not_ start with a left
  94. * or right brace or a single quote. The name itself may be made by any 
  95. * combination of alpha-numeric characters and underscores and can be followed
  96. * by an optional space or newline.
  97. * The regexps for the argument blocks is split in two parts.
  98. * The first part is the regexp for a single line of arguments: it may start 
  99. * with up to six spaces, followed by any possible character (continuation char)
  100. * any number of spaces and a left brace. After that any number of characters,
  101. * followed by an optional right brace, an optional space and and optional
  102. * newline.
  103. * The second part is an argument list that may start right after the name
  104. * of a (function,subroutine,program). It can have up to five spaces, any 
  105. * possible character except a space (continuation char), optional spaces,
  106. * an optional left brace. After that any number of chars followed by an
  107. * optional right brace, space and newline.
  108. * The regexp field <FNAME> contains three different regexps which will
  109. * match (to my knowledge) any formulation of a function or subroutine
  110. * definition with any sort of argument specification, including no arguments.
  111. *****/
  112. %}
  113.  
  114. routine  ^([ \t]{6,})subroutine[ \t]
  115. program  ^([ \t]{6,})program[ \t]
  116. function ^([ \t]{6,})[ [:alpha:]\*[:digit:]]*function[ \t]
  117. call     [^('][ \t]{1,}call[ ]
  118. name [^\(\)' ]*[a-zA-Z0-9_]+[ \n]?
  119. argline [ ]{0,6}.?[ ]*\(.+\)?[ ]?\n?
  120. argblock [ ]{5}[^ ][ ]*\(?.+\)?[ ]?\n?
  121. nl \n
  122.  
  123. %option caseless yylineno
  124.  
  125. %x FNAME
  126.  
  127. %%
  128. ^[*cC].* ; /* eat up comments entirely */  
  129. {program}    {
  130.             action = ADDFUNC; 
  131.             Type   = PROGRAM;
  132.             BEGIN FNAME;
  133.         }  
  134. {function}    {
  135.             numfunc++;
  136.             action = ADDFUNC; 
  137.             Type   = FUNCTION; 
  138.             BEGIN FNAME;
  139.         }  
  140. {routine}    {
  141.             numroutine++;
  142.             action = ADDFUNC; 
  143.             Type   = SUBROUTINE; 
  144.             BEGIN FNAME;
  145.         } 
  146. {call}        {
  147.             numcall++;
  148.             action = ADDCALL; 
  149.             Type   = UNKNOWN; 
  150.             BEGIN FNAME;
  151.         } 
  152. <FNAME>{name}{argline}* |
  153. <FNAME>{name}{argblock}* |
  154. <FNAME>{name}{argline}{argblock}* {
  155.             count_args(yytext);
  156.             BEGIN 0;
  157.         }  
  158. {nl}        BEGIN 0;
  159. .        ; /* do nothing  for all other remaining chars */
  160. %%
  161.  
  162. /*****
  163. * Count all arguments in the given text
  164. *****/
  165. static inline void
  166. count_args(char *text)
  167. {
  168.     char *string = text;
  169.     char func_name[64];
  170.     char *args = NULL;
  171.     int brace = 0, num_args = 0, num_line = 0, at_bol = 0;
  172.  
  173.     /* get function name */
  174.     for(;*string !='\0' && *string != '(' && *string != '\n' && 
  175.         !isspace(*string) ; string++);
  176.  
  177.     /* do not overflow name space */
  178.     strncpy(func_name, text, string - text > 64 ? 64 : string - text);
  179.  
  180.     /* null-terminate */
  181.     func_name[string-text] = '\0';
  182.     /* only if we have to be very verbose */
  183.     if(verbose > 2)
  184.     {    
  185.         char *chPtr;
  186.         int i = 0;
  187.         /* copy remaining args */
  188.         checked_alloca(args, strlen(text), char);
  189.         strncpy(args, string, strlen(string));
  190.         args[strlen(string)] = '\0';
  191.         printf("-------------------\n");
  192.         /* 
  193.         * print out the text preceeded with line numbers. 
  194.         * This slows things seriously down!
  195.         */
  196.         printf("line %i, text scanned:\n", yylineno);
  197.         printf("%i: ", i);
  198.         for(chPtr = text; *chPtr != '\0'; chPtr++)
  199.         {
  200.             putc(*chPtr, stdout);
  201.             if(*chPtr == '\n' && *(chPtr+1)!='\0')
  202.                 printf("%i:", ++i);
  203.         }
  204.         putc('\n', stdout);
  205.     }
  206.     while(*string)
  207.     {
  208.         switch(*string)
  209.         {
  210.             case '(':     /* initialize argcount. */
  211.                 if(num_args == 0)
  212.                     num_args++;
  213.                 brace++;
  214.                 break;
  215.             case ')':
  216.                 brace--;
  217.                 break;
  218.             case '*': /* eat up comments entirely */
  219.             case 'c':
  220.             case 'C':
  221.                 if(at_bol)
  222.                 {
  223.                     if(verbose > 2)
  224.                         printf("Rejecting comment on "
  225.                             "line %i\n", num_line); 
  226.                     while(*string != '\0' && 
  227.                         *string != '\n')
  228.                         string++;
  229.                     at_bol = 0;
  230.                 }
  231.                 break;
  232.             case '\'':
  233.                 string++;
  234.                 while(*string != '\0' && *string != '\'')
  235.                 {
  236.                     if(*string == '\n')
  237.                         num_line++;
  238.                     string++;
  239.                 }
  240.                 break;
  241.             case ',':     /* only when single left brace open*/
  242.                 if(brace == 1)    
  243.                     num_args++;
  244.                 break;
  245.         }
  246.         if(*string == '\0')
  247.             break;
  248.         at_bol = 0;
  249.         if(*string == '\n')
  250.         {
  251.             num_line++;
  252.             at_bol = 1;
  253.         }
  254.         string++;
  255.     }
  256.     /* only if we have to be very verbose */
  257.     if(verbose > 2)
  258.     {
  259.         if(action == ADDFUNC)
  260.             printf("routine name is %s\nargs are: %s", func_name,
  261.                 num_args == 0 ? "<none>\n":args);
  262.         if(action == ADDCALL)
  263.             printf("call made: %s\nargs supplied are: %s",
  264.                 func_name, num_args == 0 ? "<none>\n":args);
  265.         printf("brace count: %i\nargcount: %i\n", brace, num_args);
  266.         printf("-------------------\n");
  267.         fflush(stdout);
  268.     }
  269.     /* 19 continuation lines allowed by f77 standard */
  270.     if(num_line > 18)    
  271.     {
  272.             fprintf(stderr, "WARNING: more than 19 continuation "
  273.                 "lines ");
  274.             if(Type == ADDFUNC)
  275.                 fprintf(stderr, "in routine %s.\n", func_name); 
  276.             else
  277.                 fprintf(stderr, "in call to %s.\n", func_name);
  278.             fprintf(stderr,"near line %i in file %s%s\n", yylineno, 
  279.                 curr_path, curr_file);
  280.     }
  281.     if(brace != 0)
  282.     {
  283.         if(brace < 0)
  284.             fprintf(stderr, "WARNING: unbalanced right brace ");
  285.         else
  286.             fprintf(stderr, "WARNING: unbalanced left brace ");
  287.         fprintf(stderr, "on line %i of argument list ", num_line);
  288.         if(Type == ADDFUNC)
  289.             fprintf(stderr, "in routine %s.\n", func_name); 
  290.         else
  291.             fprintf(stderr, "in call to %s.\n", func_name);
  292.         fprintf(stderr,"near line %i in file %s%s\n", yylineno, 
  293.             curr_path, curr_file);
  294.     }
  295.     /*
  296.     * Depending on the action taken,
  297.     * add a new function to the flowgraph list or
  298.     * add an entry for a call made in the current 
  299.     * function
  300.     */
  301.     if(action == ADDFUNC)
  302.         add_new_func(func_name, yylineno, curr_path, curr_file, 
  303.             num_args);
  304.     else
  305.         add_new_call(func_name, yylineno, num_args);
  306. }
  307.  
  308. /*****
  309. * Perform argument check
  310. *****/
  311. static void
  312. cross_check(FILE *file, flowInfo *list)
  313. {
  314.     flowInfo *curr_func, *call; 
  315.     for(curr_func = list; curr_func != NULL; curr_func = curr_func->next) 
  316.     {
  317.         for(call = curr_func->calls; call != NULL; call = call->next)
  318.         {
  319.             if(call->parent && 
  320.                 call->num_args != call->parent->num_args)
  321.             {
  322.                 num_diff++;
  323.                 if(full_names)
  324.                 {
  325.                     fprintf(file, "---> %s called with %i "
  326.                         "args\n", 
  327.                         call->name, call->num_args);
  328.                     fprintf(file, "near line %i of %s%s\n",
  329.                         call->defline, curr_func->path,
  330.                         curr_func->file);
  331.                     fprintf(file, "Defined with %i args "
  332.                         "near line %i in \n",
  333.                         call->parent->num_args, 
  334.                         call->parent->defline);
  335.                     fprintf(file, "%s%s\n", 
  336.                         call->parent->path, 
  337.                         call->parent->file);
  338.                 }
  339.                 else
  340.                 {
  341.                     fprintf(file, "---> %s called with %i "
  342.                         "args ", 
  343.                         call->name, call->num_args);
  344.                     fprintf(file, "near line %i of %s\n", 
  345.                         call->defline, 
  346.                         curr_func->file);
  347.                     fprintf(file, "Defined with %i args ", 
  348.                         call->parent->num_args);
  349.                     fprintf(file, "near line %i in %s\n", 
  350.                         call->parent->defline, 
  351.                         call->parent->file);
  352.                 }
  353.             }
  354.         }
  355.     }
  356. }
  357.  
  358. /*****
  359. * Scan command line options
  360. *****/
  361. static int 
  362. set_global_option(char *arg)
  363. { 
  364.     switch(arg[0])
  365.     {
  366.         case 'f' :    /* use full names instead of filename only.*/
  367.             full_names = 1 ;
  368.             break;
  369.         case 'h' :    /* help requested */
  370.             printf(usage, progname); 
  371.             exit(2); 
  372.         case 'n' :    /* tell what subroutines are never invoked */
  373.             never_invoked = 1;
  374.             break;
  375. #ifdef __MSDOS__
  376.         case 'm' :    /* show memory usage under msdos */
  377.             need_mem_info_for_msdos = 1;
  378.             break;
  379. #endif
  380.         case 'q' :     /* be really quiet */
  381.             quiet = 1; 
  382.             verbose = 0; 
  383.             break; 
  384.         case 'v' :     /* be verbose */
  385.             verbose++;
  386.             break; 
  387.         case 'E' :    /* an extension specification */
  388.             SCAN_ARG("-E");
  389.             if(num_extensions == MAXEXTS)
  390.             {
  391.                 fprintf(stderr, "Capacity exceeded, more than "
  392.                     "%i extensions given on command line\n",
  393.                     MAXEXTS);
  394.                 fprintf(stderr,"Ignoring extension %s\n",arg+1);
  395.             }
  396.             else
  397.             {
  398.                 checked_malloc(ext_table[num_extensions], 
  399.                     strlen(arg+1)+1, char);
  400.                 strcpy(ext_table[num_extensions++], arg+1);
  401. #ifdef __MSDOS__ /* dos returns uppercase when building a filelist */
  402.                 upcase(ext_table[num_extensions-1]);
  403. #endif
  404.             }
  405.             return(1); 
  406.         case 'I' :    /* a directory specification */
  407.             SCAN_ARG("-I");
  408.             if(num_dirs_to_visit == MAXDIRS)
  409.             {
  410.                 fprintf(stderr,"Capacity exceeded, more than %i"
  411.                     " directories given on command line\n",
  412.                     MAXDIRS);
  413.                 fprintf(stderr,"Ignoring directory %s\n",arg+1);
  414.             }
  415.             else
  416.             {
  417.                 checked_malloc(dirs_to_visit[num_dirs_to_visit],
  418.                     strlen(arg+1)+1, char);
  419.                 strcpy(dirs_to_visit[num_dirs_to_visit++], 
  420.                     arg+1); 
  421.             }
  422.             return(1); 
  423.         case 'o' :    /* name of the output file */
  424.             SCAN_ARG("-o");
  425.             outfile = arg + 1;
  426.             return(1); 
  427.         case 'x' :    /* ignore the given file */
  428.             SCAN_ARG("-x");
  429.             if(num_ignore == MAXIGNORE)
  430.             {
  431.                 fprintf(stderr, "Capacity exceeded, more than "
  432.                     "%i ignores given on command line\n",
  433.                     MAXIGNORE);
  434.                 fprintf(stderr, "Ignoring option -x%s\n",arg+1);
  435.             }
  436.             else
  437.             {
  438.                 checked_malloc(ignore_list[num_ignore], 
  439.                     strlen(arg+1)+1, char);
  440.                 strcpy(ignore_list[num_ignore++], arg+1);
  441. #ifdef __MSDOS__ /* dos returns uppercase when building a filelist */
  442.                 upcase(ignore_list[num_ignore-1]);
  443. #endif
  444.             }
  445.             return(1); 
  446.         case '-' :            /* secondary options */
  447.             if(!strcmp("help", arg+1))    /* help wanted */
  448.             {
  449.                 printf(usage, progname); 
  450.                 exit(2); 
  451.             }
  452.             if(!strcmp("version", arg+1))    /* show version number*/
  453.             {
  454.                 print_version_id(progname, VERSION, "$Revision: 1.5 $");
  455.                 exit(2);
  456.             }        /* fall through */
  457.         default:
  458.             fprintf(stderr,"unknown option -%s\n", arg);
  459.             exit(3);
  460.     }
  461.     return(0); 
  462. }
  463.  
  464. /*****
  465. * main for ffscan
  466. *****/
  467. int 
  468. main (int argc, char **argv)
  469. { 
  470.     int i, narg;
  471.     char *arg;
  472.  
  473.     /* set global default values */
  474.     initialise(argv[0]);
  475.  
  476.     if(argc == 1) 
  477.     {
  478.         fprintf(stderr, "%s: no files given\n",progname);
  479.         printf(usage, progname);
  480.         exit(4);
  481.     }
  482.  
  483.     /* Default values */
  484.     outfile = "stdout";
  485.  
  486.     /* scan for any command line options */
  487.     arg = argv[narg = 1];
  488.     while ( narg < argc && arg[0] == '-' )
  489.     {
  490.         if (arg[0] == '-')
  491.         {
  492.             int num_opts = strlen(arg) ;
  493.             for(i = 1 ; i < num_opts ; i++ )
  494.             if(set_global_option(++arg))
  495.                 break;
  496.         }
  497.         arg = argv[++narg];
  498.     }
  499.     /* if no directories nor any files are given, exit */
  500.     if(num_dirs_to_visit == 0 && narg == argc)
  501.     {
  502.         fprintf(stderr,"no files given.\n");
  503.         exit(4);
  504.     }
  505.  
  506.     /* install signal handlers */
  507.     install_sig_handlers();
  508.  
  509.     /* open the output file */
  510.     if(!strcmp(outfile, "stdout"))
  511.         output_file = stdout;
  512.     else if((output_file = fopen(outfile, "w")) == NULL)
  513.     {
  514.         perror(outfile);
  515.         exit(6);
  516.     }
  517.  
  518.     /*
  519.     * always use this extension of none is given and directories are to be
  520.     * searched. 3 equals the size of .f\0
  521.     */
  522.     if(num_dirs_to_visit && !num_extensions)
  523.     {
  524.         checked_malloc(ext_table[num_extensions], 3, char);
  525. #ifdef __MSDOS__    /* msdos returns uppercase when building a filelist */
  526.         ext_table[num_extensions++] = ".F";
  527. #else
  528.         ext_table[num_extensions++] = ".f";
  529. #endif
  530.     }
  531.  
  532.     /* when directories have been given on the cmdline, build a filelist */
  533.     if(num_dirs_to_visit && verbose > 1)
  534.         printf("Scanning directories:\n");
  535.  
  536.     /* build a list of all files in the given directories (if any) */
  537.     for(i = 0 ; i < num_dirs_to_visit; i++)
  538.     {
  539.         if(verbose > 1)
  540.             printf("%s\n", dirs_to_visit[i]); 
  541.         build_file_list(&file_list, &num_files, dirs_to_visit[i],
  542.             ext_table, num_extensions); 
  543.     }
  544.     /* see if we have files left on the command line */
  545.     if(narg != argc)
  546.     {
  547.         for(i = narg ; i < argc ; i++)
  548.         {
  549.             checked_realloc(file_list, num_files+1, char*);
  550.             checked_malloc(file_list[num_files], strlen(argv[i])+1,
  551.                 char);
  552.             sprintf(file_list[num_files++], "%s", argv[i]);
  553.         }
  554.         if(verbose > 1 && argc-narg !=0)
  555.             printf("%i files given on command line.\n", argc - narg);
  556.     }
  557.  
  558.     /* show settings if we have to be a little bit verbose */
  559.     if(verbose > 1)
  560.         print_settings();
  561.  
  562.     if(verbose > 1)
  563.     {
  564.         printf("Total Files to scan: %i\n", num_files);
  565.         printf("File to write to: %s\n", outfile);
  566.     }
  567.     fflush(stdout);
  568.  
  569.     /* purge any non-matching output from yylex to /dev/null */
  570.     yyout = fopen(YYOUT_DEVICE, "w+");
  571.  
  572.     /* scan the file list */
  573.     for(i = 0; i < num_files; i++)
  574.     {
  575.         if ((num_ignore == 0 ? 1 : ignore_this_file(file_list[i])))
  576.         {
  577.             /* reset scanner for this file */
  578.             if((yyin = reset_scanner(file_list[i])) == NULL)
  579.                 continue;
  580.             yylineno = 0;
  581.             /* scan the file */
  582.             yylex();
  583.             /*
  584.             * flush the buffer of flex so we won't have
  585.             * any trailing stuff from the previous file
  586.             */
  587.             YY_FLUSH_BUFFER;
  588.             /* close input file */
  589.             fclose(yyin);
  590.             /* report some statistics if we have to */
  591.             if(verbose)
  592.                 print_file_stats(output_file, file_list[i], 
  593.                     yylineno);
  594.             total_routines += numroutine;
  595.             total_calls += numcall;
  596.             total_funcs += numfunc;
  597.         }
  598.     }
  599.     fclose(yyout);
  600.  
  601.     /* this is the final flowgraph data */
  602.     flow = global_flow.head;
  603.  
  604.     if(!quiet) 
  605.         printf("Sorting...\n"); 
  606.     fflush(stdout);
  607.  
  608.     /* Sort the flowgraph */
  609.     flow = sortAll(flow); 
  610.  
  611.     /* do argument check */
  612.     cross_check(output_file, flow);
  613.  
  614.     /* print subroutines that are never invoked */
  615.     if(never_invoked)
  616.         print_unused_routines(output_file, flow);
  617.  
  618.     if(verbose)
  619.     {
  620.         fprintf(output_file, "Checked %i files.\n", num_files);
  621.         fprintf(output_file, "Found %i subroutine definitions\n",
  622.             total_routines);
  623.         fprintf(output_file, "Found %i function definitions\n", 
  624.             total_funcs);
  625.         fprintf(output_file, "Found %i calls to subroutines\n", 
  626.             total_calls);
  627.         fprintf(output_file, "Checked %i calls in %i defined "
  628.             "subroutines in %i files.\n", 
  629.             total_calls, total_routines, num_files);
  630.     }
  631.  
  632.     /* report final results */
  633.     if(strcmp(outfile, "stdout") || !quiet)
  634.     {
  635.         if(num_diff)
  636.             fprintf(output_file, "Found %i argument mismatches.\n", 
  637.                 num_diff);
  638.         else
  639.             fprintf(output_file, "No argument mismatches found.\n");
  640.     }
  641.  
  642.     /* close output file */
  643.     if(strcmp(outfile, "stdout"))
  644.     {
  645.         fflush(output_file);
  646.         fclose(output_file);
  647.     }
  648.  
  649.     /* when wanted, print msdos memory usage summary */
  650.     print_dos_memory_usage();
  651.  
  652.     if(num_diff)
  653.         return(12);
  654.     else
  655.         return(0);
  656. }
  657.