home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 1999 mARCH / PCWK3A99.iso / Linux / DDD331 / DDD-3_1_.000 / DDD-3_1_ / ddd-3.1.1 / ddd / VSEFlags.C < prev    next >
C/C++ Source or Header  |  1998-11-23  |  18KB  |  662 lines
  1. // $Id: VSEFlags.C,v 1.19 1998/11/23 17:43:37 zeller Exp $
  2. // Global flags for VSL evaluation (and the old VSE editor)
  3.  
  4. // Copyright (C) 1995 Technische Universitaet Braunschweig, Germany.
  5. // Written by Andreas Zeller <zeller@ips.cs.tu-bs.de>.
  6. // 
  7. // This file is part of DDD.
  8. // 
  9. // DDD is free software; you can redistribute it and/or
  10. // modify it under the terms of the GNU General Public
  11. // License as published by the Free Software Foundation; either
  12. // version 2 of the License, or (at your option) any later version.
  13. // 
  14. // DDD is distributed in the hope that it will be useful,
  15. // but WITHOUT ANY WARRANTY; without even the implied warranty of
  16. // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  17. // See the GNU General Public License for more details.
  18. // 
  19. // You should have received a copy of the GNU General Public
  20. // License along with DDD -- see the file COPYING.
  21. // If not, write to the Free Software Foundation, Inc.,
  22. // 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  23. // 
  24. // DDD is the data display debugger.
  25. // For details, see the DDD World-Wide-Web page, 
  26. // `http://www.cs.tu-bs.de/softech/ddd/',
  27. // or send a mail to the DDD developers <ddd@ips.cs.tu-bs.de>.
  28.  
  29. char VSEFlags_rcsid[] = 
  30.     "$Id: VSEFlags.C,v 1.19 1998/11/23 17:43:37 zeller Exp $";
  31.  
  32. #include <stdlib.h>
  33. #include <stdio.h>
  34. #include <string.h>
  35. #include <strstream.h>
  36. #include <ctype.h>
  37. #include <X11/Intrinsic.h>
  38.  
  39. #include "assert.h"
  40. #include "strclass.h"
  41. #include "VSEFlags.h"
  42. #include "VSLLib.h"
  43. #include "config.h"
  44. #include "home.h"
  45.  
  46. #ifndef VSL_INCLUDE_PATH
  47. #define VSL_INCLUDE_PATH "/usr/local/lib/vsl-include"
  48. #endif
  49.  
  50. #ifndef EXIT_SUCCESS
  51. #define EXIT_SUCCESS 0
  52. #endif
  53.  
  54. #ifndef EXIT_FAILURE
  55. #define EXIT_FAILURE 1
  56. #endif
  57.  
  58.  
  59. // Defaults
  60.  
  61. // help
  62. static bool help                         = false;
  63.  
  64. // internal optimize options (only to be set)
  65. bool VSEFlags::optimize_resolveDefs      = true;
  66. bool VSEFlags::optimize_resolveSynonyms  = true;
  67. bool VSEFlags::optimize_foldOps          = true;
  68. bool VSEFlags::optimize_foldConsts       = true;
  69. bool VSEFlags::optimize_inlineFuncs      = true;
  70. bool VSEFlags::optimize_cleanup          = true;
  71. int VSEFlags::max_optimize_loops         = 2;
  72.  
  73. // external optimize options
  74. bool VSEFlags::incremental_eval          = true;
  75. bool VSEFlags::optimize_globals          = true;
  76.  
  77. // assertion options
  78. bool VSEFlags::assert_library_ok         = false;
  79. bool VSEFlags::assert_document_ok        = false;
  80.  
  81. // dump to file options
  82. bool VSEFlags::dump_tree                 = false;
  83. bool VSEFlags::dump_library              = false;
  84. bool VSEFlags::dump_picture              = false;
  85. bool VSEFlags::dump_document             = false;
  86. bool VSEFlags::dump_while_optimizing     = false;
  87. bool VSEFlags::dump_last                 = false;
  88.  
  89. // show options
  90. bool VSEFlags::show_optimize             = false;
  91. bool VSEFlags::show_match_nodes          = false;
  92. bool VSEFlags::show_match_boxes          = false;
  93. bool VSEFlags::show_match_defs           = false;
  94. bool VSEFlags::show_tiny_eval            = false;
  95. bool VSEFlags::show_large_eval           = false;
  96. bool VSEFlags::show_huge_eval            = false;
  97. bool VSEFlags::show_balance              = false;
  98. bool VSEFlags::show_flags                = false;
  99. bool VSEFlags::show_backtrace            = true;
  100. bool VSEFlags::show_ids                  = false;
  101. bool VSEFlags::show_vars                 = false;
  102. bool VSEFlags::show_draw                 = false;
  103.  
  104. // info options
  105. bool VSEFlags::include_list_info         = false;
  106. bool VSEFlags::include_size_info         = false;
  107. bool VSEFlags::include_font_info         = false;
  108. bool VSEFlags::include_const_info        = true;
  109. bool VSEFlags::include_tag_info          = false;
  110. bool VSEFlags::include_id_info           = false;
  111. bool VSEFlags::include_select_info       = false;
  112.  
  113. // time options
  114. bool VSEFlags::show_eval_time            = false;
  115. bool VSEFlags::show_optimizing_time      = false;
  116. bool VSEFlags::show_display_time         = false;
  117.  
  118. // eval options
  119. bool VSEFlags::suppress_eval             = false;
  120. bool VSEFlags::issue_nooptionals         = false;
  121.  
  122. // arguments
  123. char *VSEFlags::library_file             = "";
  124. char *VSEFlags::document_file            = "";
  125. char *VSEFlags::startup_file             = "";
  126.  
  127. // mode options
  128. bool VSEFlags::bag_mode                  = false;
  129. bool VSEFlags::concurrent_mode           = false;
  130. bool VSEFlags::verbose                   = false;
  131. bool VSEFlags::what                      = false;
  132. bool VSEFlags::load_open_mode            = true;
  133.  
  134. // other settings
  135. int VSEFlags::max_eval_nesting           = 500;
  136. int VSEFlags::max_info_nesting           = -1;
  137. int VSEFlags::max_pattern_variables      = 256;
  138. int VSEFlags::loops                      = 1;
  139. char *VSEFlags::include_search_path      = "";
  140.  
  141.  
  142. // Table options <-> names
  143. VSEOptionTableEntry VSEFlags::optionTable[] = {
  144.  
  145. // Help options
  146. { TITLE,    "",                     "Help",
  147.     0 },
  148. { BOOLEAN,  "help",                 "Show VSL options",
  149.     &help },
  150. { BOOLEAN,  "?",                    "Show VSL options",
  151.     &help },
  152.  
  153. // Settings
  154. { TITLE,    "",                     "Settings",
  155.     0 },
  156. { BOOLEAN,  "verbose",              "Enter verbose mode",
  157.     &verbose },
  158. { BOOLEAN,  "bag",                  "Enter bag mode",
  159.     &bag_mode },
  160. { BOOLEAN,  "open",                 "Open documents when loaded",
  161.     &load_open_mode },
  162. { BOOLEAN,  "concurrent",           "Allow concurrent editing",
  163.     &concurrent_mode },
  164. { BOOLEAN,  "what",                 "Display source file versions",
  165.     &what },
  166. { STRING,   "library",              "Load vsl library",
  167.     &library_file },
  168. { STRING,   "document",             "Load document",
  169.     &document_file },
  170. { STRING,   "startup",              "Load startup file",
  171.     &startup_file },
  172. { STRING,   "I",                    "Set #include search path",
  173.     &include_search_path },
  174. { STRING,   "include",              "Set #include search path",
  175.     &include_search_path },
  176.  
  177. // Optimize options
  178. { TITLE,    "",                     "Optimizing",
  179.     0 },
  180. { BOOLEAN,  "optimize-inline-functions",    "Perform inlineFuncs optimization",
  181.     &optimize_inlineFuncs },
  182. { BOOLEAN,  "optimize-fold-ops",            "Perform foldOps optimization",
  183.     &optimize_foldOps },
  184. { BOOLEAN,  "optimize-fold-consts",         "Perform foldConsts optimization",
  185.     &optimize_foldConsts },
  186. { BOOLEAN,  "optimize-resolve-defs",        "Perform resolveDefs optimization",
  187.     &optimize_resolveDefs },
  188. { BOOLEAN,  "optimize-resolve-synonyms",    "Perform resolveSynonyms optimization",
  189.     &optimize_resolveSynonyms },
  190. { BOOLEAN,  "optimize-cleanup",             "Perform cleanup between optimization stages",
  191.     &optimize_cleanup },
  192. { BOOLEAN,  "optimize-incremental-eval",    "Perform incremental evaluation",
  193.     &incremental_eval },
  194. { BOOLEAN,  "optimize-",                    "Perform all optimizations",
  195.     0 },
  196. { INT,      "max-optimize-loops",           "Set maximum #optimize loops",
  197.     &max_optimize_loops },
  198.  
  199. // Debugging Options
  200. { TITLE,    "",                     "Debugging",
  201.     0 },
  202. { BOOLEAN,  "debug-assert-document-ok",  "Assert document::OK()",
  203.     &assert_document_ok },
  204. { BOOLEAN,  "debug-assert-library-ok",   "Assert library::OK()",
  205.     &assert_library_ok },
  206. { BOOLEAN,  "debug-show-tree",           "Show library tree",
  207.     &dump_tree },
  208. { BOOLEAN,  "debug-show-library",        "Show library (in VSL)",
  209.     &dump_library },
  210. { BOOLEAN,  "debug-show-last",           "Show only last library def",
  211.     &dump_last },
  212. { BOOLEAN,  "debug-show-document",       "Show document (in VSL)",
  213.     &dump_document },
  214. { BOOLEAN,  "debug-show-picture",        "Show picture (in VSL)",
  215.     &dump_picture },
  216. { BOOLEAN,  "debug-const-info",          "Include const info",
  217.     &include_const_info },
  218. { BOOLEAN,  "debug-list-info",           "Include list info",
  219.     &include_list_info },
  220. { BOOLEAN,  "debug-box-fonts-info",      "Include box font info",
  221.     &include_font_info },
  222. { BOOLEAN,  "debug-box-id-info",         "Include box id info",
  223.     &include_id_info },
  224. { BOOLEAN,  "debug-box-tag-info",        "Include box tag info",
  225.     &include_tag_info },
  226. { BOOLEAN,  "debug-box-size-info",       "Include box size info",
  227.     &include_size_info },
  228. { BOOLEAN,  "debug-doc-select-info",     "Include document select state info",
  229.     &include_select_info },
  230. { BOOLEAN,  "debug-show-balance",        "Show balance",
  231.     &show_balance },
  232. { BOOLEAN,  "debug-show-eval-huge",      "Show huge evaluation (documents)",
  233.     &show_huge_eval },
  234. { BOOLEAN,  "debug-show-eval-large",     "Show large evaluation (defs)",
  235.     &show_large_eval },
  236. { BOOLEAN,  "debug-show-eval-tiny",      "Show tiny evaluation (nodes)",
  237.     &show_tiny_eval },
  238. { BOOLEAN,  "debug-show-backtrace",      "Show backtrace on errors",
  239.     &show_backtrace },
  240. { BOOLEAN,  "debug-show-ids",            "Show id creation and deletion",
  241.     &show_ids },
  242. { BOOLEAN,  "debug-show-vars",           "Show variable declaration and use",
  243.     &show_vars },
  244. { BOOLEAN,  "debug-show-draw",           "Show drawing",
  245.     &show_draw },
  246. { BOOLEAN,  "debug-show-flags",          "Show flag processing",
  247.     &show_flags },
  248. { BOOLEAN,  "debug-show-optimize",       "Show optimization",
  249.     &show_optimize },
  250. { BOOLEAN,  "debug-show-match-nodes",    "Show pattern matching (nodes)",
  251.     &show_match_nodes },
  252. { BOOLEAN,  "debug-show-match-boxes",    "Show pattern matching (boxes)",
  253.     &show_match_boxes },
  254. { BOOLEAN,  "debug-show-match-defs",     "Show pattern matching (defs)",
  255.     &show_match_defs },
  256. { BOOLEAN,  "debug-time-display",        "Show display time",
  257.     &show_display_time },
  258. { BOOLEAN,  "debug-time-evaluation",     "Show evaluation time",
  259.     &show_eval_time },
  260. { BOOLEAN,  "debug-time-optimizing",     "Show optimizing time",
  261.     &show_optimizing_time },
  262. { BOOLEAN,  "debug-optimize-globals",    "Perform foldConsts on global defs",
  263.     &optimize_globals },
  264. { BOOLEAN,  "debug-suppress-eval",       "Skip evaluation and picture",
  265.     &suppress_eval },
  266. { BOOLEAN,  "debug-issue-nooptionals",   "Generate code for nooptionals",
  267.     &issue_nooptionals },
  268.  
  269. // Sizes
  270. { TITLE,    "",                     "Sizes",
  271.     0 },
  272. { INT,      "eval-nesting",        "Set max eval nesting",
  273.     &max_eval_nesting },
  274. { INT,      "info-nesting",        "Set max info nesting",
  275.     &max_info_nesting },
  276. { INT,      "pattern-variables",   "Set max #variables in pattern",
  277.     &max_pattern_variables },
  278. { INT,      "eval-loops",          "Set #evaluation loops",
  279.     &loops },
  280.  
  281. // Last Option
  282. { LAST,     "",                     "",
  283.     0 }
  284. };
  285.  
  286. // Read options; show help and exit if required
  287. void VSEFlags::parse(int& argc, char**& argv, char *args)
  288. {
  289.     // Get default settings
  290.     getDefaults(true);
  291.  
  292.     // Parse arguments
  293.     if (_parse(argc, argv, false))
  294.     {
  295.     cerr << argv[0] << ": usage: " << argv[0] << " [options] "
  296.          << args << "\n\n" << explain();
  297.  
  298.     exit(EXIT_FAILURE);
  299.     }
  300. }
  301.  
  302. bool VSEFlags::parse_vsl(int& argc, char**& argv)
  303. {
  304.     // Get default settings
  305.     getDefaults(false);
  306.  
  307.     return _parse(argc, argv, true);
  308. }
  309.     
  310.  
  311. // Read options; return true if help is required
  312. bool VSEFlags::_parse(int& argc, char**& argv, bool vsl_prefix_required)
  313. {
  314.     int arg = 1;
  315.  
  316.     while (arg < argc)
  317.     {
  318.     int skip = 0;
  319.  
  320.     if (argv[arg] == 0)
  321.         break;                      // No more args
  322.  
  323.     if (argv[arg][0] != '-')
  324.         break;            // No option
  325.  
  326.     if (argv[arg][1] == '\0')
  327.         break;                // No option ("-")
  328.  
  329.     if (argv[arg][1] == '-' && argv[arg][2] == '\0')
  330.         break;                      // End of options ("--")
  331.  
  332.     string opt = argv[arg];         // Full option
  333.  
  334.     // Remove "no-" prefix
  335.     bool no = false;
  336.     if (opt.contains("no-"))
  337.     {
  338.         opt.del("no-");
  339.         no = true;
  340.     }
  341.  
  342.     // Build option name after leading `-'
  343.     string optName = opt;
  344.     while (optName[0] == '-')
  345.         optName = optName.after('-');
  346.  
  347.     // If `vsl-' prefix is required, ignore all other options
  348.     if (vsl_prefix_required)
  349.         if (optName.index("vsl") != 0)
  350.         break;
  351.  
  352.     // `vsl-' prefix is optional
  353.     if (optName.index("vsl-") == 0)
  354.         optName = optName.after("vsl-");
  355.  
  356.     for (int nentry = 0; optionTable[nentry].type != LAST; nentry++)
  357.     {
  358.         VSEOptionTableEntry entry = optionTable[nentry];
  359.         string entryName = entry.name;
  360.  
  361.         if (entryName.index(optName) == 0)
  362.         {   
  363.         // entryName starts with optName: process option
  364.  
  365.         switch (entry.type)
  366.         {
  367.             case TITLE:
  368.             break;
  369.  
  370.             case BOOLEAN:
  371.             {
  372.             bool *boolptr = (bool *)entry.flag;
  373.             if (boolptr)
  374.                 *boolptr = !no;
  375.             skip = 1;
  376.             break;
  377.             }
  378.  
  379.             case INT:
  380.             {
  381.             if (arg + 1 < argc)
  382.             {
  383.                 int *intptr = (int *)entry.flag;
  384.                 if (intptr)
  385.                 *intptr = atoi(argv[arg + 1]);
  386.                 skip = 2;
  387.             }
  388.             break;
  389.             }
  390.  
  391.             case STRING:
  392.             {
  393.             if (arg + 1 < argc)
  394.             {
  395.                 char **stringptr = (char **)entry.flag;
  396.                 if (stringptr)
  397.                 *stringptr = argv[arg + 1];
  398.                 skip = 2;
  399.             }
  400.             break;
  401.             }
  402.  
  403.             default:
  404.             // This can't happen
  405.             assert(2 + 2 == 5);
  406.             break;
  407.         }
  408.  
  409.         if (show_flags)
  410.         {
  411.             // Show processed option
  412.             cout << "processed flag: " << argv[arg] << " => -";
  413.  
  414.             if (no && entry.type == BOOLEAN)
  415.             {
  416.             if (entryName.contains("debug-"))
  417.                 cout << entryName.through("debug-") << "no-" 
  418.                  << entryName.after("debug-");
  419.             else if (entryName.contains("optimize-"))
  420.                 cout << entryName.through("optimize-") << "no-" 
  421.                  << entryName.after("optimize-");
  422.             else
  423.                 cout << "no-" << entryName;
  424.             }
  425.             else
  426.             cout << entryName;
  427.  
  428.             for (int i = 1; i < skip; i++)
  429.             cout << " " << argv[arg + i];
  430.             cout << "\n";
  431.         }
  432.         }
  433.     }
  434.  
  435.     if (skip > 0)
  436.     {
  437.         // Remove option from argument list
  438.         for (int a = arg; a < argc; a++)
  439.         argv[a] = argv[a + skip];
  440.         argc -= skip;
  441.     }
  442.     else
  443.     {
  444.         // Process next argument; keep this one
  445.         arg++;
  446.     }
  447.     }
  448.  
  449.     return help;
  450. }
  451.  
  452.  
  453. // Read default options from .vserc, ~/.vserc, /usr/lib/vse/vse-options
  454. void VSEFlags::getDefaults(bool warn)
  455. {
  456.  
  457.     string filename = ".vserc";
  458.     FILE *fp = fopen(filename, "r");
  459.     if (fp == NULL)
  460.     {
  461.     string home = gethome();
  462.     filename.prepend(home + "/");
  463.     fp = fopen(filename, "r");
  464.  
  465.     if (fp == NULL)
  466.     {
  467.         static string path = 
  468.         string(VSL_INCLUDE_PATH) +
  469.         ":/usr/local/vse"
  470.         ":/usr/vse"
  471.         ":/usr/local/lib/vse"
  472.         ":/usr/lib/vse"
  473.         ":/usr/local/lib"
  474.         ":/usr/lib";
  475.  
  476.         char buffer[BUFSIZ];
  477.         strcpy(buffer, path);
  478.  
  479.         for (char *p = strtok(buffer, ":"); 
  480.          p != NULL; 
  481.          p = strtok(NULL, ":"))
  482.         {
  483.         filename = string(p) + "/vserc";
  484.  
  485.         fp = fopen(filename, "r");
  486.         if (fp != NULL)
  487.             break;
  488.         }
  489.  
  490.         if (warn)
  491.         cerr << "Warning: could not find .vserc, ~/.vserc or vserc\n";
  492.         return;
  493.     }
  494.     }
  495.  
  496.     static char *argv[3];
  497.     static char buf1[BUFSIZ];
  498.     static char buf2[BUFSIZ];
  499.  
  500.     int nargs;
  501.     do {
  502.     nargs = fscanf(fp, "%s%*[ \t]%s%*[ \t]%*[\n]", buf1, buf2);
  503.  
  504.     if (nargs > 0 && buf1[0] == '-')
  505.     {
  506.         argv[0] = "dummy";
  507.         argv[1] = "";
  508.         argv[2] = "";
  509.         if (nargs >= 1)
  510.         {
  511.         argv[1] = (String)XtNewString(buf1);
  512.         if (nargs >= 2)
  513.             argv[2] = (String)XtNewString(buf2);
  514.         }
  515.         int myargc = nargs + 1;
  516.         char **myargv = argv;
  517.  
  518.         _parse(myargc, myargv, false);
  519.  
  520.         for (int i = 1; i < myargc; i++)
  521.         if (myargv[i][0] == '-')
  522.             cerr << filename << ": unknown option " << myargv[i] 
  523.              << "\n";
  524.     }
  525.     } while (nargs != EOF);
  526.  
  527.     if (fclose(fp) == EOF)
  528.     perror(filename);
  529.  
  530.     return;
  531. }
  532.  
  533.  
  534. // Explain options (and report default values)
  535. string VSEFlags::explain(bool vsl_prefix_required)
  536. {
  537.     help = false;   // Always report '-help' (we'd get `-no-help' otherwise)
  538.  
  539.     string s = "Options include:\n";
  540.     if (vsl_prefix_required)
  541.     s = "List of VSL options:\n";
  542.  
  543.     for (int nentry = 0; optionTable[nentry].type != LAST; nentry++)
  544.     {
  545.     VSEOptionTableEntry entry = optionTable[nentry];
  546.  
  547.     if (entry.type == TITLE)
  548.     {
  549.         s = s + "\n" + entry.usage + "\n";
  550.         continue;
  551.     }
  552.  
  553.     string optName = entry.name;
  554.     string optArg  = "";
  555.     string usage   = entry.usage;
  556.     string deflt   = "";
  557.  
  558.     if (vsl_prefix_required)
  559.         optName.prepend("vsl-");
  560.  
  561.     switch (entry.type) {
  562.         case BOOLEAN:
  563.         {
  564.         bool *boolptr = (bool *)entry.flag;
  565.         if (boolptr)
  566.         {
  567.             if (*boolptr)
  568.             {
  569.             if (optName.contains("debug-"))
  570.                 optName = optName.through("debug-") + "no-" 
  571.                  + optName.after("debug-");
  572.             else if (optName.contains("optimize-"))
  573.                 optName = optName.through("optimize-") + "no-" 
  574.                  + optName.after("optimize-");
  575.             else if (optName.contains("vsl-"))
  576.                 optName = optName.through("vsl-") + "no-" 
  577.                  + optName.after("vsl-");
  578.             else
  579.                 optName = "no-" + optName;
  580.  
  581.             usage[0] = tolower(usage[0]);
  582.             usage.prepend("Don't ");
  583.             }
  584.         }
  585.         break;
  586.         }
  587.  
  588.         case INT:
  589.         {
  590.         int *intptr = (int *)entry.flag;
  591.  
  592.         optArg = " [num]";
  593.         usage += " to 'num'";
  594.  
  595.         if (intptr)
  596.         {
  597.             ostrstream os;
  598.             os << " (default: " << *intptr << ")";
  599.             deflt = string(os);
  600.         }
  601.         break;
  602.         }
  603.  
  604.         case STRING:
  605.         {
  606.         char **stringptr = (char **)entry.flag;
  607.  
  608.         optArg = " [name]";
  609.         usage += " 'name'";
  610.  
  611.         if (stringptr)
  612.             deflt = string(" (default: '") + *stringptr + "')";
  613.         break;
  614.         }
  615.     
  616.         default:
  617.         // This can't happen.
  618.         assert(1 + 1 == 3);
  619.         break;
  620.     }
  621.  
  622.     optName = "--" + optName + optArg + ":";
  623.     while (optName.length() < 36)
  624.         optName += " ";
  625.     s += optName;
  626.     usage += deflt;
  627.     s += usage;
  628.     s += "\n";
  629.     }
  630.  
  631.     s += "\n";
  632.     s += (vsl_prefix_required ? "VSL options" : "Options");
  633.     s += " may be abbreviated, which causes all matching options"
  634.      " to be set.\n";
  635.  
  636.     return s;
  637. }
  638.  
  639.  
  640. // Return optimization mode
  641. unsigned VSEFlags::optimize_mode()
  642. {
  643.     unsigned mode = 0;
  644.     
  645.     if (optimize_resolveDefs)
  646.     mode |= ResolveDefs;
  647.     if (optimize_resolveSynonyms)
  648.     mode |= ResolveSynonyms;
  649.     if (optimize_foldOps)
  650.     mode |= FoldOps;
  651.     if (optimize_foldConsts)
  652.     mode |= FoldConsts;
  653.     if (optimize_inlineFuncs)
  654.     mode |= InlineFuncs;
  655.     if (optimize_cleanup)
  656.     mode |= Cleanup;
  657.  
  658.     mode |= max_optimize_loops;
  659.  
  660.     return mode;
  661. }
  662.