home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / forut062.zip / ForUtil-0.62 / fflow / fflow.l < prev    next >
Text File  |  1996-08-28  |  16KB  |  652 lines
  1. %{
  2. #ifndef lint
  3. static char rcsId[]="$Source: /usr/local/rcs/ForUtil/fflow/RCS/fflow.l,v $";
  4. #endif
  5. /*****
  6. * fflow.l : lexical analyzer for Fortran Source files
  7. *
  8. * This file Version    $Revision: 1.9 $
  9. *
  10. * Creation date:    Mon Feb  5 02:26:23 GMT+0100 1996
  11. * Last modification:     $Date: 1996/08/28 17:45:21 $
  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: fflow.l,v $
  25. * Revision 1.9  1996/08/28 17:45:21  koen
  26. * Added print_version_id; added the -llevel option and appropriate changes.
  27. *
  28. * Revision 1.8  1996/08/27 19:16:01  koen
  29. * Heavy changes: updated scanner rules; optimized memory allocation routines; 
  30. * moved a number of routines to libflow.c
  31. *
  32. * Revision 1.7  1996/08/07 21:14:24  koen
  33. * Updated for MSDOS and added warning messages when -I, -E or -x is exceeded
  34. *
  35. * Revision 1.6  1996/08/02 14:50:29  koen
  36. * Added the -n and -n- options. Moved all system dependencies to lib/sysdeps.h
  37. *
  38. * Revision 1.5  1996/07/30 02:00:57  koen
  39. * Changed output stuff.
  40. * Added missing things to command line options.
  41. * Added version information.
  42. * Changed the ignore_this_file routine to use strstr.
  43. * Fixed a bug which left files open when a file was to be ignored.
  44. *
  45. * Revision 1.4  1996/07/16 09:05:44  koen
  46. * cmd_line related bug fixed.
  47. * Changed all fprintf(stderr,...) to printf(...) where output on stdout is
  48. * expected
  49. *
  50. * Revision 1.3  1996/05/06 00:34:40  koen
  51. * Adapted for MSDOS.
  52. *
  53. * Revision 1.2  1996/02/05 01:45:29  koen
  54. * Added the inline define for systems without __inline__ (noticably HP-UX).
  55. *
  56. * Revision 1.1  1996/02/05 01:28:07  koen
  57. * Initial revision
  58. *
  59. *****/ 
  60. #ifdef HAVE_CONFIG_H
  61. #include "autoconf.h"
  62. #endif
  63.  
  64. #include <stdio.h> 
  65. #include <string.h>
  66. #include <errno.h>
  67.  
  68. #include "forutil.h"
  69. #include "memmacros.h"
  70. #include "version.h"
  71. #include "libflow.h"
  72.  
  73. /**** Private Variables ****/
  74. static int skip_unknowns, ignore_empty_funcs;
  75. static int start_at_program, ignore_unused_funcs, start_at_named_function;
  76. static int complete_graph, never_invoked, no_graph; 
  77. static int output_line, verbose, cutoff_depth;
  78. static char *sep_char, *base_function_name, *outfile;
  79. static char cmd_line[MAXPATHLEN];
  80. static FILE *output_file;
  81.  
  82. static char *usage = {"Usage: %s [-cefhinpqtuv] [-Eext] [-Idir] [-ddepth] [-ofile] [-llevel] [-sname] [-xname] [files]\n\n"
  83. " Generates a (partial) flowgraph of a collection of fortran files\n\n"
  84. " Options\n"
  85. "\t-c: generate a complete flowgraph for each subroutine or function\n"
  86. "\t-e: ignore functions without calls\n"
  87. "\t-f: print precise location of filenames. Otherwise print name\n"
  88. "\t    of file only.\n"
  89. "\t-h, --help: print this help\n"
  90. "\t-i: ignore unknown function calls\n"
  91. "\t-n: tell what subroutines are never invoked. Use -n- to only check for\n"
  92. "\t    this and you do not want a flowgraph\n"
  93. "\t-p: start flowgraph at PROGRAM definition\n"
  94. "\t-q: be really quiet (usefull if called from a script)\n"
  95. "\t-t: use tabs instead of | as depth indicator\n"
  96. "\t-u: ignore unused subroutines\n"
  97. "\t-v: be verbose\n"
  98. "\t--version: display version number\n"
  99. "\t-Eext: extensions to use for retrieving files. Multiple -E allowed.\n"
  100. "\t-Idir: get files from directory dir. Multiple -I allowed\n"
  101. "\t-ddepth: maximum recursion depth, default is %i\n"
  102. "\t-llevel: Generate a flowgraph up to level deep\n"
  103. "\t-ofile: file to write flowgraph to, default is stdout\n"
  104. "\t-sname: use <name> as the topmost function\n"
  105. "\t-xname.f: exclude file. Multiple -x allowed\n\n"
  106. " Currently, fflow only looks at CALL, so although FUNCTION is found, these \n"
  107. " do not show up in the flowgraph\n\n"
  108. "(C)Copyright 1995-1996 by Ripley Software Development\n"};
  109.  
  110. /**** Private Function prototypes ****/
  111. static void print_flow_graph(FILE *file, flowInfo *list);
  112. static void print_flow_calls(FILE *file, flowInfo *calls, int depth);
  113. static int set_global_option(char *arg);
  114.  
  115. %}
  116.  
  117. routine  ^([ \t]{6,})subroutine[ \t]
  118. program  ^([ \t]{6,})program[ \t]
  119. function ^([ \t]{6,})[ [:alpha:]\*[:digit:]]*function[ \t]
  120. call     [^('][ \t]{1,}call[ ]*
  121. name [^\(\)'\n ]*[a-z0-9_]+
  122. nl \n
  123.  
  124. %option caseless yylineno
  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}?    {
  153.         /*
  154.         * Depending on the action taken,
  155.         * add a new function to the flowgraph list or
  156.         * add an entry for a call made in the current 
  157.         * function
  158.         */
  159.             if(action == ADDFUNC)
  160.                 add_new_func(yytext, yylineno, curr_path, 
  161.                     curr_file, 0);
  162.             else
  163.                 add_new_call(yytext, yylineno, 0);
  164.             BEGIN 0;
  165.         }
  166. {nl}        BEGIN 0;
  167. .         ; /* do nothing  for all other remaining chars */ 
  168. %%
  169.  
  170. /*****
  171. * Print the flowgraph to the given file. We follow up to depth levels
  172. * deep. If this depth is reached, recursion might be happening. If this
  173. * is the case, the program aborts with an appropriate message. The
  174. * default value for depth is MAXDEPTH, defined to 64. 
  175. * 
  176. * This routine is recursive.
  177. *****/
  178. static void 
  179. print_flow_calls(FILE *file, flowInfo *calls, int depth)
  180. {
  181.     flowInfo *tmp;
  182.     int i;
  183.  
  184.     /* return if we are cutoff_depth levels deep in the calltree */
  185.     if(cutoff_depth && depth >= cutoff_depth)
  186.         return;
  187.  
  188.     if(depth >= maxdepth) 
  189.     {
  190.         fprintf(stderr,"ERROR: I'm %i levels deep. This might indicate "
  191.             "undetected recursion.\n", depth);
  192.         if(calls->name) 
  193.             fprintf(stderr, "Current function is %s in file %s%s\n",
  194.                 calls->name, calls->path, calls->file);  
  195.         fprintf(stderr,"If this is no recursion, increase maxdepth by "
  196.                 "using -d\n"); 
  197.         exit(9);
  198.     } 
  199.     for(tmp = calls; tmp != NULL; tmp = tmp->next)
  200.     {
  201.         if(tmp->parent || (skip_unknowns == 0 && tmp->Type != KNOWN)) 
  202.         {
  203.             fprintf(file,"%-5i",depth+1);
  204.             for(i = 0 ; i < depth; i++)
  205.                 fprintf(file," %s", sep_char);
  206.             fprintf(file," %s -> %s, line %i ", sep_char, tmp->name,
  207.                 tmp->defline);
  208.             if(tmp->parent)
  209.             {
  210.                 if(complete_graph || 
  211.                     tmp->parent->output_line == 0) 
  212.                 {
  213.                     if(full_names)
  214.                         fprintf(file,"(%s", 
  215.                             tmp->parent->path);
  216.                     else
  217.                         fprintf(file, "(");
  218.                     fprintf(file, "%s, line %i)\n",
  219.                         tmp->parent->file, 
  220.                         tmp->parent->defline);
  221.                     if(errno)
  222.                     {
  223.                         fprintf(stderr, "Write failed:"
  224.                             " %s\n", ErrorString());
  225.                         exit(6);
  226.                     }
  227.                     tmp->output_line = ++output_line;
  228.                     if(!tmp->parent->recursive && 
  229.                         tmp->parent->calls)
  230.                         print_flow_calls(file, 
  231.                             tmp->parent->calls, 
  232.                             depth+1);
  233.                 } 
  234.                 else if(!complete_graph)
  235.                 {
  236.                     fprintf(file, "==>> line %i <<==\n", 
  237.                         tmp->parent->output_line);
  238.                     output_line++;
  239.                 }
  240.             } 
  241.             else 
  242.             {
  243.                 fprintf(file, "(<unknown>)\n");
  244.                 tmp->output_line = ++output_line;
  245.             }
  246.         }
  247.     }
  248. }
  249.  
  250. /*****
  251. * Main flow graph printing routine
  252. *****/
  253. static void 
  254. print_flow_graph(FILE *file, flowInfo *list)
  255. {
  256.     flowInfo *tmp, *start;
  257.  
  258.     if(start_at_program)
  259.     {
  260.         for(tmp=list; tmp!=NULL && tmp->Type!=PROGRAM; tmp=tmp->next);
  261.         if(tmp == NULL)
  262.         {
  263.             fprintf(stderr,"\nCould not find PROGRAM anywhere, "
  264.                 "I'm stymied\n");
  265.             exit(10);
  266.         }
  267.         start = tmp;
  268.     }    
  269.     else
  270.         if(start_at_named_function) 
  271.         { 
  272.             for(tmp = list; tmp != NULL && 
  273.                 strcasecmp(base_function_name, tmp->name); 
  274.                 tmp = tmp->next);
  275.             if(tmp == NULL)
  276.             {
  277.                 fprintf(stderr,"\nCould not find function or "
  278.                     "subroutine %s anywhere, "
  279.                     "I'm stymied\n", base_function_name);
  280.                 exit(11);
  281.             }
  282.             start = tmp;
  283.         } 
  284.         else
  285.             start = list;
  286.  
  287.     if(!quiet) 
  288.         printf("Writing to %s...\n", outfile); 
  289.     fflush(stdout);
  290.     fprintf(file, "%%\n%% Fortran flowgraph generated by fflow\n");
  291.     fprintf(file, "%% args used: %s\n%%\n", cmd_line); 
  292.     output_line = 5;
  293.  
  294.     if(start_at_named_function) 
  295.     {
  296.         fprintf(file, "\n%%\n%% Generated for %s\n%%\n", 
  297.             base_function_name); 
  298.         output_line += 4;
  299.     }
  300.     /* neat loop termination trick */
  301.     for(tmp = start; tmp != NULL; 
  302.         tmp=(ignore_unused_funcs ? NULL : tmp->next))
  303.     {
  304.         if(verbose)
  305.             printf("Generating flowgraph for: %s\n", tmp->name);
  306.         if(tmp->calls || !ignore_empty_funcs)
  307.         {
  308.             tmp->output_line = output_line++;
  309.             switch(tmp->Type)
  310.             {
  311.                 case PROGRAM:
  312.                     fprintf(file,"program");
  313.                     break;
  314.                 case FUNCTION:
  315.                     fprintf(file,"function");
  316.                     break;
  317.                 case SUBROUTINE:
  318.                     fprintf(file,"subroutine");
  319.                     break;
  320.                 default:    /* should not be reached */
  321.                     fprintf(file,"(unknown type)");
  322.             }
  323.             if(full_names)
  324.                 fprintf(file," %s (%s",tmp->name,tmp->path);
  325.             else
  326.                 fprintf(file," %s (", tmp->name);
  327.             fprintf(file,"%s, line %i)\n\n",tmp->file,tmp->defline);
  328.             output_line++;
  329.             print_flow_calls(file, tmp->calls, 0);
  330.             fprintf(file,"\n"); 
  331.             output_line++;
  332.             if(verbose)
  333.                 fflush(stdout);
  334.         }
  335.     }
  336. }
  337.  
  338. /*****
  339. * Scan command line options
  340. *****/
  341. static int 
  342. set_global_option(char *arg)
  343. { 
  344.     switch(arg[0])
  345.     {
  346.         case 'c' :    /* generate a complete flowgraph */
  347.             complete_graph = 1;
  348.             break;
  349.         case 'e' :    /* ignore empty functions */
  350.             ignore_empty_funcs = 1;
  351.             break;
  352.         case 'f' :    /* use full names instead of filename only.*/
  353.             full_names = 1 ;
  354.             break;
  355.         case 'h' :    /* help requested */
  356.             printf(usage, progname, MAXDEPTH); 
  357.             exit(2); 
  358.         case 'i' :    /* don't print unresolved references */
  359.             skip_unknowns = 1;
  360.             break;
  361.         case 'n' :    /* tell what subroutines are never invoked */
  362.             never_invoked = 1;
  363.             /* -n- will not generate a flowgraph */
  364.             if(arg[1] != '\0' && arg[1] == '-')
  365.             {
  366.                 no_graph = 1;
  367.                 return(1);
  368.             }
  369.             break;
  370. #ifdef __MSDOS__
  371.         case 'm' :    /* show memory usage under msdos */
  372.             need_mem_info_for_msdos = 1;
  373.             break;
  374. #endif
  375.         case 'p' :    /* start the flowgraph at PROGRAM */
  376.             start_at_program = 1;
  377.             break;
  378.         case 'q' :     /* be really quiet */
  379.             quiet = 1; 
  380.             verbose = 0; 
  381.         case 't' :    /* use a tabs instead of | */
  382.             sep_char = "\t";
  383.             break;
  384.         case 'u' :    /* ignore unreferenced functions */
  385.             ignore_unused_funcs = 1;
  386.             break;
  387.         case 'v' :     /* be verbose */
  388.             verbose = 1; 
  389.             break; 
  390.         case 'E' :    /* an extension specification */
  391.             SCAN_ARG("-E");
  392.             if(num_extensions == MAXEXTS)
  393.             {
  394.                 fprintf(stderr, "Capacity exceeded, more than "
  395.                     "%i extensions given on command line\n",
  396.                     MAXEXTS);
  397.                 fprintf(stderr,"Ignoring extension %s\n",arg+1);
  398.             }
  399.             else
  400.             {
  401.                 checked_malloc(ext_table[num_extensions], 
  402.                     strlen(arg+1)+1, char);
  403.                 strcpy(ext_table[num_extensions++], arg+1);
  404. #ifdef __MSDOS__    /* dos returns uppercase when building a filelist */
  405.                 upcase(ext_table[num_extensions-1]);
  406. #endif
  407.             }
  408.             return(1);
  409.         case 'I' :    /* a directory specification */
  410.             SCAN_ARG("-I");
  411.             if(num_dirs_to_visit == MAXDIRS)
  412.             {
  413.                 fprintf(stderr,"Capacity exceeded, more than %i"
  414.                     " directories given on command line\n",
  415.                     MAXDIRS);
  416.                 fprintf(stderr,"Ignoring directory %s\n",arg+1);
  417.             }
  418.             else
  419.             {
  420.                 checked_malloc(dirs_to_visit[num_dirs_to_visit],
  421.                     strlen(arg+1)+1, char);
  422.                 strcpy(dirs_to_visit[num_dirs_to_visit++], 
  423.                     arg+1); 
  424.             }
  425.             return(1);
  426.         case 'd' : /* max. recursion depth */
  427.             SCAN_ARG("-d");
  428.             maxdepth = atoi(arg + 1);
  429.             return(1);
  430.         case 'l' : /* max. recursion depth */
  431.             SCAN_ARG("-l");
  432.             cutoff_depth = atoi(arg + 1);
  433.             return(1);
  434.         case 'o' :    /* name of the output file */
  435.             SCAN_ARG("-o");
  436.             outfile = arg + 1;
  437.             return(1);
  438.         case 's' :    /* start flowgraph at the given function name */
  439.             start_at_named_function = 1;
  440.             SCAN_ARG("-s");
  441.             base_function_name = arg + 1;
  442.             return(1); 
  443.         case 'x' :    /* ignore the given file */
  444.             SCAN_ARG("-x");
  445.             if(num_ignore == MAXIGNORE)
  446.             {
  447.                 fprintf(stderr, "Capacity exceeded, more than "
  448.                     "%i ignores given on command line\n",
  449.                     MAXIGNORE);
  450.                 fprintf(stderr, "Ignoring option -x%s\n",arg+1);
  451.             }
  452.             else
  453.             {
  454.                 checked_malloc(ignore_list[num_ignore], 
  455.                     strlen(arg+1)+1, char);
  456.                 strcpy(ignore_list[num_ignore++], arg+1);
  457. #ifdef __MSDOS__    /* dos returns uppercase when building a filelist */
  458.                 upcase(ignore_list[num_ignore-1]);
  459. #endif
  460.             }
  461.             return(1);
  462.         case '-' :    /* secondary options */
  463.             if(!strcmp("help", arg+1))    /* help wanted */
  464.             {
  465.                 printf(usage, progname, MAXDEPTH); 
  466.                 exit(2); 
  467.             }
  468.             if(!strcmp("version", arg+1))    /* show version id */
  469.             {
  470.                 print_version_id(progname, VERSION, "$Revision: 1.9 $");
  471.                 exit(2);
  472.             }        /* fall through */
  473.         default:
  474.             fprintf(stderr,"unknown option -%s\n", arg);
  475.             exit(3);
  476.     }
  477.     return(0); 
  478. }
  479.  
  480. /*****
  481. * main for fflow
  482. *****/
  483. int 
  484. main(int argc, char **argv)
  485. { 
  486.     int i, narg; 
  487.     char *arg; 
  488.  
  489.     /* set global default values */
  490.     initialise(argv[0]);
  491.  
  492.     if(argc == 1)
  493.     {
  494.         fprintf(stderr, "%s: no files given\n",progname);
  495.         printf(usage, progname, MAXDEPTH); 
  496.         exit(4);
  497.     }
  498.  
  499.     /* Default values */
  500.     outfile = "stdout"; 
  501.     sep_char = "|"; 
  502.     maxdepth = MAXDEPTH; 
  503.     cutoff_depth = 0;
  504.  
  505.     /* scan for any command line options and save a copy of it */
  506.     arg = argv[narg = 1];
  507.     while ( narg < argc && arg[0] == '-' )
  508.     {
  509.         if (arg[0] == '-')
  510.         { 
  511.             int num_opts = strlen(arg) ; 
  512.             for(i = 1 ; i < num_opts ; i++ )
  513.             if(set_global_option(++arg)) 
  514.                 break;
  515.         } 
  516.         strcat(cmd_line, argv[narg]);
  517.         strcat(cmd_line, " ");
  518.         arg = argv[++narg];
  519.     }
  520.  
  521.     /* if no directories or files are given, exit */
  522.     if(num_dirs_to_visit == 0 && narg == argc) 
  523.     { 
  524.         fprintf(stderr,"no files given.\n"); 
  525.         exit(4); 
  526.     } 
  527.  
  528.     /* install signal handlers */
  529.     install_sig_handlers();
  530.  
  531.     /* open the output file */
  532.     if(!strcmp(outfile, "stdout"))
  533.         output_file = stdout;
  534.     else if((output_file = fopen(outfile, "w")) == NULL)
  535.     {
  536.         perror(outfile);
  537.         exit(6);
  538.     }
  539.  
  540.     /*
  541.     * always use this extension of none is given and directories are to be
  542.     * searched. 3 equals the size of .f\0 
  543.     */
  544.     if(num_dirs_to_visit && !num_extensions)
  545.     {
  546.         checked_malloc(ext_table[num_extensions], 3, char);
  547. #ifdef __MSDOS__    /* msdos returns uppercase when building a filelist */
  548.         ext_table[num_extensions++] = ".F";
  549. #else
  550.         ext_table[num_extensions++] = ".f";
  551. #endif
  552.     }
  553.  
  554.     /* when directories have been given on the cmdline, build a filelist */
  555.     if(num_dirs_to_visit && verbose)
  556.         printf("Scanning directories:\n");
  557.  
  558.     for(i = 0 ; i < num_dirs_to_visit; i++)
  559.     {
  560.         if(verbose)
  561.             printf("%s\n", dirs_to_visit[i]); 
  562.         build_file_list(&file_list, &num_files, dirs_to_visit[i],
  563.             ext_table, num_extensions); 
  564.     }
  565.  
  566.     /* see if we have files left on the command line */
  567.     if(narg != argc)
  568.     {
  569.         for(i = narg ; i < argc ; i++)
  570.         {
  571.             checked_realloc(file_list, num_files+1, char*);
  572.             checked_malloc(file_list[num_files], strlen(argv[i])+1,
  573.                 char);
  574.             sprintf(file_list[num_files++], "%s", argv[i]); 
  575.         }
  576.         if(verbose && argc-narg !=0)
  577.             printf("%i files given on command line.\n", argc - narg); 
  578.     }
  579.  
  580.     /* show settings if we have to be verbose */
  581.     if(verbose)
  582.         print_settings();
  583.  
  584.     if(!quiet)
  585.     {
  586.         printf("Total Files to scan: %i\n", num_files); 
  587.         printf("File to write to: %s\n", outfile);
  588.     }
  589.     fflush(stdout);
  590.  
  591.     /* purge any non-matching output from yylex to /dev/null */
  592.     yyout = fopen(YYOUT_DEVICE, "w+");
  593.  
  594.     /* scan the file list */
  595.     for(i = 0; i < num_files; i++)
  596.     {
  597.         if ((num_ignore == 0 ? 1 : ignore_this_file(file_list[i]))) 
  598.         {
  599.             /* reset scanner for this file */
  600.             if((yyin = reset_scanner(file_list[i])) == NULL)
  601.                 continue;
  602.             yylineno = 0;
  603.             /* scan the file */
  604.             yylex();
  605.             /* 
  606.             * flush the buffer of flex so we won't have 
  607.             * any trailing stuff from the previous file 
  608.             */
  609.             YY_FLUSH_BUFFER; 
  610.             /* close input file */
  611.             fclose(yyin);
  612.             /* report some statistics if we have to */
  613.             if(verbose) 
  614.                 print_file_stats(output_file, file_list[i], 
  615.                 yylineno);
  616.         }
  617.     }
  618.     fclose(yyout);
  619.  
  620.     /* this is the final flowgraph data */
  621.     flow = global_flow.head;
  622.  
  623.     if(!quiet) 
  624.         printf("Sorting...\n"); 
  625.     fflush(stdout);
  626.  
  627.     /* Sort the flowgraph */
  628.     flow = sortAll(flow); 
  629.  
  630.     /* print the flow graph if thus wanted */
  631.     if(no_graph == 0)
  632.         print_flow_graph(output_file, flow);
  633.  
  634.     /* print subroutines that are never invoked */
  635.     if(never_invoked)
  636.         print_unused_routines(output_file, flow);
  637.  
  638.     /* close the output file */
  639.     if(!strcmp(outfile, "stdout"))
  640.     {
  641.         fflush(output_file);
  642.         fclose(output_file); 
  643.     }
  644.     if(!quiet)
  645.         printf("Done, total files scanned: %i\n", i);
  646.  
  647.     /* when wanted, print msdos memory usage summary */
  648.     print_dos_memory_usage();
  649.  
  650.     return(0);
  651. }
  652.