prop-src/metasyntax.cc

   1 ///////////////////////////////////////////////////////////////////////////////
   2 //  This file is generated automatically using Prop (version 2.3.6),
   3 //  last updated on Nov 2, 1999.
   4 //  The original source file is "metasyntax.pcc".
   5 ///////////////////////////////////////////////////////////////////////////////
   6
   7 #line 1 "metasyntax.pcc"
   8 ///////////////////////////////////////////////////////////////////////////////
   9 //
  10 //  This file implements the meta-syntax compiler.
  11 //
  12 ///////////////////////////////////////////////////////////////////////////////
  13 #include <iostream>
  14 #include "metasyntax.h"
  15 #include "ir.h"
  16 #include "ast.h"
  17 #include "hashtab.h"
  18 #include "options.h"
  19
  20 ///////////////////////////////////////////////////////////////////////////////
  21 //
  22 //  Implementation of the meta syntax compiler
  23 //
  24 ///////////////////////////////////////////////////////////////////////////////
  25 class MetaSyntaxCompilerImpl {
  26     MetaSyntaxCompilerImpl(const MetaSyntaxCompilerImpl&);
  27     void operator = (const MetaSyntaxCompilerImpl&);
  28 public:
  29
  30     size_t    memory_used;   // total memory used for the parsers and lexers
  31     HashTable grammar_map;   // mapping from name to grammar
  32     int       timer;         // use count timer
  33
  34     MetaSyntaxCompilerImpl()
  35        : memory_used(0),
  36          grammar_map(string_hash,string_equal)
  37          {}
  38 };
  39
  40 ///////////////////////////////////////////////////////////////////////////////
  41 //
  42 //  Definition of a grammar record
  43 //
  44 ///////////////////////////////////////////////////////////////////////////////
  45 struct GrammarRecord {
  46    Id      grammar_name;   // grammar name
  47    GramExp grammar_exp;    // grammar expression
  48    size_t  memory_used;    // memory used for this grammar
  49    int     last_used;      // time of last use
  50    int     use_count;      // number of uses
  51 };
  52
  53 ///////////////////////////////////////////////////////////////////////////////
  54 //
  55 //  Constructor and destructor
  56 //
  57 ///////////////////////////////////////////////////////////////////////////////
  58 MetaSyntaxCompiler:: MetaSyntaxCompiler()
  59    : impl(new MetaSyntaxCompilerImpl)
  60      {}
  61 MetaSyntaxCompiler::~MetaSyntaxCompiler()
  62      { delete impl; }
  63
  64 ///////////////////////////////////////////////////////////////////////////////
  65 //
  66 //  Method to compile a grammar give it an unique name.
  67 //  We'll invoke the parser generator subclass to create a new parser.
  68 //  Then the parser table is stored inside internal tables.
  69 //
  70 ///////////////////////////////////////////////////////////////////////////////
  71 void MetaSyntaxCompiler::install_grammar(Id grammar_name, GramExp grammar)
  72 {  gen_parser(grammar_name, grammar);
  73 }
  74
  75 ///////////////////////////////////////////////////////////////////////////////
  76 //
  77 //  Method to parse the text as an expression.
  78 //
  79 ///////////////////////////////////////////////////////////////////////////////
  80 Exp MetaSyntaxCompiler::parse_exp (Id           grammar_name,
  81                                    const char * text
  82                                   )
  83 {  error ("%Lunrecognized quoted expression `%s`\n",text);
  84    return NOexp;
  85 }
  86
  87 ///////////////////////////////////////////////////////////////////////////////
  88 //
  89 //  Method to parse the text as a pattern.
  90 //
  91 ///////////////////////////////////////////////////////////////////////////////
  92 Pat MetaSyntaxCompiler::parse_pat (Id           grammar_name,
  93                                    const char * text
  94                                   )
  95 {  error ("%Lunrecognized quoted pattern `%s`\n",text);
  96    return NOpat;
  97 }
  98
  99 ///////////////////////////////////////////////////////////////////////////////
 100 //
 101 //  Method to flush out a grammar when memory is low.
 102 //  This is invoked whenever a new grammar is to be compiled
 103 //  and the total memory used has reached a limit.   The least
 104 //  recently used grammars are flushed in this process.
 105 //
 106 ///////////////////////////////////////////////////////////////////////////////
 107 void MetaSyntaxCompiler::flush_grammar (size_t memory_needed)
 108 {  long memory_to_free = memory_needed;
 109    while (memory_to_free > 0 && impl->grammar_map.size() > 0)
 110    {  GrammarRecord * kill_candidate = 0; // the candidate to invalidate.
 111       HashTable& grammar_map = impl->grammar_map;
 112
 113       // Locate the least frequently used entry
 114       foreach_entry(e,grammar_map)
 115       {  if (kill_candidate == 0 ||
 116              ((GrammarRecord *)(e->v))->use_count < kill_candidate->use_count)
 117             kill_candidate = (GrammarRecord *)(e->v);
 118       }
 119       // Locate the oldest used entry
 120       foreach_entry(e,grammar_map)
 121       {  if (kill_candidate == 0 ||
 122              ((GrammarRecord *)(e->v))->last_used < kill_candidate->last_used)
 123             kill_candidate = (GrammarRecord *)(e->v);
 124       }
 125       // Kill entry and update the available memory
 126       if (kill_candidate)
 127       {  if (options.generate_report)
 128              open_logfile() << "[Invalidating meta-language '"
 129                             << kill_candidate->grammar_name << "']\n";
 130          impl->memory_used -= kill_candidate->memory_used;
 131          memory_to_free    -= kill_candidate->memory_used;
 132       }
 133    }
 134 }
 135
 136 ///////////////////////////////////////////////////////////////////////////////
 137 //
 138 //  Method to generate a report of all the grammars generated.
 139 //
 140 ///////////////////////////////////////////////////////////////////////////////
 141 std::ostream& MetaSyntaxCompiler::print_report(std::ostream& f)
 142 {
 143     return f;
 144 }
 145 #line 138 "metasyntax.pcc"
 146 /*
 147 ------------------------------- Statistics -------------------------------
 148 Merge matching rules         = yes
 149 Number of DFA nodes merged   = 0
 150 Number of ifs generated      = 0
 151 Number of switches generated = 0
 152 Number of labels             = 0
 153 Number of gotos              = 0
 154 Adaptive matching            = enabled
 155 Fast string matching         = disabled
 156 Inline downcasts             = enabled
 157 --------------------------------------------------------------------------
 158 */