home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 20 / AACD20.BIN / AACD / Programming / Jikes / Source / src / semantic.h < prev    next >
Encoding:
C/C++ Source or Header  |  2001-02-24  |  58.7 KB  |  1,325 lines
  1. // $Id: semantic.h,v 1.35 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 semantic_INCLUDED
  11. #define semantic_INCLUDED
  12.  
  13. #include "platform.h"
  14. #include "ast.h"
  15. #include "diagnose.h"
  16. #include "error.h"
  17. #include "symbol.h"
  18. #include "control.h"
  19. #include "tuple.h"
  20. #include "set.h"
  21.  
  22. /*
  23. //FIXME: include stuff
  24. #ifdef HAVE_WCHAR_H
  25. # include <wchar.h>
  26. #endif
  27. */
  28.  
  29. #ifdef    HAVE_JIKES_NAMESPACE
  30. namespace Jikes {    // Open namespace Jikes block
  31. #endif
  32.  
  33.  
  34. class cp_info;
  35. class TypeShadowSymbol;
  36.  
  37. //
  38. //
  39. //
  40. class SymbolTableStack
  41. {
  42. public:
  43.     void Push(SymbolTable *symtab) { table.Next() = symtab; }
  44.     void Pop()                     { if (table.Length() > 0) table.Reset(table.Length() - 1); }
  45.     int Size()                     { return table.Length(); }
  46.     SymbolTable *Top()             { return (SymbolTable *) (table.Length() > 0 ? table[table.Length() - 1] : NULL); }
  47.  
  48.     SymbolTable *operator[](const int i) { return table[i]; } /*  */
  49.  
  50.     //
  51.     // Search for a variable in a stack of symbol tables starting at the current symbol table
  52.     // and ending with the symbol table of the method from which this call originates.
  53.     //
  54.     VariableSymbol *FindVariableSymbol(NameSymbol *name_symbol)
  55.     {
  56.         for (int i = table.Length() - 1; i >= 0; i--)
  57.         {
  58.             VariableSymbol *symbol = table[i] -> FindVariableSymbol(name_symbol);
  59.             if (symbol)
  60.                 return symbol;
  61.         }
  62.         return (VariableSymbol *) NULL;
  63.     }
  64.  
  65.     //
  66.     // Search for a type in a stack of symbol tables starting at the current symbol table
  67.     // and ending with the symbol table of the method from which this call originates.
  68.     //
  69.     TypeSymbol* FindTypeSymbol(NameSymbol *name_symbol)
  70.     {
  71.         for (int i = table.Length() - 1; i >= 0; i--)
  72.         {
  73.             TypeSymbol *symbol = table[i] -> FindTypeSymbol(name_symbol);
  74.             if (symbol)
  75.                 return symbol;
  76.         }
  77.         return (TypeSymbol *) NULL;
  78.     }
  79.  
  80.     //
  81.     // Search for a label in a stack of symbol tables starting at the current symbol table
  82.     // and ending with the symbol table of the method from which this call originates.
  83.     //
  84.     LabelSymbol* FindLabelSymbol(NameSymbol *name_symbol)
  85.     {
  86.         for (int i = table.Length() - 1; i >= 0; i--)
  87.         {
  88.             LabelSymbol *label = table[i] -> FindLabelSymbol(name_symbol);
  89.             if (label)
  90.                 return label;
  91.         }
  92.         return (LabelSymbol *) NULL;
  93.     }
  94.  
  95. private:
  96.     Tuple<SymbolTable *> table;
  97. };
  98.  
  99.  
  100. //
  101. //
  102. //
  103. class ExceptionTableStack
  104. {
  105. public:
  106.     void Push(SymbolSet *set) { table.Next() = set; }
  107.     void       Pop()          { if (table.Length() > 0) table.Reset(table.Length() - 1); }
  108.     int        Size()         { return table.Length(); }
  109.     SymbolSet *Top()          { return (SymbolSet *) (table.Length() > 0 ? table[table.Length() - 1] : NULL); }
  110.  
  111. private:
  112.     Tuple<SymbolSet *> table;
  113. };
  114.  
  115.  
  116. //
  117. //
  118. //
  119. class StatementStack
  120. {
  121. public:
  122.     void Push(Ast *stmt) { info.Next() = stmt; }
  123.     void Pop()           { if (info.Length() > 0) info.Reset(info.Length() - 1); }
  124.     int Size()           { return info.Length(); }
  125.     Ast *Top()           { return (Ast *) (info.Length() > 0 ? info[info.Length() - 1] : NULL); }
  126.  
  127.     Ast *operator[](const int i) { return info[i]; }
  128.  
  129. private:
  130.     Tuple<Ast *> info;
  131. };
  132.  
  133.  
  134. //
  135. //
  136. //
  137. class BlockStack
  138. {
  139. public:
  140.     int max_size;
  141.  
  142.     void Push(AstBlock *block_)
  143.     {
  144.         block.Next() = block_;
  145.         index.Next() = 0;
  146.         if (block.Length() > max_size)
  147.             max_size = block.Length();
  148.     }
  149.  
  150.     void Pop()
  151.     {
  152.         int len = block.Length() - 1;
  153.         if (len >= 0)
  154.         {
  155.             block.Reset(len);
  156.             index.Reset(len);
  157.         }
  158.     }
  159.  
  160.     int Size() { return block.Length(); }
  161.     AstBlock *TopBlock() { return (AstBlock *) (block.Length() > 0 ? block[block.Length() - 1] : NULL); }
  162.  
  163.     AstBlock *operator[](const int i) { return block[i]; }
  164.  
  165.     int &TopMaxEnclosedVariableIndex()
  166.     {
  167.         if (index.Length() <= 0)
  168.             assert(false);
  169.         return index[index.Length() - 1];
  170.     }
  171.  
  172.     BlockStack() : max_size(0) {}
  173.  
  174. private:
  175.     Tuple<AstBlock *> block;
  176.     Tuple<int> index;
  177. };
  178.  
  179.  
  180. //
  181. //
  182. //
  183. class DefiniteFinalAssignmentStack
  184. {
  185. public:
  186.     void Push() { info.Next().Reset(); }
  187.     void Pop()  { if (info.Length() > 0) info.Reset(info.Length() - 1); }
  188.     int Size()  { return info.Length(); }
  189.     Tuple <AstExpression *> &Top()  { if (info.Length() == 0) assert(false); return info[info.Length() - 1]; }
  190.  
  191. private:
  192.     Tuple< Tuple<AstExpression *> > info;
  193. };
  194.  
  195.  
  196. //
  197. //
  198. //
  199. class DefiniteSets
  200. {
  201. public:
  202.     DefiniteSets(int set_size) : break_set(set_size),
  203.                                  continue_set(set_size),
  204.                                  return_set(set_size),
  205.                                  throw_set(set_size)
  206.     {}
  207.  
  208.     BitSet break_set,
  209.            continue_set,
  210.            return_set,
  211.            throw_set;
  212.  
  213.     void UniverseInit()
  214.     {
  215.         break_set.SetUniverse();
  216.         continue_set.SetUniverse();
  217.         return_set.SetUniverse();
  218.         throw_set.SetUniverse();
  219.     }
  220.  
  221.     void EmptyInit()
  222.     {
  223.         break_set.SetEmpty();
  224.         continue_set.SetEmpty();
  225.         return_set.SetEmpty();
  226.         throw_set.SetEmpty();
  227.     }
  228. };
  229.  
  230.  
  231. //
  232. //
  233. //
  234. class DefiniteBlockStack
  235. {
  236. public:
  237.  
  238.     void Push(AstBlock *block_)
  239.     {
  240.         definite_sets[top_index] -> UniverseInit();
  241.         final_sets[top_index] -> EmptyInit();
  242.  
  243.         if (locally_defined_variables)
  244.         {
  245.             if (top_index == 0)
  246.             {
  247.                 memset(local_variables[top_index], 0, locally_defined_variables[top_index] -> Size() * sizeof(VariableSymbol *));
  248.                 locally_defined_variables[top_index] -> SetEmpty();
  249.             }
  250.             else
  251.             {
  252.                 memmove(local_variables[top_index],
  253.                         local_variables[top_index - 1],
  254.                         locally_defined_variables[top_index] -> Size() * sizeof(VariableSymbol *));
  255.                 *locally_defined_variables[top_index] = *locally_defined_variables[top_index - 1];
  256.             }
  257.         }
  258.  
  259.         block[top_index] = block_;
  260.         top_index++;
  261.     }
  262.  
  263.     void Pop()
  264.     {
  265.         if (top_index > 0)
  266.              top_index--;
  267.         else assert(false);
  268.     }
  269.  
  270.     int Size()                 { return top_index; }
  271.     AstBlock *Block(int i)     { return block[i]; }
  272.     AstBlock *TopBlock()       { assert(top_index > 0); return block[top_index - 1]; }
  273.  
  274.     VariableSymbol **TopLocalVariables() { assert(top_index > 0 && local_variables); return local_variables[top_index - 1]; }
  275.     BitSet *TopLocallyDefinedVariables() { assert(top_index > 0 && locally_defined_variables); return locally_defined_variables[top_index - 1]; }
  276.  
  277.     BitSet &BreakSet(int i)    { return definite_sets[i] -> break_set; }
  278.     BitSet &ContinueSet(int i) { return definite_sets[i] -> continue_set; }
  279.     BitSet &ReturnSet(int i)   { return definite_sets[i] -> return_set; }
  280.     BitSet &ThrowSet(int i)    { return definite_sets[i] -> throw_set; }
  281.  
  282.     BitSet &TopBreakSet()      { assert(top_index > 0); return definite_sets[top_index - 1] -> break_set; }
  283.     BitSet &TopContinueSet()   { assert(top_index > 0); return definite_sets[top_index - 1] -> continue_set; }
  284.     BitSet &TopReturnSet()     { assert(top_index > 0); return definite_sets[top_index - 1] -> return_set; }
  285.     BitSet &TopThrowSet()      { assert(top_index > 0); return definite_sets[top_index - 1] -> throw_set; }
  286.  
  287.     BitSet &TopExitSet(BitSet &start_set)
  288.     {
  289.         assert(top_index > 0);
  290.  
  291.         exit_set  = start_set;
  292.         exit_set *= TopBreakSet();
  293.         exit_set *= TopContinueSet();
  294.         exit_set *= TopReturnSet();
  295.         exit_set *= TopThrowSet();
  296.  
  297.         return exit_set;
  298.     }
  299.  
  300.     BitSet &FinalBreakSet(int i)    { return final_sets[i] -> break_set; }
  301.     BitSet &FinalContinueSet(int i) { return final_sets[i] -> continue_set; }
  302.     BitSet &FinalReturnSet(int i)   { return final_sets[i] -> return_set; }
  303.     BitSet &FinalThrowSet(int i)    { return final_sets[i] -> throw_set; }
  304.  
  305.     BitSet &TopFinalBreakSet()      { assert(top_index > 0); return final_sets[top_index - 1] -> break_set; }
  306.     BitSet &TopFinalContinueSet()   { assert(top_index > 0); return final_sets[top_index - 1] -> continue_set; }
  307.     BitSet &TopFinalReturnSet()     { assert(top_index > 0); return final_sets[top_index - 1] -> return_set; }
  308.     BitSet &TopFinalThrowSet()      { assert(top_index > 0); return final_sets[top_index - 1] -> throw_set; }
  309.  
  310.     BitSet &TopFinalExitSet(BitSet &start_set)
  311.     {
  312.         assert(top_index > 0);
  313.  
  314.         exit_set  = start_set;
  315.         exit_set += TopFinalBreakSet();
  316.         exit_set += TopFinalContinueSet();
  317.         exit_set += TopFinalReturnSet();
  318.         exit_set += TopFinalThrowSet();
  319.  
  320.         return exit_set;
  321.     }
  322.  
  323.     DefiniteBlockStack(Control &control, int stack_size_, int set_size) : stack_size(stack_size_),
  324.                                                                           top_index(0),
  325.                                                                           exit_set(set_size)
  326.     {
  327.         block = new AstBlock*[stack_size];
  328.         definite_sets = new DefiniteSets*[stack_size];
  329.         final_sets = new DefiniteSets*[stack_size];
  330.         local_variables = (VariableSymbol ***) (control.option.g ? new VariableSymbol**[stack_size] : NULL);
  331.         locally_defined_variables = (BitSet **) (control.option.g ? new BitSet*[stack_size] : NULL);
  332.  
  333.         for (int i = 0; i < stack_size; i++)
  334.         {
  335.             definite_sets[i] = new DefiniteSets(set_size);
  336.             final_sets[i] = new DefiniteSets(set_size);
  337.             if (local_variables)
  338.             {
  339.                 local_variables[i] = new VariableSymbol*[set_size];
  340.                 locally_defined_variables[i] = new BitSet(set_size);
  341.             }
  342.         }
  343.     }
  344.  
  345.     ~DefiniteBlockStack()
  346.     {
  347.         for (int i = 0; i < stack_size; i++)
  348.         {
  349.             delete definite_sets[i];
  350.             delete final_sets[i];
  351.             if (local_variables)
  352.             {
  353.                 delete [] local_variables[i];
  354.                 delete locally_defined_variables[i];
  355.             }
  356.         }
  357.  
  358.         delete [] block;
  359.         delete [] definite_sets;
  360.         delete [] final_sets;
  361.         delete [] local_variables;
  362.         delete [] locally_defined_variables;
  363.     }
  364.  
  365. private:
  366.  
  367.     int stack_size,
  368.         top_index;
  369.     AstBlock **block;
  370.  
  371.     DefiniteSets **definite_sets,
  372.                  **final_sets;
  373.  
  374.     BitSet **locally_defined_variables;
  375.     VariableSymbol ***local_variables;
  376.  
  377.     BitSet exit_set;
  378. };
  379.  
  380.  
  381. //
  382. //
  383. //
  384. class DefiniteTryStack
  385. {
  386. public:
  387.  
  388.     void Push(AstTryStatement *try_statement_)
  389.     {
  390.         this -> try_statement[top_index] = try_statement_;
  391.         top_index++;
  392.     }
  393.  
  394.     void Pop()
  395.     {
  396.         if (top_index > 0)
  397.              top_index--;
  398.         else assert(false);
  399.     }
  400.  
  401.     int Size()                           { return top_index; }
  402.     AstTryStatement *TryStatement(int i) { return try_statement[i]; }
  403.     AstBlock *Block(int i)               { return block[i]; }
  404.     AstBlock *TopBlock()                 { assert(top_index > 0); return block[top_index - 1]; }
  405.     void SetTopBlock(AstBlock *block_)   { assert(top_index > 0); block[top_index - 1] = block_; }
  406.  
  407.     DefiniteTryStack(int stack_size_) : stack_size(stack_size_),
  408.                                         top_index(0)
  409.     {
  410.         block = new AstBlock*[stack_size];
  411.         try_statement = new AstTryStatement*[stack_size];
  412.     }
  413.  
  414.     ~DefiniteTryStack()
  415.     {
  416.         delete [] block;
  417.         delete [] try_statement;
  418.     }
  419.  
  420. private:
  421.  
  422.     int stack_size,
  423.         top_index;
  424.     AstBlock **block;
  425.     AstTryStatement **try_statement;
  426. };
  427.  
  428.  
  429. //
  430. //
  431. //
  432. class SemanticEnvironment
  433. {
  434. public:
  435.  
  436.     Semantic *sem;
  437.     SemanticEnvironment *previous;
  438.  
  439.     MethodSymbol   *this_method;
  440.     VariableSymbol *this_variable;
  441.     Ast            *explicit_constructor_invocation;
  442.     Ast            *ast_construct;
  443.  
  444.     SymbolTableStack symbol_table; // Points to symbol table on top of stack
  445.     ExceptionTableStack try_exception_table_stack;
  446.     StatementStack try_statement_stack,
  447.                    breakable_statement_stack,
  448.                    continuable_statement_stack;
  449.     BlockStack block_stack;
  450.  
  451.     SemanticEnvironment(Semantic *sem_, TypeSymbol *type_, SemanticEnvironment *previous_ = NULL)
  452.             : sem(sem_),
  453.               previous(previous_),
  454.               this_method(NULL),
  455.               this_variable(NULL),
  456.               explicit_constructor_invocation(NULL),
  457.               ast_construct(NULL),
  458.               _type(type_),
  459.               next(NULL)
  460.     {}
  461.  
  462.  
  463.     ~SemanticEnvironment()
  464.     {
  465.         delete next; // if there was any clone, get rid of it
  466.     }
  467.  
  468.     //
  469.     // Clone the immediate environment of "this" Semantic environment.
  470.     // The immediate environment consists primarily of the stack of symbol
  471.     // tables that are necessary for looking up local variables in the immediate
  472.     // environment.
  473.     //
  474.     SemanticEnvironment *GetEnvironment(Ast *ast)
  475.     {
  476.         SemanticEnvironment *clone = new SemanticEnvironment(sem, _type, NULL);
  477.         clone -> this_method = this -> this_method;
  478.         clone -> this_variable = this -> this_variable;
  479.         clone -> ast_construct = ast;
  480.         for (int i = 0; i < this -> symbol_table.Size(); i++)
  481.             clone -> symbol_table.Push(this -> symbol_table[i]);
  482.         clone -> next = this -> next;
  483.         this -> next = clone;
  484.  
  485.         return clone;
  486.     }
  487.  
  488.     TypeSymbol *Type() { return _type; }
  489.  
  490.     //
  491.     // Are we in a static area ?
  492.     //
  493.     inline bool StaticRegion()
  494.     {
  495.         return (this_variable && this_variable -> ACC_STATIC()) ||
  496.                (this_method   && this_method -> ACC_STATIC())   ||
  497.                (_type -> ACC_INTERFACE());
  498.     }
  499.  
  500. private:
  501.  
  502.     TypeSymbol *_type;
  503.     SemanticEnvironment *next; // use to link an environment to its clones.
  504. };
  505.  
  506.  
  507. //
  508. //
  509. //
  510. class SemanticEnvironmentStack
  511. {
  512. public:
  513.     void Push(SemanticEnvironment *env) { info.Next() = env; }
  514.  
  515.     void Pop()
  516.     {
  517.         if (info.Length() > 0)
  518.             info.Reset(info.Length() - 1);
  519.  
  520.         return;
  521.     }
  522.  
  523.     int Size() { return info.Length(); }
  524.  
  525.     SemanticEnvironment *Top() { return (SemanticEnvironment *) (info.Length() > 0 ? info[info.Length() - 1] : NULL); }
  526.  
  527.     SemanticEnvironment *operator[](const int i) { return info[i]; }
  528.  
  529. private:
  530.     Tuple<SemanticEnvironment *> info;
  531. };
  532.  
  533.  
  534. class Semantic
  535. {
  536. public:
  537.     //
  538.     //
  539.     //
  540.     Control &control;
  541.     FileSymbol *source_file_symbol;
  542.     LexStream *lex_stream;
  543.     AstCompilationUnit *compilation_unit;
  544.     DirectorySymbol *directory_symbol;
  545.  
  546.     SymbolSet types_to_be_processed;
  547.  
  548.     int return_code;
  549.  
  550.     PackageSymbol *Package() { return this_package; }
  551.  
  552.     void CheckPackage();
  553.     void ProcessTypeNames();
  554.     void ProcessImports();
  555.     void ProcessSuperTypeDependences(AstClassDeclaration *);
  556.     void ProcessSuperTypeDependences(AstInterfaceDeclaration *);
  557.  
  558.     LiteralValue *ComputeFinalValue(AstVariableDeclarator *);
  559.  
  560.     Semantic(Control &control_, FileSymbol *file_symbol_) : control(control_),
  561.                                                             source_file_symbol(file_symbol_),
  562.                                                             lex_stream(file_symbol_ -> lex_stream),
  563.                                                             compilation_unit(file_symbol_ -> compilation_unit),
  564.                                                             directory_symbol(file_symbol_ -> directory_symbol),
  565.                                                             return_code(0),
  566.                                                             error(NULL),
  567.                                                             this_package(file_symbol_ -> package),
  568.                                                             definitely_assigned_variables(NULL),
  569.                                                             possibly_assigned_finals(NULL),
  570.                                                             universe(NULL),
  571.                                                             definite_block_stack(NULL),
  572.                                                             definite_try_stack(NULL),
  573.                                                             definite_final_assignment_stack(NULL),
  574.                                                             definite_visible_variables(NULL)
  575.     {
  576.         ProcessExprOrStmt[Ast::LOCAL_VARIABLE_DECLARATION] = &Semantic::ProcessLocalVariableDeclarationStatement;
  577.         ProcessExprOrStmt[Ast::BLOCK]                      = &Semantic::ProcessBlock;
  578.         ProcessExprOrStmt[Ast::EXPRESSION_STATEMENT]       = &Semantic::ProcessExpressionStatement;
  579.         ProcessExprOrStmt[Ast::SYNCHRONIZED_STATEMENT]     = &Semantic::ProcessSynchronizedStatement;
  580.         ProcessExprOrStmt[Ast::IF]                         = &Semantic::ProcessIfStatement;
  581.         ProcessExprOrStmt[Ast::WHILE]                      = &Semantic::ProcessWhileStatement;
  582.         ProcessExprOrStmt[Ast::FOR]                        = &Semantic::ProcessForStatement;
  583.         ProcessExprOrStmt[Ast::SWITCH]                     = &Semantic::ProcessSwitchStatement;
  584.         ProcessExprOrStmt[Ast::DO]                         = &Semantic::ProcessDoStatement;
  585.         ProcessExprOrStmt[Ast::BREAK]                      = &Semantic::ProcessBreakStatement;
  586.         ProcessExprOrStmt[Ast::CONTINUE]                   = &Semantic::ProcessContinueStatement;
  587.         ProcessExprOrStmt[Ast::RETURN]                     = &Semantic::ProcessReturnStatement;
  588.         ProcessExprOrStmt[Ast::THROW]                      = &Semantic::ProcessThrowStatement;
  589.         ProcessExprOrStmt[Ast::TRY]                        = &Semantic::ProcessTryStatement;
  590.         ProcessExprOrStmt[Ast::EMPTY_STATEMENT]            = &Semantic::ProcessEmptyStatement;
  591.         ProcessExprOrStmt[Ast::CLASS]                      = &Semantic::ProcessClassDeclaration;
  592.  
  593.         ProcessExprOrStmt[Ast::IDENTIFIER]               = &Semantic::ProcessSimpleName;
  594.         ProcessExprOrStmt[Ast::DOT]                      = &Semantic::ProcessFieldAccess;
  595.         ProcessExprOrStmt[Ast::INTEGER_LITERAL]          = &Semantic::ProcessIntegerLiteral;
  596.         ProcessExprOrStmt[Ast::LONG_LITERAL]             = &Semantic::ProcessLongLiteral;
  597.         ProcessExprOrStmt[Ast::FLOATING_POINT_LITERAL]   = &Semantic::ProcessFloatingPointLiteral;
  598.         ProcessExprOrStmt[Ast::DOUBLE_LITERAL]           = &Semantic::ProcessDoubleLiteral;
  599.         ProcessExprOrStmt[Ast::TRUE_LITERAL]             = &Semantic::ProcessTrueLiteral;
  600.         ProcessExprOrStmt[Ast::FALSE_LITERAL]            = &Semantic::ProcessFalseLiteral;
  601.         ProcessExprOrStmt[Ast::STRING_LITERAL]           = &Semantic::ProcessStringLiteral;
  602.         ProcessExprOrStmt[Ast::CHARACTER_LITERAL]        = &Semantic::ProcessCharacterLiteral;
  603.         ProcessExprOrStmt[Ast::NULL_LITERAL]             = &Semantic::ProcessNullLiteral;
  604.         ProcessExprOrStmt[Ast::ARRAY_ACCESS]             = &Semantic::ProcessArrayAccess;
  605.         ProcessExprOrStmt[Ast::CALL]                     = &Semantic::ProcessMethodInvocation;
  606.         ProcessExprOrStmt[Ast::THIS_EXPRESSION]          = &Semantic::ProcessThisExpression;
  607.         ProcessExprOrStmt[Ast::SUPER_EXPRESSION]         = &Semantic::ProcessSuperExpression;
  608.         ProcessExprOrStmt[Ast::PARENTHESIZED_EXPRESSION] = &Semantic::ProcessParenthesizedExpression;
  609.         ProcessExprOrStmt[Ast::CLASS_CREATION]           = &Semantic::ProcessClassInstanceCreationExpression;
  610.         ProcessExprOrStmt[Ast::ARRAY_CREATION]           = &Semantic::ProcessArrayCreationExpression;
  611.         ProcessExprOrStmt[Ast::POST_UNARY]               = &Semantic::ProcessPostUnaryExpression;
  612.         ProcessExprOrStmt[Ast::PRE_UNARY]                = &Semantic::ProcessPreUnaryExpression;
  613.         ProcessExprOrStmt[Ast::CAST]                     = &Semantic::ProcessCastExpression;
  614.         ProcessExprOrStmt[Ast::BINARY]                   = &Semantic::ProcessBinaryExpression;
  615.         ProcessExprOrStmt[Ast::TYPE]                     = &Semantic::ProcessTypeExpression;
  616.         ProcessExprOrStmt[Ast::CONDITIONAL]              = &Semantic::ProcessConditionalExpression;
  617.         ProcessExprOrStmt[Ast::ASSIGNMENT]               = &Semantic::ProcessAssignmentExpression;
  618.  
  619.         DefiniteStmt[Ast::LOCAL_VARIABLE_DECLARATION] = &Semantic::DefiniteLocalVariableDeclarationStatement;
  620.         DefiniteStmt[Ast::BLOCK]                      = &Semantic::DefiniteBlock;
  621.         DefiniteStmt[Ast::EXPRESSION_STATEMENT]       = &Semantic::DefiniteExpressionStatement;
  622.         DefiniteStmt[Ast::SYNCHRONIZED_STATEMENT]     = &Semantic::DefiniteSynchronizedStatement;
  623.         DefiniteStmt[Ast::IF]                         = &Semantic::DefiniteIfStatement;
  624.         DefiniteStmt[Ast::WHILE]                      = &Semantic::DefiniteWhileStatement;
  625.         DefiniteStmt[Ast::FOR]                        = &Semantic::DefiniteForStatement;
  626.         DefiniteStmt[Ast::SWITCH]                     = &Semantic::DefiniteSwitchStatement;
  627.         DefiniteStmt[Ast::DO]                         = &Semantic::DefiniteDoStatement;
  628.         DefiniteStmt[Ast::BREAK]                      = &Semantic::DefiniteBreakStatement;
  629.         DefiniteStmt[Ast::CONTINUE]                   = &Semantic::DefiniteContinueStatement;
  630.         DefiniteStmt[Ast::RETURN]                     = &Semantic::DefiniteReturnStatement;
  631.         DefiniteStmt[Ast::THROW]                      = &Semantic::DefiniteThrowStatement;
  632.         DefiniteStmt[Ast::TRY]                        = &Semantic::DefiniteTryStatement;
  633.         DefiniteStmt[Ast::EMPTY_STATEMENT]            = &Semantic::DefiniteEmptyStatement;
  634.         DefiniteStmt[Ast::CLASS]                      = &Semantic::DefiniteClassDeclaration;
  635.  
  636.         DefiniteExpr[Ast::IDENTIFIER]               = &Semantic::DefiniteSimpleName;
  637.         DefiniteExpr[Ast::DOT]                      = &Semantic::DefiniteFieldAccess;
  638.         DefiniteExpr[Ast::ARRAY_ACCESS]             = &Semantic::DefiniteArrayAccess;
  639.         DefiniteExpr[Ast::CALL]                     = &Semantic::DefiniteMethodInvocation;
  640.         DefiniteExpr[Ast::PARENTHESIZED_EXPRESSION] = &Semantic::DefiniteParenthesizedExpression;
  641.         DefiniteExpr[Ast::CLASS_CREATION]           = &Semantic::DefiniteClassInstanceCreationExpression;
  642.         DefiniteExpr[Ast::ARRAY_CREATION]           = &Semantic::DefiniteArrayCreationExpression;
  643.         DefiniteExpr[Ast::POST_UNARY]               = &Semantic::DefinitePostUnaryExpression;
  644.         DefiniteExpr[Ast::PRE_UNARY]                = &Semantic::DefinitePreUnaryExpression;
  645.         DefiniteExpr[Ast::CAST]                     = &Semantic::DefiniteCastExpression;
  646.         DefiniteExpr[Ast::CHECK_AND_CAST]           = &Semantic::DefiniteCastExpression;
  647.         DefiniteExpr[Ast::BINARY]                   = &Semantic::DefiniteBinaryExpression;
  648.         DefiniteExpr[Ast::CONDITIONAL]              = &Semantic::DefiniteConditionalExpression;
  649.         DefiniteExpr[Ast::ASSIGNMENT]               = &Semantic::DefiniteAssignmentExpression;
  650.  
  651.         DefiniteExpr[Ast::INTEGER_LITERAL]          = &Semantic::DefiniteDefaultExpression;
  652.         DefiniteExpr[Ast::LONG_LITERAL]             = &Semantic::DefiniteDefaultExpression;
  653.         DefiniteExpr[Ast::FLOATING_POINT_LITERAL]   = &Semantic::DefiniteDefaultExpression;
  654.         DefiniteExpr[Ast::DOUBLE_LITERAL]           = &Semantic::DefiniteDefaultExpression;
  655.         DefiniteExpr[Ast::TRUE_LITERAL]             = &Semantic::DefiniteDefaultExpression;
  656.         DefiniteExpr[Ast::FALSE_LITERAL]            = &Semantic::DefiniteDefaultExpression;
  657.         DefiniteExpr[Ast::STRING_LITERAL]           = &Semantic::DefiniteDefaultExpression;
  658.         DefiniteExpr[Ast::CHARACTER_LITERAL]        = &Semantic::DefiniteDefaultExpression;
  659.         DefiniteExpr[Ast::NULL_LITERAL]             = &Semantic::DefiniteDefaultExpression;
  660.         DefiniteExpr[Ast::THIS_EXPRESSION]          = &Semantic::DefiniteDefaultExpression;
  661.         DefiniteExpr[Ast::SUPER_EXPRESSION]         = &Semantic::DefiniteDefaultExpression;
  662.         DefiniteExpr[Ast::TYPE]                     = &Semantic::DefiniteDefaultExpression;
  663.  
  664.         DefiniteBinaryExpr[AstBinaryExpression::PLUS]                 = &Semantic::DefiniteDefaultBinaryExpression;
  665.         DefiniteBinaryExpr[AstBinaryExpression::LEFT_SHIFT]           = &Semantic::DefiniteDefaultBinaryExpression;
  666.         DefiniteBinaryExpr[AstBinaryExpression::RIGHT_SHIFT]          = &Semantic::DefiniteDefaultBinaryExpression;
  667.         DefiniteBinaryExpr[AstBinaryExpression::UNSIGNED_RIGHT_SHIFT] = &Semantic::DefiniteDefaultBinaryExpression;
  668.         DefiniteBinaryExpr[AstBinaryExpression::LESS]                 = &Semantic::DefiniteDefaultBinaryExpression;
  669.         DefiniteBinaryExpr[AstBinaryExpression::GREATER]              = &Semantic::DefiniteDefaultBinaryExpression;
  670.         DefiniteBinaryExpr[AstBinaryExpression::LESS_EQUAL]           = &Semantic::DefiniteDefaultBinaryExpression;
  671.         DefiniteBinaryExpr[AstBinaryExpression::GREATER_EQUAL]        = &Semantic::DefiniteDefaultBinaryExpression;
  672.  
  673.         //
  674.         // TODO: Remove this comment as well as the functions:
  675.         //
  676.         //     DefiniteAND
  677.         //     DefiniteXOR
  678.         //     DefiniteIOR
  679.         //
  680.         //     DefiniteEQUAL
  681.         //     DefiniteNOT_EQUAL
  682.         //
  683.         // when revised spec is released !!!
  684.         //
  685.         //****************************************************************************************
  686.         //
  687.         // To: Martin Odersky <Martin.Odersky@epfl.ch>
  688.         // cc: David Shields/Watson/IBM@IBMUS, compiler@eng.sun.com,
  689.         // gilad.bracha@eng.sun.com, jrose@eng.sun.com,
  690.         // innerclass-comments@lukasiewicz.eng.sun.com, guy.steele@east.sun.com,
  691.         // peter.kessler@eng.sun.com
  692.         // Subject: Re: Query #32 to Sun: Verification problem
  693.         //
  694.         //
  695.         //
  696.         //
  697.         // On Thu, 29 Jul 1999, Martin Odersky wrote:
  698.         //
  699.         // > It seems a very undesirable state of affairs if the Java spec for |,
  700.         // > &, ^ and the JVM spec for iand, ior, ixor differ in their definite
  701.         // > assignment properties. Assuming that it's unreasonable to make the
  702.         // > verifier implement the current JLS spec one-to-one, would it be
  703.         // > possible to tighten the JLS so that definite assignment for |, & ,^ is
  704.         // > done in the way the verifier does it? I doubt that such a tightening
  705.         // > would invalidate any real Java programs.
  706.         //
  707.         // Gilad and I decided today that ammending the JLS was the best course of
  708.         // action, and then discovered that Guy had already done so in our working
  709.         // draft of the revised specification.  We anticipate that when a draft is
  710.         // made
  711.         // available for public review, it will drop sections 16.1.6, 16.1.7, and
  712.         // 16.1.8, which specify special-case rules for the &, |, and ^ operators.
  713.         // They will be covered instead by the general case for expressions with
  714.         // subexpressions, which reads as follows in the current working draft:
  715.         //
  716.         //  If the expression has subexpressions, V is [un]assigned
  717.         //  after the expression iff V is [un]assigned after its rightmost
  718.         //  immediate subexpression.
  719.         //
  720.         // Note that the when-true and when-false cases, currently distinguished
  721.         // for these operators, are now coalesced, as in the general case.
  722.         //
  723.         // Pending an official change to the specification, we recommend that
  724.         // compiler implementors follow the proposed ammendments.
  725.         //
  726.         // Due to the fact that 'javac' has never been in compliance with the
  727.         // current JLS on this issue, nor will much (all?) code that
  728.         // relies on the difference actually verify and execute, compatibility
  729.         // implications should be minimal.
  730.         //
  731.         // --Bill
  732.         //
  733.         //------------------------------------------------------------------------------------------------
  734.         //
  735.         // To: David Shields/Watson/IBM@IBMUS
  736.         // cc: Martin Odersky <Martin.Odersky@epfl.ch>, compiler@eng.sun.com, gilad.bracha@eng.sun.com,
  737.         // jrose@eng.sun.com, innerclass-comments@lukasiewicz.eng.sun.com, guy.steele@east.sun.com,
  738.         // peter.kessler@eng.sun.com
  739.         // Subject: Re: Query #32 to Sun: Verification problem
  740.         //
  741.         // On Mon, 2 Aug 1999 shieldsd@us.ibm.com wrote:
  742.         //
  743.         // > Do you still plan to retain 16.1.3, 16.1.4 and 16.1.11? Since we follow them as
  744.         // > currently written, we accept some of the positive 1.2 JCK tests that javac
  745.         // > currently rejects, but the resulting class files fail verification. Examples
  746.         // > include dasg02901, dasg03001, dasg03301, dasg03303, dasg03401, dasg03501,
  747.         // > dasg04501, dasg04601, dasg04701 and dasg05001).
  748.         // >
  749.         // > dave and philippe
  750.         //
  751.         // We plan to keep these.  However, the special rules for '==' (16.1.9) and
  752.         // '!=' (16.1.10) have also been dropped, again because the bytecodes for these
  753.         // operators create materialized boolean values on the stack at runtime.
  754.         //
  755.         // Guy and Gilad:  In my copy of the draft, the second-to-last sentence on
  756.         // page p.395 claims otherwise, but sections 16.1.9 and 16.1.10 have in fact
  757.         // been deleted.
  758.         //
  759.         // --Bill
  760.         //
  761.         DefiniteBinaryExpr[AstBinaryExpression::AND]                  = &Semantic::DefiniteDefaultBinaryExpression;// &Semantic::DefiniteAND;
  762.         DefiniteBinaryExpr[AstBinaryExpression::XOR]                  = &Semantic::DefiniteDefaultBinaryExpression;// &Semantic::DefiniteXOR;
  763.         DefiniteBinaryExpr[AstBinaryExpression::IOR]                  = &Semantic::DefiniteDefaultBinaryExpression;// &Semantic::DefiniteIOR;
  764.  
  765.         DefiniteBinaryExpr[AstBinaryExpression::EQUAL_EQUAL]          = &Semantic::DefiniteDefaultBinaryExpression; // &Semantic::DefiniteEQUAL_EQUAL;
  766.         DefiniteBinaryExpr[AstBinaryExpression::NOT_EQUAL]            = &Semantic::DefiniteDefaultBinaryExpression; // &Semantic::DefiniteNOT_EQUAL;
  767.  
  768.         DefiniteBinaryExpr[AstBinaryExpression::AND_AND]              = &Semantic::DefiniteAND_AND;
  769.         DefiniteBinaryExpr[AstBinaryExpression::OR_OR]                = &Semantic::DefiniteOR_OR;
  770.         DefiniteBinaryExpr[AstBinaryExpression::STAR]                 = &Semantic::DefiniteDefaultBinaryExpression;
  771.         DefiniteBinaryExpr[AstBinaryExpression::MINUS]                = &Semantic::DefiniteDefaultBinaryExpression;
  772.         DefiniteBinaryExpr[AstBinaryExpression::SLASH]                = &Semantic::DefiniteDefaultBinaryExpression;
  773.         DefiniteBinaryExpr[AstBinaryExpression::MOD]                  = &Semantic::DefiniteDefaultBinaryExpression;
  774.         DefiniteBinaryExpr[AstBinaryExpression::INSTANCEOF]           = &Semantic::DefiniteDefaultBinaryExpression;
  775.  
  776.         DefinitePreUnaryExpr[AstPreUnaryExpression::PLUS]             = &Semantic::DefiniteDefaultPreUnaryExpression;
  777.         DefinitePreUnaryExpr[AstPreUnaryExpression::MINUS]            = &Semantic::DefiniteDefaultPreUnaryExpression;
  778.         DefinitePreUnaryExpr[AstPreUnaryExpression::TWIDDLE]          = &Semantic::DefiniteDefaultPreUnaryExpression;
  779.         DefinitePreUnaryExpr[AstPreUnaryExpression::NOT]              = &Semantic::DefiniteNOT;
  780.         DefinitePreUnaryExpr[AstPreUnaryExpression::PLUSPLUS]         = &Semantic::DefinitePLUSPLUSOrMINUSMINUS;
  781.         DefinitePreUnaryExpr[AstPreUnaryExpression::MINUSMINUS]       = &Semantic::DefinitePLUSPLUSOrMINUSMINUS;
  782.  
  783.         ProcessBinaryExpr[AstBinaryExpression::PLUS]                 = &Semantic::ProcessPLUS;
  784.         ProcessBinaryExpr[AstBinaryExpression::LEFT_SHIFT]           = &Semantic::ProcessLEFT_SHIFT;
  785.         ProcessBinaryExpr[AstBinaryExpression::RIGHT_SHIFT]          = &Semantic::ProcessRIGHT_SHIFT;
  786.         ProcessBinaryExpr[AstBinaryExpression::UNSIGNED_RIGHT_SHIFT] = &Semantic::ProcessUNSIGNED_RIGHT_SHIFT;
  787.         ProcessBinaryExpr[AstBinaryExpression::LESS]                 = &Semantic::ProcessLESS;
  788.         ProcessBinaryExpr[AstBinaryExpression::GREATER]              = &Semantic::ProcessGREATER;
  789.         ProcessBinaryExpr[AstBinaryExpression::LESS_EQUAL]           = &Semantic::ProcessLESS_EQUAL;
  790.         ProcessBinaryExpr[AstBinaryExpression::GREATER_EQUAL]        = &Semantic::ProcessGREATER_EQUAL;
  791.         ProcessBinaryExpr[AstBinaryExpression::AND]                  = &Semantic::ProcessAND;
  792.         ProcessBinaryExpr[AstBinaryExpression::XOR]                  = &Semantic::ProcessXOR;
  793.         ProcessBinaryExpr[AstBinaryExpression::IOR]                  = &Semantic::ProcessIOR;
  794.         ProcessBinaryExpr[AstBinaryExpression::AND_AND]              = &Semantic::ProcessAND_AND;
  795.         ProcessBinaryExpr[AstBinaryExpression::OR_OR]                = &Semantic::ProcessOR_OR;
  796.         ProcessBinaryExpr[AstBinaryExpression::EQUAL_EQUAL]          = &Semantic::ProcessEQUAL_EQUAL;
  797.         ProcessBinaryExpr[AstBinaryExpression::NOT_EQUAL]            = &Semantic::ProcessNOT_EQUAL;
  798.         ProcessBinaryExpr[AstBinaryExpression::STAR]                 = &Semantic::ProcessSTAR;
  799.         ProcessBinaryExpr[AstBinaryExpression::MINUS]                = &Semantic::ProcessMINUS;
  800.         ProcessBinaryExpr[AstBinaryExpression::SLASH]                = &Semantic::ProcessSLASH;
  801.         ProcessBinaryExpr[AstBinaryExpression::MOD]                  = &Semantic::ProcessMOD;
  802.         ProcessBinaryExpr[AstBinaryExpression::INSTANCEOF]           = &Semantic::ProcessINSTANCEOF;
  803.  
  804.         ProcessPreUnaryExpr[AstPreUnaryExpression::PLUS]       = &Semantic::ProcessPLUS;
  805.         ProcessPreUnaryExpr[AstPreUnaryExpression::MINUS]      = &Semantic::ProcessMINUS;
  806.         ProcessPreUnaryExpr[AstPreUnaryExpression::TWIDDLE]    = &Semantic::ProcessTWIDDLE;
  807.         ProcessPreUnaryExpr[AstPreUnaryExpression::NOT]        = &Semantic::ProcessNOT;
  808.         ProcessPreUnaryExpr[AstPreUnaryExpression::PLUSPLUS]   = &Semantic::ProcessPLUSPLUSOrMINUSMINUS;
  809.         ProcessPreUnaryExpr[AstPreUnaryExpression::MINUSMINUS] = &Semantic::ProcessPLUSPLUSOrMINUSMINUS;
  810.     }
  811.  
  812.     ~Semantic() { delete error; }
  813.  
  814.     void ReportSemError(SemanticError::SemanticErrorKind kind,
  815.                         LexStream::TokenIndex ltok,
  816.                         LexStream::TokenIndex rtok,
  817.                         wchar_t *s1 = NULL,
  818.                         wchar_t *s2 = NULL,
  819.                         wchar_t *s3 = NULL,
  820.                         wchar_t *s4 = NULL,
  821.                         wchar_t *s5 = NULL,
  822.                         wchar_t *s6 = NULL,
  823.                         wchar_t *s7 = NULL,
  824.                         wchar_t *s8 = NULL,
  825.                         wchar_t *s9 = NULL)
  826.     {
  827.         if (! error)
  828.             error = new SemanticError(control, source_file_symbol);
  829.         error -> Report(kind, ltok, rtok, s1, s2, s3, s4, s5, s6, s7, s8, s9);
  830.     }
  831.  
  832.     int NumErrors() { return (error ? error -> num_errors : 0); }
  833.  
  834.     //
  835.     // If we had a bad compilation unit, print the parser messages.
  836.     // If semantic errors were detected print them too.
  837.     // Set the return code.
  838.     //
  839.     void PrintMessages()
  840.     {
  841.         if (this != control.system_semantic)
  842.         {
  843.             if (lex_stream -> NumBadTokens() > 0)
  844.             {
  845.                 lex_stream -> PrintMessages();
  846.                 return_code = 1;
  847.             }
  848.  
  849.             if ((! compilation_unit) || compilation_unit -> BadCompilationUnitCast())
  850.             {
  851.                 DiagnoseParser *diagnose_parser = new DiagnoseParser(control, lex_stream);
  852.                 return_code = 1;
  853.                 delete diagnose_parser;
  854.             }
  855.  
  856.             if (! control.option.nocleanup)
  857.             if (compilation_unit)
  858.                 CleanUp();
  859.         }
  860.  
  861.         if (error && error -> error.Length() > 0 && error -> PrintMessages() > return_code)
  862.             return_code = 1;
  863.  
  864.         //
  865.         // Once we have processed the errors, reset the error object
  866.         //
  867.         delete error;
  868.         error = NULL;
  869.  
  870.         return;
  871.     }
  872.  
  873.     TypeSymbol *ProcessSignature(TypeSymbol *, const char *, LexStream::TokenIndex);
  874.     TypeSymbol *ReadType(FileSymbol *, PackageSymbol *, NameSymbol *, LexStream::TokenIndex);
  875.     TypeSymbol *ReadTypeFromSignature(TypeSymbol *, const char *, int, LexStream::TokenIndex);
  876.     TypeSymbol *ProcessNestedType(TypeSymbol *, NameSymbol *, LexStream::TokenIndex);
  877.  
  878. private:
  879.  
  880.     SemanticError *error;
  881.  
  882.     void CleanUp();
  883.     void CleanUpType(TypeSymbol *);
  884.  
  885.     void SetDefaultSuperType(AstClassDeclaration *);
  886.     void SetDefaultSuperType(AstInterfaceDeclaration *);
  887.     void ProcessTypeHeader(AstClassDeclaration *);
  888.     void MarkCircularNest(TypeSymbol *);
  889.     void ProcessSuperTypesOfOuterType(TypeSymbol *);
  890.     void ProcessSuperTypesOfInnerType(TypeSymbol *, Tuple<TypeSymbol *> &);
  891.     void ProcessTypeHeaders(AstClassDeclaration *);
  892.     TypeSymbol *FindTypeInLayer(Ast *, SymbolSet &);
  893.     void ProcessNestedSuperTypes(TypeSymbol *);
  894.     void ProcessNestedTypeHeaders(TypeSymbol *, AstClassBody *);
  895.     void ProcessTypeHeader(AstInterfaceDeclaration *);
  896.     void ProcessTypeHeaders(AstInterfaceDeclaration *);
  897.     void ProcessNestedTypeHeaders(AstInterfaceDeclaration *);
  898.     void ProcessConstructorMembers(AstClassBody *);
  899.     void ProcessMethodMembers(AstClassBody *);
  900.     void ProcessFieldMembers(AstClassBody *);
  901.     void ProcessMembers(SemanticEnvironment *, AstClassBody *);
  902.     void CompleteSymbolTable(SemanticEnvironment *, LexStream::TokenIndex, AstClassBody *);
  903.     void ProcessExecutableBodies(SemanticEnvironment *, AstClassBody *);
  904.     void ProcessExecutableBodies(AstInterfaceDeclaration *);
  905.  
  906.     void ProcessMethodMembers(AstInterfaceDeclaration *);
  907.     void ProcessFieldMembers(AstInterfaceDeclaration *);
  908.     void ProcessMembers(AstInterfaceDeclaration *);
  909.     void CompleteSymbolTable(AstInterfaceDeclaration *);
  910.  
  911.     friend class TypeSymbol;
  912.  
  913.     Tuple<Symbol *> import_on_demand_packages;
  914.     Tuple<TypeSymbol *> single_type_imports;
  915.  
  916.     //
  917.     // Where am I?
  918.     //
  919.     PackageSymbol  *this_package;
  920.  
  921.     TypeSymbol *ThisType()                        { assert(state_stack.Size()); return state_stack.Top() -> Type(); }
  922.     MethodSymbol *&ThisMethod()                   { assert(state_stack.Size()); return state_stack.Top() -> this_method; }
  923.     VariableSymbol *&ThisVariable()               { assert(state_stack.Size()); return state_stack.Top() -> this_variable; }
  924.     Ast *&ExplicitConstructorInvocation()         { assert(state_stack.Size()); return state_stack.Top() -> explicit_constructor_invocation; }
  925.     SymbolTableStack &LocalSymbolTable()          { assert(state_stack.Size()); return state_stack.Top() -> symbol_table; }
  926.     ExceptionTableStack &TryExceptionTableStack() { assert(state_stack.Size()); return state_stack.Top() -> try_exception_table_stack; }
  927.     StatementStack &TryStatementStack()           { assert(state_stack.Size()); return state_stack.Top() -> try_statement_stack; }
  928.     StatementStack &BreakableStatementStack()     { assert(state_stack.Size()); return state_stack.Top() -> breakable_statement_stack; }
  929.     StatementStack &ContinuableStatementStack()   { assert(state_stack.Size()); return state_stack.Top() -> continuable_statement_stack; }
  930.     BlockStack &LocalBlockStack()                 { assert(state_stack.Size()); return state_stack.Top() -> block_stack; }
  931.     SemanticEnvironment *GetEnvironment(Ast *ast) { assert(state_stack.Size()); return state_stack.Top() -> GetEnvironment(ast); }
  932.     bool StaticRegion()                           { assert(state_stack.Size()); return state_stack.Top() -> StaticRegion(); }
  933.  
  934.     SemanticEnvironmentStack state_stack;
  935.  
  936.     BitSet *definitely_assigned_variables,
  937.            *possibly_assigned_finals,
  938.            *universe;
  939.     DefiniteBlockStack *definite_block_stack;
  940.     DefiniteTryStack *definite_try_stack;
  941.     DefiniteFinalAssignmentStack *definite_final_assignment_stack;
  942.     SymbolSet *definite_visible_variables;
  943.  
  944.     bool IsIntValueRepresentableInType(AstExpression *, TypeSymbol *);
  945.  
  946.     void CheckClassMembers(TypeSymbol *, AstClassBody *);
  947.     void CheckNestedTypeDuplication(SemanticEnvironment *, LexStream::TokenIndex);
  948.     TypeSymbol *ProcessNestedClassName(TypeSymbol *, AstClassDeclaration *);
  949.     void CheckInterfaceMembers(TypeSymbol *, AstInterfaceDeclaration *);
  950.     TypeSymbol *ProcessNestedInterfaceName(TypeSymbol *, AstInterfaceDeclaration *);
  951.     TypeSymbol *FindTypeInShadow(TypeShadowSymbol *, LexStream::TokenIndex);
  952.     void ReportTypeInaccessible(LexStream::TokenIndex, LexStream::TokenIndex, TypeSymbol *);
  953.     void ReportTypeInaccessible(Ast *ast, TypeSymbol *type) { ReportTypeInaccessible(ast -> LeftToken(), ast -> RightToken(), type); }
  954.     TypeSymbol *GetBadNestedType(TypeSymbol *, LexStream::TokenIndex);
  955.     TypeSymbol *FindNestedType(TypeSymbol *, LexStream::TokenIndex);
  956.     TypeSymbol *MustFindNestedType(TypeSymbol *, Ast *);
  957.     void ProcessImportQualifiedName(AstExpression *);
  958.     void ProcessPackageOrType(AstExpression *);
  959.     void ProcessTypeImportOnDemandDeclaration(AstImportDeclaration *);
  960.     AstExpression *FindFirstType(Ast *);
  961.     TypeSymbol *FindSimpleNameType(PackageSymbol *, LexStream::TokenIndex);
  962.     void ProcessSingleTypeImportDeclaration(AstImportDeclaration *);
  963.     AccessFlags ProcessClassModifiers(AstClassDeclaration *);
  964.     AccessFlags ProcessLocalClassModifiers(AstClassDeclaration *);
  965.     AccessFlags ProcessNestedClassModifiers(AstClassDeclaration *);
  966.     AccessFlags ProcessStaticNestedClassModifiers(AstClassDeclaration *);
  967.     AccessFlags ProcessInterfaceModifiers(AstInterfaceDeclaration *);
  968.     AccessFlags ProcessNestedInterfaceModifiers(AstInterfaceDeclaration *);
  969.     AccessFlags ProcessStaticNestedInterfaceModifiers(AstInterfaceDeclaration *);
  970.     AccessFlags ProcessFieldModifiers(AstFieldDeclaration *);
  971.     AccessFlags ProcessLocalModifiers(AstLocalVariableDeclarationStatement *);
  972.     AccessFlags ProcessFormalModifiers(AstFormalParameter *);
  973.     AccessFlags ProcessMethodModifiers(AstMethodDeclaration *);
  974.     AccessFlags ProcessConstructorModifiers(AstConstructorDeclaration *);
  975.     AccessFlags ProcessConstantModifiers(AstFieldDeclaration *);
  976.     AccessFlags ProcessInterfaceMethodModifiers(AstMethodDeclaration *);
  977.     void AddDefaultConstructor(TypeSymbol *);
  978.     void ProcessConstructorDeclaration(AstConstructorDeclaration *);
  979.     void ProcessMethodDeclaration(AstMethodDeclaration *);
  980.     void ProcessFieldDeclaration(AstFieldDeclaration *);
  981.     void ProcessFormalParameters(BlockSymbol *, AstMethodDeclarator *);
  982.     TypeSymbol *ImportType(LexStream::TokenIndex, NameSymbol *);
  983.     TypeSymbol *FindPrimitiveType(AstPrimitiveType *);
  984.     TypeSymbol *FindTypeInEnvironment(SemanticEnvironment *, NameSymbol *);
  985.     TypeSymbol *FindType(LexStream::TokenIndex);
  986.     TypeSymbol *MustFindType(Ast *);
  987.     void ProcessInterface(TypeSymbol *, AstExpression *);
  988.  
  989.     void InitializeVariable(AstFieldDeclaration *, Tuple<VariableSymbol *> &);
  990.     void ProcessInitializer(AstBlock *, AstBlock *, MethodSymbol *, Tuple<VariableSymbol *> &);
  991.     bool NeedsInitializationMethod(AstFieldDeclaration *);
  992.     void ProcessStaticInitializers(AstClassBody *);
  993.     void ProcessBlockInitializers(AstClassBody *);
  994.  
  995.     bool CanWideningPrimitiveConvert(TypeSymbol *, TypeSymbol *);
  996.     bool CanNarrowingPrimitiveConvert(TypeSymbol *, TypeSymbol *);
  997.     bool CanCastConvert(TypeSymbol *, TypeSymbol *, LexStream::TokenIndex);
  998.     bool CanMethodInvocationConvert(TypeSymbol *, TypeSymbol *);
  999.     bool CanAssignmentConvert(TypeSymbol *, AstExpression *);
  1000.     bool CanAssignmentConvertReference(TypeSymbol *, TypeSymbol *);
  1001.     LiteralValue *CastPrimitiveValue(TypeSymbol *, AstExpression *);
  1002.     LiteralValue *CastValue(TypeSymbol *, AstExpression *);
  1003.     AstExpression *ConvertToType(AstExpression *, TypeSymbol *);
  1004.     AstExpression *PromoteUnaryNumericExpression(AstExpression *);
  1005.     void BinaryNumericPromotion(AstAssignmentExpression *);
  1006.     void BinaryNumericPromotion(AstBinaryExpression *);
  1007.     void BinaryNumericPromotion(AstConditionalExpression *);
  1008.  
  1009.     void (Semantic::*DefiniteStmt[Ast::_num_kinds])(Ast *);
  1010.     inline void DefiniteStatement(Ast *);
  1011.  
  1012.     void DefiniteLoopBody(AstStatement *);
  1013.  
  1014.     void DefiniteBlock(Ast *);
  1015.     void DefiniteLocalVariableDeclarationStatement(Ast *);
  1016.     void DefiniteExpressionStatement(Ast *);
  1017.     void DefiniteSynchronizedStatement(Ast *);
  1018.     void DefiniteIfStatement(Ast *);
  1019.     void DefiniteWhileStatement(Ast *);
  1020.     void DefiniteForStatement(Ast *);
  1021.     void DefiniteSwitchStatement(Ast *);
  1022.     void DefiniteDoStatement(Ast *);
  1023.     void DefiniteBreakStatement(Ast *);
  1024.     void DefiniteContinueStatement(Ast *);
  1025.     void DefiniteReturnStatement(Ast *);
  1026.     void DefiniteThrowStatement(Ast *);
  1027.     void DefiniteTryStatement(Ast *);
  1028.     void DefiniteEmptyStatement(Ast *);
  1029.     void DefiniteClassDeclaration(Ast *);
  1030.  
  1031.     VariableSymbol *DefiniteFinal(AstFieldAccess *);
  1032.  
  1033.     DefiniteAssignmentSet *(Semantic::*DefiniteExpr[Ast::_num_expression_kinds])(AstExpression *, BitSet &);
  1034.     DefiniteAssignmentSet *DefiniteSimpleName(AstExpression *, BitSet &);
  1035.     DefiniteAssignmentSet *DefiniteArrayAccess(AstExpression *, BitSet &);
  1036.     DefiniteAssignmentSet *DefiniteMethodInvocation(AstExpression *, BitSet &);
  1037.     DefiniteAssignmentSet *DefiniteClassInstanceCreationExpression(AstExpression *, BitSet &);
  1038.     DefiniteAssignmentSet *DefiniteArrayCreationExpression(AstExpression *, BitSet &);
  1039.     DefiniteAssignmentSet *DefinitePreUnaryExpression(AstExpression *, BitSet &);
  1040.     DefiniteAssignmentSet *DefinitePostUnaryExpression(AstExpression *, BitSet &);
  1041.     DefiniteAssignmentSet *DefiniteBinaryExpression(AstExpression *, BitSet &);
  1042.     DefiniteAssignmentSet *DefiniteConditionalExpression(AstExpression *, BitSet &);
  1043.     DefiniteAssignmentSet *DefiniteAssignmentExpression(AstExpression *, BitSet &);
  1044.     DefiniteAssignmentSet *DefiniteDefaultExpression(AstExpression *, BitSet &);
  1045.     DefiniteAssignmentSet *DefiniteFieldAccess(AstExpression *, BitSet &);
  1046.     DefiniteAssignmentSet *DefiniteParenthesizedExpression(AstExpression *, BitSet &);
  1047.     DefiniteAssignmentSet *DefiniteCastExpression(AstExpression *, BitSet &);
  1048.     DefiniteAssignmentSet *DefiniteExpression(AstExpression *, BitSet &);
  1049.  
  1050.     DefiniteAssignmentSet *(Semantic::*DefinitePreUnaryExpr[AstPreUnaryExpression::_num_kinds])(AstExpression *, BitSet &);
  1051.     DefiniteAssignmentSet *DefiniteDefaultPreUnaryExpression(AstExpression *, BitSet &);
  1052.     DefiniteAssignmentSet *DefiniteNOT(AstExpression *, BitSet &);
  1053.     DefiniteAssignmentSet *DefinitePLUSPLUSOrMINUSMINUS(AstExpression *, BitSet &);
  1054.  
  1055.     DefiniteAssignmentSet *(Semantic::*DefiniteBinaryExpr[AstBinaryExpression::_num_kinds])(AstBinaryExpression *, BitSet &);
  1056.     DefiniteAssignmentSet *DefiniteDefaultBinaryExpression(AstBinaryExpression *, BitSet &);
  1057.     DefiniteAssignmentSet *DefiniteAND(AstBinaryExpression *, BitSet &);
  1058.     DefiniteAssignmentSet *DefiniteIOR(AstBinaryExpression *, BitSet &);
  1059.     DefiniteAssignmentSet *DefiniteXOR(AstBinaryExpression *, BitSet &);
  1060.     DefiniteAssignmentSet *DefiniteAND_AND(AstBinaryExpression *, BitSet &);
  1061.     DefiniteAssignmentSet *DefiniteOR_OR(AstBinaryExpression *, BitSet &);
  1062.     DefiniteAssignmentSet *DefiniteEQUAL_EQUAL(AstBinaryExpression *, BitSet &);
  1063.     DefiniteAssignmentSet *DefiniteNOT_EQUAL(AstBinaryExpression *, BitSet &);
  1064.  
  1065.     DefiniteAssignmentSet *DefiniteAssignmentAND(TypeSymbol *, BitSet *, BitSet &, DefiniteAssignmentSet *, DefiniteAssignmentSet *);
  1066.     DefiniteAssignmentSet *DefiniteAssignmentIOR(TypeSymbol *, BitSet *, BitSet &, DefiniteAssignmentSet *, DefiniteAssignmentSet *);
  1067.     DefiniteAssignmentSet *DefiniteAssignmentXOR(TypeSymbol *, BitSet *, BitSet &, DefiniteAssignmentSet *, DefiniteAssignmentSet *);
  1068.  
  1069.     void DefiniteArrayInitializer(AstArrayInitializer *);
  1070.     void DefiniteVariableInitializer(AstVariableDeclarator *);
  1071.     void DefiniteBlockStatements(AstBlock *);
  1072.     void DefiniteMethodBody(AstMethodDeclaration *, Tuple<VariableSymbol *> &);
  1073.     void DefiniteConstructorBody(AstConstructorDeclaration *, Tuple<VariableSymbol *> &);
  1074.     void DefiniteBlockInitializer(AstBlock *, int, Tuple<VariableSymbol *> &);
  1075.     void DefiniteVariableInitializer(AstVariableDeclarator *, Tuple<VariableSymbol *> &);
  1076.  
  1077.     void ProcessBlockStatements(AstBlock *);
  1078.     void ProcessThisCall(AstThisCall *);
  1079.     void ProcessSuperCall(AstSuperCall *);
  1080.     void CheckThrow(AstExpression *);
  1081.     void ProcessMethodBody(AstMethodDeclaration *);
  1082.     void ProcessConstructorBody(AstConstructorDeclaration *, bool);
  1083.     bool CatchableException(TypeSymbol *);
  1084.     void ReportMethodNotFound(Ast *ast, wchar_t *);
  1085.     MethodSymbol *FindConstructor(TypeSymbol *, Ast *, LexStream::TokenIndex, LexStream::TokenIndex);
  1086.     bool MoreSpecific(MethodSymbol *, MethodSymbol *);
  1087.     bool MoreSpecific(MethodSymbol *, Tuple<MethodSymbol *> &);
  1088.     bool NoMethodMoreSpecific(Tuple<MethodSymbol *> &, MethodSymbol *);
  1089.     bool IsMethodAccessible(AstFieldAccess *, TypeSymbol *, MethodSymbol *);
  1090.     void SearchForMethodInEnvironment(Tuple<MethodSymbol *> &, SemanticEnvironment *&, SemanticEnvironment *, AstMethodInvocation *);
  1091.     MethodSymbol *FindMisspelledMethodName(TypeSymbol *, AstMethodInvocation *, NameSymbol *);
  1092.     MethodSymbol *FindMethodInEnvironment(SemanticEnvironment *&, SemanticEnvironment *, AstMethodInvocation *);
  1093.     MethodSymbol *FindMethodInType(TypeSymbol *, AstMethodInvocation *, NameSymbol * = NULL);
  1094.  
  1095.     void ReportAccessedFieldNotFound(AstFieldAccess *, TypeSymbol *);
  1096.     void SearchForVariableInEnvironment(Tuple<VariableSymbol *> &, SemanticEnvironment *&,
  1097.                                         SemanticEnvironment *, NameSymbol *, LexStream::TokenIndex);
  1098.     VariableSymbol *FindMisspelledVariableName(TypeSymbol *, LexStream::TokenIndex);
  1099.     VariableSymbol *FindVariableInEnvironment(SemanticEnvironment *&, SemanticEnvironment *, LexStream::TokenIndex);
  1100.     VariableSymbol *FindVariableInType(TypeSymbol *, AstFieldAccess *, NameSymbol * = NULL);
  1101.     VariableSymbol *FindInstance(TypeSymbol *, TypeSymbol *);
  1102.     AstExpression *CreateAccessToType(Ast *, TypeSymbol *);
  1103.     void CreateAccessToScopedVariable(AstSimpleName *, TypeSymbol *);
  1104.     void CreateAccessToScopedMethod(AstMethodInvocation *, TypeSymbol *);
  1105.  
  1106.     void TypeAccessCheck(Ast *, TypeSymbol *);
  1107.     void TypeNestAccessCheck(AstExpression *);
  1108.     void ConstructorAccessCheck(AstClassInstanceCreationExpression *, MethodSymbol *);
  1109.     void MemberAccessCheck(AstFieldAccess *, TypeSymbol *, Symbol *);
  1110.     void SimpleNameAccessCheck(AstSimpleName *, TypeSymbol *, Symbol *);
  1111.  
  1112.     void (Semantic::*ProcessPreUnaryExpr[AstPreUnaryExpression::_num_kinds])(AstPreUnaryExpression *);
  1113.     void ProcessPLUS(AstPreUnaryExpression *);
  1114.     void ProcessMINUS(AstPreUnaryExpression *);
  1115.     void ProcessTWIDDLE(AstPreUnaryExpression *);
  1116.     void ProcessNOT(AstPreUnaryExpression *);
  1117.     void ProcessPLUSPLUSOrMINUSMINUS(AstPreUnaryExpression *);
  1118.  
  1119.     void (Semantic::*ProcessBinaryExpr[AstBinaryExpression::_num_kinds])(AstBinaryExpression *);
  1120.     void ProcessPLUS(AstBinaryExpression *);
  1121.     void ProcessLEFT_SHIFT(AstBinaryExpression *);
  1122.     void ProcessRIGHT_SHIFT(AstBinaryExpression *);
  1123.     void ProcessUNSIGNED_RIGHT_SHIFT(AstBinaryExpression *);
  1124.     void ProcessLESS(AstBinaryExpression *);
  1125.     void ProcessGREATER(AstBinaryExpression *);
  1126.     void ProcessLESS_EQUAL(AstBinaryExpression *);
  1127.     void ProcessGREATER_EQUAL(AstBinaryExpression *);
  1128.     void ProcessAND(AstBinaryExpression *);
  1129.     void ProcessXOR(AstBinaryExpression *);
  1130.     void ProcessIOR(AstBinaryExpression *);
  1131.     void ProcessAND_AND(AstBinaryExpression *);
  1132.     void ProcessOR_OR(AstBinaryExpression *);
  1133.     void ProcessEQUAL_EQUAL(AstBinaryExpression *);
  1134.     void ProcessNOT_EQUAL(AstBinaryExpression *);
  1135.     void ProcessSTAR(AstBinaryExpression *);
  1136.     void ProcessMINUS(AstBinaryExpression *);
  1137.     void ProcessSLASH(AstBinaryExpression *);
  1138.     void ProcessMOD(AstBinaryExpression *);
  1139.     void ProcessINSTANCEOF(AstBinaryExpression *);
  1140.  
  1141.     MethodSymbol *FindMethodMember(TypeSymbol *, TypeSymbol *, AstMethodInvocation *);
  1142.     void ProcessMethodName(AstMethodInvocation *);
  1143.     void (Semantic::*ProcessExprOrStmt[Ast::_num_kinds])(Ast *);
  1144.     inline void ProcessStatement(AstStatement *stmt)
  1145.     {
  1146.         (this ->* ProcessExprOrStmt[stmt -> kind])(stmt);
  1147.     }
  1148.  
  1149.     inline void ProcessExpression(AstExpression *expr)
  1150.     {
  1151.         (this ->* ProcessExprOrStmt[expr -> kind])(expr);
  1152.     }
  1153.  
  1154.     inline void ProcessExpressionOrStringConstant(AstExpression *expr)
  1155.     {
  1156.         (this ->* ProcessExprOrStmt[expr -> kind])(expr);
  1157.         //
  1158.         // If the expression is of type String, check whether or not it is
  1159.         // constant, and if so, compute the result.
  1160.         //
  1161.         if (expr -> symbol == control.String() && (! expr -> IsConstant()))
  1162.             control.Utf8_pool.CheckStringConstant(expr);
  1163.  
  1164.         return;
  1165.     }
  1166.  
  1167.     void ProcessLocalVariableDeclarationStatement(Ast *);
  1168.     void ProcessBlock(Ast *);
  1169.     void ProcessForStatement(Ast *);
  1170.     void ProcessSwitchStatement(Ast *);
  1171.     void ProcessThrowStatement(Ast *);
  1172.     void ProcessTryStatement(Ast *);
  1173.     void ProcessExpressionStatement(Ast *);
  1174.     void ProcessSynchronizedStatement(Ast *);
  1175.     void ProcessIfStatement(Ast *);
  1176.     void ProcessWhileStatement(Ast *);
  1177.     void ProcessDoStatement(Ast *);
  1178.     void ProcessBreakStatement(Ast *);
  1179.     void ProcessContinueStatement(Ast *);
  1180.     void ProcessReturnStatement(Ast *);
  1181.     void ProcessEmptyStatement(Ast *);
  1182.     TypeSymbol *GetLocalType(AstClassDeclaration *);
  1183.     void ProcessClassDeclaration(Ast *);
  1184.     void GenerateLocalConstructor(MethodSymbol *);
  1185.  
  1186.     void CheckSimpleName(AstSimpleName *, SemanticEnvironment *where_found);
  1187.     void ProcessSimpleName(Ast *);
  1188.     void FindVariableMember(TypeSymbol *, TypeSymbol *, AstFieldAccess *);
  1189.     void ProcessAmbiguousName(Ast *);
  1190.     void ProcessFieldAccess(Ast *);
  1191.     void ProcessIntegerLiteral(Ast *);
  1192.     void ProcessLongLiteral(Ast *);
  1193.     void ProcessFloatingPointLiteral(Ast *);
  1194.     void ProcessDoubleLiteral(Ast *);
  1195.     void ProcessTrueLiteral(Ast *);
  1196.     void ProcessFalseLiteral(Ast *);
  1197.     void ProcessStringLiteral(Ast *);
  1198.     void ProcessCharacterLiteral(Ast *);
  1199.     void ProcessArrayAccess(Ast *);
  1200.     void ProcessMethodInvocation(Ast *);
  1201.     void ProcessNullLiteral(Ast *);
  1202.     void ProcessThisExpression(Ast *);
  1203.     void ProcessSuperExpression(Ast *);
  1204.     void ProcessParenthesizedExpression(Ast *);
  1205.     void UpdateGeneratedLocalConstructor(MethodSymbol *);
  1206.     void UpdateLocalConstructors(TypeSymbol *);
  1207.     void GetAnonymousConstructor(AstClassInstanceCreationExpression *, TypeSymbol *);
  1208.     TypeSymbol *GetAnonymousType(AstClassInstanceCreationExpression *, TypeSymbol *);
  1209.     void ProcessClassInstanceCreationExpression(Ast *);
  1210.     void ProcessArrayCreationExpression(Ast *);
  1211.     void ProcessPostUnaryExpression(Ast *);
  1212.     void ProcessPreUnaryExpression(Ast *);
  1213.     void ProcessCastExpression(Ast *);
  1214.     void ProcessBinaryExpression(Ast *);
  1215.     void ProcessTypeExpression(Ast *);
  1216.     void ProcessConditionalExpression(Ast *);
  1217.     void ProcessAssignmentExpression(Ast *);
  1218.  
  1219.     void ProcessVariableInitializer(AstVariableDeclarator *);
  1220.     void ProcessArrayInitializer(AstArrayInitializer *, TypeSymbol *);
  1221.  
  1222.     void CheckInheritedMethodThrows(AstMethodDeclaration *, MethodSymbol *);
  1223.     void CheckMethodOverride(AstMethodDeclaration *, MethodSymbol *);
  1224.     void CheckInheritedMethodThrows(AstClassDeclaration *, MethodSymbol *, MethodSymbol *);
  1225.     void CheckMethodOverride(AstClassDeclaration *, MethodSymbol *, MethodSymbol *);
  1226.     void AddInheritedTypes(TypeSymbol *, TypeSymbol *);
  1227.     void AddInheritedFields(TypeSymbol *, TypeSymbol *);
  1228.     void AddInheritedMethods(TypeSymbol *, TypeSymbol *, LexStream::TokenIndex);
  1229.     void ComputeTypesClosure(TypeSymbol *, LexStream::TokenIndex);
  1230.     void ComputeFieldsClosure(TypeSymbol *, LexStream::TokenIndex);
  1231.     void ComputeMethodsClosure(TypeSymbol *, LexStream::TokenIndex);
  1232.  
  1233.     inline bool InRange(const char *buffer_ptr, const char *buffer_tail, int size) { return ((buffer_ptr + size) <= buffer_tail); }
  1234.     TypeSymbol *RetrieveNestedTypes(TypeSymbol *, wchar_t *, LexStream::TokenIndex);
  1235.     TypeSymbol *GetClassPool(TypeSymbol *, TypeSymbol **, const char **, int, LexStream::TokenIndex);
  1236.     void ProcessBadClass(TypeSymbol *, LexStream::TokenIndex);
  1237.     bool ProcessClassFile(TypeSymbol *, const char *, int, LexStream::TokenIndex);
  1238.     void ReadClassFile(TypeSymbol *, LexStream::TokenIndex);
  1239.  
  1240.     //
  1241.     // Any exception that is neither RuntimeException or one of its subclasses nor
  1242.     // Error or one of its subclasses is a checked exception.
  1243.     //
  1244.     inline bool CheckedException(TypeSymbol *exception)
  1245.     {
  1246.         return (! (exception -> IsSubclass(control.RuntimeException()) || exception -> IsSubclass(control.Error())));
  1247.     }
  1248.  
  1249. public:
  1250.  
  1251.     static inline u1 GetU1(const char *);
  1252.     static inline u2 GetU2(const char *);
  1253.     static inline u4 GetU4(const char *);
  1254.  
  1255.     static inline u1 GetAndSkipU1(const char *&);
  1256.     static inline u2 GetAndSkipU2(const char *&);
  1257.     static inline u4 GetAndSkipU4(const char *&);
  1258.     static inline void Skip(const char *&, int);
  1259.  
  1260.     inline void AddDependence(TypeSymbol *, TypeSymbol *, LexStream::TokenIndex, bool = false);
  1261.     inline void SetObjectSuperType(TypeSymbol *, LexStream::TokenIndex);
  1262.     inline void AddStringConversionDependence(TypeSymbol *, LexStream::TokenIndex);
  1263. };
  1264.  
  1265.  
  1266. inline void Semantic::AddDependence(TypeSymbol *base_type_, TypeSymbol *parent_type_, LexStream::TokenIndex tok, bool static_access)
  1267. {
  1268.     if (base_type_ != control.no_type)
  1269.     {
  1270.         TypeSymbol *base_type = base_type_ -> outermost_type,
  1271.                    *parent_type = parent_type_ -> outermost_type;
  1272.  
  1273.         parent_type -> dependents -> AddElement(base_type);
  1274.         if (static_access)
  1275.              base_type -> static_parents -> AddElement(parent_type);
  1276.         else base_type -> parents -> AddElement(parent_type);
  1277.  
  1278.         if (control.option.pedantic)
  1279.         {
  1280.             if (parent_type -> ContainingPackage() == control.unnamed_package &&
  1281.                 base_type -> ContainingPackage() != control.unnamed_package)
  1282.             {
  1283.                 error -> Report(SemanticError::PARENT_TYPE_IN_UNNAMED_PACKAGE,
  1284.                                 tok,
  1285.                                 tok,
  1286.                                 parent_type_ -> ContainingPackage() -> PackageName(),
  1287.                                 parent_type_ -> ExternalName());
  1288.             }
  1289.         }
  1290.     }
  1291.  
  1292.     return;
  1293. }
  1294.  
  1295. inline void Semantic::SetObjectSuperType(TypeSymbol *type, LexStream::TokenIndex tok)
  1296. {
  1297.     type -> super = control.Object();
  1298.     AddDependence(type, type -> super, tok);
  1299. }
  1300.  
  1301. inline void Semantic::AddStringConversionDependence(TypeSymbol *type, LexStream::TokenIndex tok)
  1302. {
  1303.     if (type == control.null_type)
  1304.          ;
  1305.     else if (type == control.boolean_type)
  1306.          AddDependence(ThisType(), control.Boolean(), tok);
  1307.     else if (type == control.char_type)
  1308.          AddDependence(ThisType(), control.Character(), tok);
  1309.     else if (type == control.int_type)
  1310.          AddDependence(ThisType(), control.Integer(), tok);
  1311.     else if (type == control.long_type)
  1312.          AddDependence(ThisType(), control.Long(), tok);
  1313.     else if (type == control.float_type)
  1314.          AddDependence(ThisType(), control.Float(), tok);
  1315.     else // (type == control.double_type)
  1316.          AddDependence(ThisType(), control.Double(), tok);
  1317. }
  1318.  
  1319. #ifdef    HAVE_JIKES_NAMESPACE
  1320. }            // Close namespace Jikes block
  1321. #endif
  1322.  
  1323. #endif
  1324.  
  1325.