home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 20 / AACD20.BIN / AACD / Programming / Jikes / Source / src / table.h < prev    next >
Encoding:
C/C++ Source or Header  |  2001-02-24  |  12.5 KB  |  447 lines
  1. // $Id: table.h,v 1.11 2001/01/05 09:13:21 mdejong Exp $
  2. //
  3. // This software is subject to the terms of the IBM Jikes Compiler
  4. // License Agreement available at the following URL:
  5. // http://www.ibm.com/research/jikes.
  6. // Copyright (C) 1996, 1998, International Business Machines Corporation
  7. // and others.  All Rights Reserved.
  8. // You must accept the terms of that agreement to use this software.
  9. //
  10. #ifndef table_INCLUDED
  11. #define table_INCLUDED
  12.  
  13. #include "platform.h"
  14. #include "symbol.h"
  15.  
  16. #ifdef    HAVE_JIKES_NAMESPACE
  17. namespace Jikes {    // Open namespace Jikes block
  18. #endif
  19.  
  20. class VariableShadowSymbol
  21. {
  22. public:
  23.     VariableSymbol *variable_symbol;
  24.  
  25.     VariableShadowSymbol(VariableSymbol *variable_symbol_) : variable_symbol(variable_symbol_),
  26.                                                              conflict(NULL)
  27.     {}
  28.  
  29.     ~VariableShadowSymbol()
  30.     {
  31.         delete conflict;
  32.     }
  33.  
  34.     VariableSymbol *Conflict(int i) { return (*conflict)[i]; }
  35.  
  36.     inline int NumConflicts()
  37.     {
  38.         return (conflict ? conflict -> Length() : 0);
  39.     }
  40.     inline void AddConflict(VariableSymbol *conflict_symbol)
  41.     {
  42.         if ((variable_symbol != conflict_symbol) && (! Find(conflict_symbol)))
  43.             conflict -> Next() = conflict_symbol;
  44.         return;
  45.     }
  46.     inline void CompressSpace()
  47.     {
  48.         if (conflict)
  49.             (void) conflict -> Array();
  50.     }
  51.  
  52. private:
  53.     friend class ExpandedFieldTable;
  54.     VariableShadowSymbol *next;
  55.  
  56.     ConvertibleArray<VariableSymbol *> *conflict;
  57.  
  58.     bool Find(VariableSymbol *conflict_symbol)
  59.     {
  60.         if (! conflict)
  61.             conflict = new ConvertibleArray<VariableSymbol *>(4);
  62.         for (int k = 0; k < conflict -> Length(); k++)
  63.             if ((*conflict)[k] == conflict_symbol)
  64.                 return true;
  65.         return false;
  66.     }
  67. };
  68.  
  69.  
  70. class MethodShadowSymbol
  71. {
  72. public:
  73.     MethodSymbol *method_symbol;
  74.     MethodShadowSymbol *next_method;
  75.  
  76.     MethodShadowSymbol(MethodSymbol *method_symbol_) : method_symbol(method_symbol_),
  77.                                                        conflict(NULL)
  78.     {}
  79.  
  80.     ~MethodShadowSymbol()
  81.     {
  82.         delete conflict;
  83.     }
  84.  
  85.     MethodSymbol *Conflict(const int i) { return (*conflict)[i]; }
  86.  
  87.     inline int NumConflicts()
  88.     {
  89.         return (conflict ? conflict -> Length() : 0);
  90.     }
  91.     inline void AddConflict(MethodSymbol *conflict_symbol)
  92.     {
  93.         if ((method_symbol != conflict_symbol) && (! Find(conflict_symbol)))
  94.             conflict -> Next() = conflict_symbol;
  95.         return;
  96.     }
  97.     inline void RemoveConflicts()
  98.     {
  99.         delete conflict;
  100.         conflict = NULL;
  101.     }
  102.  
  103.     inline void CompressSpace()
  104.     {
  105.         if (conflict)
  106.             (void) conflict -> Array();
  107.     }
  108.  
  109. private:
  110.     friend class ExpandedMethodTable;
  111.     MethodShadowSymbol *next;
  112.  
  113.     ConvertibleArray<MethodSymbol *> *conflict;
  114.  
  115.     bool Find(MethodSymbol *conflict_symbol)
  116.     {
  117.         if (! conflict)
  118.             conflict = new ConvertibleArray<MethodSymbol *>(4);
  119.         for (int k = 0; k < conflict -> Length(); k++)
  120.             if ((*conflict)[k] == conflict_symbol)
  121.                 return true;
  122.         return false;
  123.     }
  124. };
  125.  
  126.  
  127. class TypeShadowSymbol
  128. {
  129. public:
  130.     TypeSymbol *type_symbol;
  131.  
  132.     TypeShadowSymbol(TypeSymbol *type_symbol_) : type_symbol(type_symbol_),
  133.                                                  conflict(NULL)
  134.     {}
  135.  
  136.     ~TypeShadowSymbol()
  137.     {
  138.         delete conflict;
  139.     }
  140.  
  141.     TypeSymbol *Conflict(int i) { return (*conflict)[i]; }
  142.  
  143.     inline int NumConflicts()
  144.     {
  145.         return (conflict ? conflict -> Length() : 0);
  146.     }
  147.  
  148.     inline void AddConflict(TypeSymbol *conflict_symbol)
  149.     {
  150.         if ((type_symbol != conflict_symbol) && (! Find(conflict_symbol)))
  151.             conflict -> Next() = conflict_symbol;
  152.         return;
  153.     }
  154.  
  155.     inline void CompressSpace()
  156.     {
  157.         if (conflict)
  158.             (void) conflict -> Array();
  159.     }
  160.  
  161. private:
  162.     friend class ExpandedTypeTable;
  163.     TypeShadowSymbol *next;
  164.  
  165.     ConvertibleArray<TypeSymbol *> *conflict;
  166.  
  167.     bool Find(TypeSymbol *conflict_symbol)
  168.     {
  169.         if (! conflict)
  170.             conflict = new ConvertibleArray<TypeSymbol *>(4);
  171.         for (int k = 0; k < conflict -> Length(); k++)
  172.             if ((*conflict)[k] == conflict_symbol)
  173.                 return true;
  174.         return false;
  175.     }
  176. };
  177.  
  178.  
  179. class ExpandedTypeTable
  180. {
  181. public:
  182.     enum
  183.     {
  184.         DEFAULT_HASH_SIZE = 251,
  185.         MAX_HASH_SIZE = 509
  186.     };
  187.  
  188.     ConvertibleArray<TypeShadowSymbol *> symbol_pool;
  189.  
  190.     inline void CompressSpace()
  191.     {
  192.         hash_size = symbol_pool.Length();
  193.         hash_size = (hash_size <= 0 ? 1 : (hash_size > MAX_HASH_SIZE ? MAX_HASH_SIZE : hash_size));
  194.         delete [] base;
  195.         base = (TypeShadowSymbol **) memset(new TypeShadowSymbol *[hash_size], 0, hash_size * sizeof(TypeShadowSymbol *));
  196.  
  197.         TypeShadowSymbol **array = symbol_pool.Array();
  198.         for (int i = 0; i < symbol_pool.Length(); i++)
  199.         {
  200.             array[i] -> CompressSpace();
  201.  
  202.             int k = array[i] -> type_symbol -> name_symbol -> index % hash_size;
  203.             array[i] -> next = base[k];
  204.             base[k] = array[i];
  205.         }
  206.     }
  207.  
  208.     ExpandedTypeTable(int hash_size_ = DEFAULT_HASH_SIZE) : symbol_pool(10, 4)
  209.     {
  210.         hash_size = (hash_size_ <= 0 ? 1 : (hash_size_ > MAX_HASH_SIZE ? MAX_HASH_SIZE : hash_size_));
  211.         base = (TypeShadowSymbol **) memset(new TypeShadowSymbol *[hash_size], 0, hash_size * sizeof(TypeShadowSymbol *));
  212.     }
  213.  
  214.     ~ExpandedTypeTable()
  215.     {
  216.         for (int k = 0; k < symbol_pool.Length(); k++)
  217.             delete symbol_pool[k];
  218.         delete [] base;
  219.     }
  220.  
  221.     inline TypeShadowSymbol *InsertTypeShadowSymbol(TypeSymbol *type_symbol)
  222.     {
  223.         int i = type_symbol -> name_symbol -> index % hash_size;
  224.         TypeShadowSymbol *p = new TypeShadowSymbol(type_symbol);
  225.         p -> next = base[i];
  226.         base[i] = p;
  227.         symbol_pool.Next() = p;
  228.  
  229.         return p;
  230.     }
  231.  
  232.     inline TypeShadowSymbol *FindTypeShadowSymbol(NameSymbol *name_symbol)
  233.     {
  234.         TypeShadowSymbol *p;
  235.         for (p = base[name_symbol -> index % hash_size]; p; p = p -> next)
  236.              if (p -> type_symbol -> name_symbol == name_symbol)
  237.                  break;
  238.         return p;
  239.     }
  240.  
  241. private:
  242.     TypeShadowSymbol **base;
  243.     int hash_size;
  244. };
  245.  
  246. class ExpandedFieldTable
  247. {
  248. public:
  249.     enum
  250.     {
  251.         DEFAULT_HASH_SIZE = 251,
  252.         MAX_HASH_SIZE = 509
  253.     };
  254.  
  255.     ConvertibleArray<VariableShadowSymbol *> symbol_pool;
  256.  
  257.     inline void CompressSpace()
  258.     {
  259.         hash_size = symbol_pool.Length();
  260.         hash_size = (hash_size <= 0 ? 1 : (hash_size > MAX_HASH_SIZE ? MAX_HASH_SIZE : hash_size));
  261.         delete [] base;
  262.         base = (VariableShadowSymbol **) memset(new VariableShadowSymbol *[hash_size], 0, hash_size * sizeof(VariableShadowSymbol *));
  263.  
  264.         VariableShadowSymbol **array = symbol_pool.Array();
  265.         for (int i = 0; i < symbol_pool.Length(); i++)
  266.         {
  267.             array[i] -> CompressSpace();
  268.  
  269.             int k = array[i] -> variable_symbol -> name_symbol -> index % hash_size;
  270.             array[i] -> next = base[k];
  271.             base[k] = array[i];
  272.         }
  273.     }
  274.  
  275.     ExpandedFieldTable(int hash_size_ = DEFAULT_HASH_SIZE) : symbol_pool(10, 4)
  276.     {
  277.         hash_size = (hash_size_ <= 0 ? 1 : (hash_size_ > MAX_HASH_SIZE ? MAX_HASH_SIZE : hash_size_));
  278.         base = (VariableShadowSymbol **) memset(new VariableShadowSymbol *[hash_size], 0, hash_size * sizeof(VariableShadowSymbol *));
  279.     }
  280.     ~ExpandedFieldTable()
  281.     {
  282.         for (int i = 0; i < symbol_pool.Length(); i++)
  283.             delete symbol_pool[i];
  284.         delete [] base;
  285.     }
  286.  
  287.     inline VariableShadowSymbol *InsertVariableShadowSymbol(VariableSymbol *variable_symbol)
  288.     {
  289.         int i = variable_symbol -> name_symbol -> index % hash_size;
  290.         VariableShadowSymbol *p = new VariableShadowSymbol(variable_symbol);
  291.         p -> next = base[i];
  292.         base[i] = p;
  293.         symbol_pool.Next() = p;
  294.  
  295.         return p;
  296.     }
  297.  
  298.     inline VariableShadowSymbol *FindVariableShadowSymbol(NameSymbol *name_symbol)
  299.     {
  300.         VariableShadowSymbol *p;
  301.         for (p = base[name_symbol -> index % hash_size]; p; p = p -> next)
  302.             if (p -> variable_symbol -> name_symbol == name_symbol)
  303.                 break;
  304.         return p;
  305.     }
  306.  
  307. private:
  308.     VariableShadowSymbol **base;
  309.     int hash_size;
  310. };
  311.  
  312.  
  313. class ExpandedMethodTable
  314. {
  315. public:
  316.     enum
  317.     {
  318.         DEFAULT_HASH_SIZE = 251,
  319.         MAX_HASH_SIZE = 509
  320.     };
  321.  
  322.     ConvertibleArray<MethodShadowSymbol *> symbol_pool;
  323.  
  324.     inline void CompressSpace()
  325.     {
  326.         hash_size = symbol_pool.Length();
  327.         hash_size = (hash_size <= 0 ? 1 : (hash_size > MAX_HASH_SIZE ? MAX_HASH_SIZE : hash_size));
  328.         delete [] base;
  329.         base = (MethodShadowSymbol **) memset(new MethodShadowSymbol *[hash_size], 0, hash_size * sizeof(MethodShadowSymbol *));
  330.  
  331.         MethodShadowSymbol **array = symbol_pool.Array();
  332.         for (int i = 0; i < symbol_pool.Length(); i++)
  333.         {
  334.             array[i] -> CompressSpace();
  335.  
  336.             NameSymbol *name_symbol = array[i] -> method_symbol -> name_symbol;
  337.             MethodShadowSymbol *base_shadow = FindMethodShadowSymbol(name_symbol);
  338.             if (! base_shadow)
  339.             {
  340.                 int k = name_symbol -> index % hash_size;
  341.                 array[i] -> next = base[k];
  342.                 base[k] = array[i];
  343.                 array[i] -> next_method = NULL;
  344.             }
  345.             else
  346.             {
  347.                 array[i] -> next_method = base_shadow -> next_method;
  348.                 base_shadow -> next_method = array[i];
  349.             }
  350.         }
  351.     }
  352.  
  353.     ExpandedMethodTable(int hash_size_ = DEFAULT_HASH_SIZE) : symbol_pool(10, 4)
  354.     {
  355.         hash_size = (hash_size_ <= 0 ? 1 : (hash_size_ > MAX_HASH_SIZE ? MAX_HASH_SIZE : hash_size_));
  356.         base = (MethodShadowSymbol **) memset(new MethodShadowSymbol *[hash_size], 0, hash_size * sizeof(MethodShadowSymbol *));
  357.     }
  358.     ~ExpandedMethodTable()
  359.     {
  360.         for (int i = 0; i < symbol_pool.Length(); i++)
  361.             delete symbol_pool[i];
  362.        delete [] base;
  363.     }
  364.  
  365.     inline MethodShadowSymbol *FindMethodShadowSymbol(NameSymbol *name_symbol)
  366.     {
  367.         MethodShadowSymbol *p;
  368.         for (p = base[name_symbol -> index % hash_size]; p; p = p -> next)
  369.             if (p -> method_symbol -> name_symbol == name_symbol)
  370.                 break;
  371.         return p;
  372.     }
  373.  
  374.     inline void InsertMethodShadowSymbol(MethodSymbol *method_symbol)
  375.     {
  376.         int i = method_symbol -> name_symbol -> index % hash_size;
  377.         MethodShadowSymbol *p = new MethodShadowSymbol(method_symbol);
  378.         p -> next_method = NULL;
  379.         p -> next = base[i];
  380.         base[i] = p;
  381.         symbol_pool.Next() = p;
  382.  
  383.         return;
  384.     }
  385.  
  386.     inline void Overload(MethodShadowSymbol *base_shadow, MethodSymbol *overload_method)
  387.     {
  388.         MethodShadowSymbol *shadow = new MethodShadowSymbol(overload_method);
  389.         symbol_pool.Next() = shadow;
  390.         shadow -> next_method = base_shadow -> next_method;
  391.         base_shadow -> next_method = shadow;
  392.     }
  393.  
  394.     inline void Overload(MethodSymbol *overload_method)
  395.     {
  396.         MethodShadowSymbol *base_shadow = FindMethodShadowSymbol(overload_method -> name_symbol);
  397.         if (! base_shadow)
  398.              InsertMethodShadowSymbol(overload_method);
  399.         else Overload(base_shadow, overload_method);
  400.     }
  401.  
  402.     MethodShadowSymbol *FindOverloadMethodShadow(MethodSymbol *overload_method, Semantic *sem, LexStream::TokenIndex tok)
  403.     {
  404.         if (! overload_method -> IsTyped())
  405.             overload_method -> ProcessMethodSignature(sem, tok);
  406.  
  407.         for (MethodShadowSymbol *method_shadow = FindMethodShadowSymbol(overload_method -> name_symbol);
  408.              method_shadow;
  409.              method_shadow = method_shadow -> next_method)
  410.         {
  411.             MethodSymbol *method = method_shadow -> method_symbol;
  412.  
  413.             if (overload_method == method)
  414.                 return method_shadow;
  415.  
  416.             if (! method -> IsTyped())
  417.                 method -> ProcessMethodSignature(sem, tok);
  418.  
  419.             if (overload_method -> NumFormalParameters() == method -> NumFormalParameters())
  420.             {
  421.                 int i;
  422.                 for (i = method -> NumFormalParameters() - 1; i >= 0; i--)
  423.                 {
  424.                     if (method -> FormalParameter(i) -> Type() != overload_method -> FormalParameter(i) -> Type())
  425.                         break;
  426.                 }
  427.  
  428.                 if (i < 0)
  429.                     return method_shadow;
  430.             }
  431.         }
  432.  
  433.         return (MethodShadowSymbol *) NULL;
  434.     }
  435.  
  436. private:
  437.     MethodShadowSymbol **base;
  438.     int hash_size;
  439. };
  440.  
  441. #ifdef    HAVE_JIKES_NAMESPACE
  442. }            // Close namespace Jikes block
  443. #endif
  444.  
  445. #endif
  446.  
  447.