home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 20 / AACD20.BIN / AACD / Programming / Jikes / Source / src / modifier.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  2001-02-24  |  44.1 KB  |  1,100 lines
  1. // $Id: modifier.cpp,v 1.14 2001/01/10 16:49:45 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.  
  11. #include "platform.h"
  12. #include "semantic.h"
  13.  
  14. #ifdef    HAVE_JIKES_NAMESPACE
  15. namespace Jikes {    // Open namespace Jikes block
  16. #endif
  17.  
  18. AccessFlags Semantic::ProcessClassModifiers(AstClassDeclaration *class_declaration)
  19. {
  20.     AccessFlags access_flags;
  21.  
  22.     for (int i = 0; i < class_declaration -> NumClassModifiers(); i++)
  23.     {
  24.         AstModifier *modifier = class_declaration -> ClassModifier(i);
  25.  
  26.         switch(modifier -> kind)
  27.         {
  28.             case Ast::ABSTRACT:
  29.                  if (access_flags.ACC_ABSTRACT())
  30.                  {
  31.                      ReportSemError(SemanticError::DUPLICATE_MODIFIER,
  32.                                     modifier -> modifier_kind_token,
  33.                                     modifier -> modifier_kind_token);
  34.                  }
  35.                  else access_flags.SetACC_ABSTRACT();
  36.  
  37.                  if (access_flags.ACC_FINAL())
  38.                  {
  39.                      ReportSemError(SemanticError::FINAL_ABSTRACT_CLASS,
  40.                                     modifier -> modifier_kind_token,
  41.                                     modifier -> modifier_kind_token);
  42.                  }
  43.                  break;
  44.             case Ast::FINAL:
  45.                  if (access_flags.ACC_FINAL())
  46.                  {
  47.                      ReportSemError(SemanticError::DUPLICATE_MODIFIER,
  48.                                     modifier -> modifier_kind_token,
  49.                                     modifier -> modifier_kind_token);
  50.                  }
  51.                  else access_flags.SetACC_FINAL();
  52.  
  53.                  if (access_flags.ACC_ABSTRACT())
  54.                  {
  55.                      ReportSemError(SemanticError::FINAL_ABSTRACT_CLASS,
  56.                                     modifier -> modifier_kind_token,
  57.                                     modifier -> modifier_kind_token);
  58.                  }
  59.                  break;
  60.             case Ast::PUBLIC:
  61.                  if (access_flags.ACC_PUBLIC())
  62.                  {
  63.                      ReportSemError(SemanticError::DUPLICATE_MODIFIER,
  64.                                     modifier -> modifier_kind_token,
  65.                                     modifier -> modifier_kind_token);
  66.                  }
  67.                  else access_flags.SetACC_PUBLIC();
  68.                  break;
  69.             case Ast::STRICTFP:
  70.                  if (access_flags.ACC_STRICTFP())
  71.                  {
  72.                      ReportSemError(SemanticError::DUPLICATE_MODIFIER,
  73.                                     modifier -> modifier_kind_token,
  74.                                     modifier -> modifier_kind_token);
  75.                  }
  76.                  else access_flags.SetACC_STRICTFP();
  77.                  break;
  78.             default:
  79.                  ReportSemError(SemanticError::INVALID_TOP_LEVEL_CLASS_MODIFIER,
  80.                                 modifier -> modifier_kind_token,
  81.                                 modifier -> modifier_kind_token,
  82.                                 lex_stream -> NameString(modifier -> modifier_kind_token));
  83.                  break;
  84.         }
  85.     }
  86.  
  87.     return access_flags;
  88. }
  89.  
  90.  
  91. AccessFlags Semantic::ProcessLocalClassModifiers(AstClassDeclaration *class_declaration)
  92. {
  93.     AccessFlags access_flags;
  94.  
  95.     for (int i = 0; i < class_declaration -> NumClassModifiers(); i++)
  96.     {
  97.         AstModifier *modifier = class_declaration -> ClassModifier(i);
  98.  
  99.         switch(modifier -> kind)
  100.         {
  101.             case Ast::ABSTRACT:
  102.                  if (access_flags.ACC_ABSTRACT())
  103.                  {
  104.                      ReportSemError(SemanticError::DUPLICATE_MODIFIER,
  105.                                     modifier -> modifier_kind_token,
  106.                                     modifier -> modifier_kind_token);
  107.                  }
  108.                  else access_flags.SetACC_ABSTRACT();
  109.  
  110.                  if (access_flags.ACC_FINAL())
  111.                  {
  112.                      ReportSemError(SemanticError::FINAL_ABSTRACT_CLASS,
  113.                                     modifier -> modifier_kind_token,
  114.                                     modifier -> modifier_kind_token);
  115.                  }
  116.                  break;
  117.             case Ast::FINAL:
  118.                  if (access_flags.ACC_FINAL())
  119.                  {
  120.                      ReportSemError(SemanticError::DUPLICATE_MODIFIER,
  121.                                     modifier -> modifier_kind_token,
  122.                                     modifier -> modifier_kind_token);
  123.                  }
  124.                  else access_flags.SetACC_FINAL();
  125.  
  126.                  if (access_flags.ACC_ABSTRACT())
  127.                  {
  128.                      ReportSemError(SemanticError::FINAL_ABSTRACT_CLASS,
  129.                                     modifier -> modifier_kind_token,
  130.                                     modifier -> modifier_kind_token);
  131.                  }
  132.                  break;
  133.             case Ast::STRICTFP:
  134.                  if (access_flags.ACC_STRICTFP())
  135.                  {
  136.                      ReportSemError(SemanticError::DUPLICATE_MODIFIER,
  137.                                     modifier -> modifier_kind_token,
  138.                                     modifier -> modifier_kind_token);
  139.                  }
  140.                  else access_flags.SetACC_STRICTFP();
  141.                  break;
  142.             default:
  143.                  ReportSemError(SemanticError::INVALID_LOCAL_CLASS_MODIFIER,
  144.                                 modifier -> modifier_kind_token,
  145.                                 modifier -> modifier_kind_token,
  146.                                 lex_stream -> NameString(modifier -> modifier_kind_token));
  147.                  break;
  148.         }
  149.     }
  150.  
  151.     return access_flags;
  152. }
  153.  
  154.  
  155. AccessFlags Semantic::ProcessNestedClassModifiers(AstClassDeclaration *class_declaration)
  156. {
  157.     AccessFlags access_flags;
  158.  
  159.     for (int i = 0; i < class_declaration -> NumClassModifiers(); i++)
  160.     {
  161.         AstModifier *modifier = class_declaration -> ClassModifier(i);
  162.  
  163.         switch(modifier -> kind)
  164.         {
  165.             case Ast::ABSTRACT:
  166.                  if (access_flags.ACC_ABSTRACT())
  167.                  {
  168.                      ReportSemError(SemanticError::DUPLICATE_MODIFIER,
  169.                                     modifier -> modifier_kind_token,
  170.                                     modifier -> modifier_kind_token);
  171.                  }
  172.                  else access_flags.SetACC_ABSTRACT();
  173.  
  174.                  if (access_flags.ACC_FINAL())
  175.                  {
  176.                      ReportSemError(SemanticError::FINAL_ABSTRACT_CLASS,
  177.                                     modifier -> modifier_kind_token,
  178.                                     modifier -> modifier_kind_token);
  179.                  }
  180.                  break;
  181.             case Ast::FINAL:
  182.                  if (access_flags.ACC_FINAL())
  183.                  {
  184.                      ReportSemError(SemanticError::DUPLICATE_MODIFIER,
  185.                                     modifier -> modifier_kind_token,
  186.                                     modifier -> modifier_kind_token);
  187.                  }
  188.                  else access_flags.SetACC_FINAL();
  189.  
  190.                  if (access_flags.ACC_ABSTRACT())
  191.                  {
  192.                      ReportSemError(SemanticError::FINAL_ABSTRACT_CLASS,
  193.                                     modifier -> modifier_kind_token,
  194.                                     modifier -> modifier_kind_token);
  195.                  }
  196.                  break;
  197.             case Ast::PUBLIC:
  198.                  if (access_flags.ACC_PUBLIC() || access_flags.ACC_PROTECTED() || access_flags.ACC_PRIVATE())
  199.                  {
  200.                      ReportSemError(SemanticError::DUPLICATE_ACCESS_MODIFIER,
  201.                                     modifier -> modifier_kind_token,
  202.                                     modifier -> modifier_kind_token);
  203.                  }
  204.                  else access_flags.SetACC_PUBLIC();
  205.                  break;
  206.             case Ast::PRIVATE:
  207.                  if (access_flags.ACC_PUBLIC() || access_flags.ACC_PROTECTED() || access_flags.ACC_PRIVATE())
  208.                  {
  209.                      ReportSemError(SemanticError::DUPLICATE_ACCESS_MODIFIER,
  210.                                     modifier -> modifier_kind_token,
  211.                                     modifier -> modifier_kind_token);
  212.                  }
  213.                  else access_flags.SetACC_PRIVATE();
  214.                  break;
  215.             case Ast::PROTECTED:
  216.                  if (access_flags.ACC_PUBLIC() || access_flags.ACC_PROTECTED() || access_flags.ACC_PRIVATE())
  217.                  {
  218.                      ReportSemError(SemanticError::DUPLICATE_ACCESS_MODIFIER,
  219.                                     modifier -> modifier_kind_token,
  220.                                     modifier -> modifier_kind_token);
  221.                  }
  222.                  else access_flags.SetACC_PROTECTED();
  223.                  break;
  224.             case Ast::STATIC:
  225.                  if (access_flags.ACC_STATIC())
  226.                  {
  227.                      ReportSemError(SemanticError::DUPLICATE_MODIFIER,
  228.                                     modifier -> modifier_kind_token,
  229.                                     modifier -> modifier_kind_token);
  230.                  }
  231.                  else access_flags.SetACC_STATIC();
  232.                  break;
  233.             case Ast::STRICTFP:
  234.                  if (access_flags.ACC_STRICTFP())
  235.                  {
  236.                      ReportSemError(SemanticError::DUPLICATE_MODIFIER,
  237.                                     modifier -> modifier_kind_token,
  238.                                     modifier -> modifier_kind_token);
  239.                  }
  240.                  else access_flags.SetACC_STRICTFP();
  241.                  break;
  242.             default:
  243.                  ReportSemError(SemanticError::INVALID_INNER_CLASS_MODIFIER,
  244.                                 modifier -> modifier_kind_token,
  245.                                 modifier -> modifier_kind_token,
  246.                                 lex_stream -> NameString(modifier -> modifier_kind_token));
  247.                  break;
  248.         }
  249.     }
  250.  
  251.     return access_flags;
  252. }
  253.  
  254.  
  255. AccessFlags Semantic::ProcessStaticNestedClassModifiers(AstClassDeclaration *class_declaration)
  256. {
  257.     AccessFlags access_flags;
  258.  
  259.     for (int i = 0; i < class_declaration -> NumClassModifiers(); i++)
  260.     {
  261.         AstModifier *modifier = class_declaration -> ClassModifier(i);
  262.  
  263.         switch(modifier -> kind)
  264.         {
  265.             case Ast::ABSTRACT:
  266.                  if (access_flags.ACC_ABSTRACT())
  267.                  {
  268.                      ReportSemError(SemanticError::DUPLICATE_MODIFIER,
  269.                                     modifier -> modifier_kind_token,
  270.                                     modifier -> modifier_kind_token);
  271.                  }
  272.                  else access_flags.SetACC_ABSTRACT();
  273.  
  274.                  if (access_flags.ACC_FINAL())
  275.                  {
  276.                      ReportSemError(SemanticError::FINAL_ABSTRACT_CLASS,
  277.                                     modifier -> modifier_kind_token,
  278.                                     modifier -> modifier_kind_token);
  279.                  }
  280.                  break;
  281.             case Ast::FINAL:
  282.                  if (access_flags.ACC_FINAL())
  283.                  {
  284.                      ReportSemError(SemanticError::DUPLICATE_MODIFIER,
  285.                                     modifier -> modifier_kind_token,
  286.                                     modifier -> modifier_kind_token);
  287.                  }
  288.                  else access_flags.SetACC_FINAL();
  289.  
  290.                  if (access_flags.ACC_ABSTRACT())
  291.                  {
  292.                      ReportSemError(SemanticError::FINAL_ABSTRACT_CLASS,
  293.                                     modifier -> modifier_kind_token,
  294.                                     modifier -> modifier_kind_token);
  295.                  }
  296.                  break;
  297.             case Ast::PUBLIC:
  298.                  if (access_flags.ACC_PUBLIC() || access_flags.ACC_PROTECTED() || access_flags.ACC_PRIVATE())
  299.                  {
  300.                      ReportSemError(SemanticError::DUPLICATE_ACCESS_MODIFIER,
  301.                                     modifier -> modifier_kind_token,
  302.                                     modifier -> modifier_kind_token);
  303.                  }
  304.                  else
  305.                  {
  306.                      if (control.option.pedantic)
  307.                          ReportSemError(SemanticError::REDUNDANT_PUBLIC,
  308.                                         modifier -> modifier_kind_token,
  309.                                         modifier -> modifier_kind_token);
  310.                      access_flags.SetACC_PUBLIC();
  311.                  }
  312.                  break;
  313.             case Ast::STATIC:
  314.                  if (access_flags.ACC_STATIC())
  315.                  {
  316.                      ReportSemError(SemanticError::DUPLICATE_MODIFIER,
  317.                                     modifier -> modifier_kind_token,
  318.                                     modifier -> modifier_kind_token);
  319.                  }
  320.                  else
  321.                  {
  322.                      if (control.option.pedantic)
  323.                          ReportSemError(SemanticError::REDUNDANT_STATIC,
  324.                                         modifier -> modifier_kind_token,
  325.                                         modifier -> modifier_kind_token);
  326.                      access_flags.SetACC_STATIC();
  327.                  }
  328.                  break;
  329.             case Ast::STRICTFP:
  330.                  if (access_flags.ACC_STRICTFP())
  331.                  {
  332.                      ReportSemError(SemanticError::DUPLICATE_MODIFIER,
  333.                                     modifier -> modifier_kind_token,
  334.                                     modifier -> modifier_kind_token);
  335.                  }
  336.                  else access_flags.SetACC_STRICTFP();
  337.                  break;
  338.             default:
  339.                  ReportSemError(SemanticError::INVALID_INNER_CLASS_MODIFIER,
  340.                                 modifier -> modifier_kind_token,
  341.                                 modifier -> modifier_kind_token,
  342.                                 lex_stream -> NameString(modifier -> modifier_kind_token));
  343.                  break;
  344.         }
  345.     }
  346.  
  347.     //
  348.     // A type that is a member of an interface is implicitly deemed to
  349.     // be static and public, whether it is explicitly marked so or not.
  350.     //
  351.     access_flags.SetACC_STATIC();
  352.     access_flags.SetACC_PUBLIC();
  353.  
  354.     return access_flags;
  355. }
  356.  
  357.  
  358. AccessFlags Semantic::ProcessInterfaceModifiers(AstInterfaceDeclaration *interface_declaration)
  359. {
  360.     AccessFlags access_flags;
  361.  
  362.     for (int i = 0; i < interface_declaration -> NumInterfaceModifiers(); i++)
  363.     {
  364.         AstModifier *modifier = interface_declaration -> InterfaceModifier(i);
  365.  
  366.         switch(modifier -> kind)
  367.         {
  368.             case Ast::ABSTRACT:
  369.                  if (access_flags.ACC_ABSTRACT())
  370.                  {
  371.                      ReportSemError(SemanticError::DUPLICATE_MODIFIER,
  372.                                     modifier -> modifier_kind_token,
  373.                                     modifier -> modifier_kind_token);
  374.                  }
  375.                  else
  376.                  {
  377.                      ReportSemError(SemanticError::OBSOLESCENT_ABSTRACT,
  378.                                     modifier -> modifier_kind_token,
  379.                                     modifier -> modifier_kind_token);
  380.                      access_flags.SetACC_ABSTRACT();
  381.                  }
  382.                  break;
  383.             case Ast::PUBLIC:
  384.                  if (access_flags.ACC_PUBLIC())
  385.                  {
  386.                      ReportSemError(SemanticError::DUPLICATE_MODIFIER,
  387.                                     modifier -> modifier_kind_token,
  388.                                     modifier -> modifier_kind_token);
  389.                  }
  390.                  else access_flags.SetACC_PUBLIC();
  391.                  break;
  392.             case Ast::STRICTFP:
  393.                  if (access_flags.ACC_STRICTFP())
  394.                  {
  395.                      ReportSemError(SemanticError::DUPLICATE_MODIFIER,
  396.                                     modifier -> modifier_kind_token,
  397.                                     modifier -> modifier_kind_token);
  398.                  }
  399.                  else access_flags.SetACC_STRICTFP();
  400.                  break;
  401.             default:
  402.                  ReportSemError(SemanticError::INVALID_INTERFACE_MODIFIER,
  403.                                 modifier -> modifier_kind_token,
  404.                                 modifier -> modifier_kind_token,
  405.                                 lex_stream -> NameString(modifier -> modifier_kind_token));
  406.                  break;
  407.         }
  408.     }
  409.  
  410.     access_flags.SetACC_INTERFACE();
  411.     access_flags.SetACC_ABSTRACT(); // every interface is implicitly abstract
  412.  
  413.     return access_flags;
  414. }
  415.  
  416. /**
  417.  * Process modifieres for interface contained in another interface.
  418.  */
  419. AccessFlags Semantic::ProcessStaticNestedInterfaceModifiers(AstInterfaceDeclaration *interface_declaration)
  420. {
  421.     AccessFlags access_flags;
  422.  
  423.     for (int i = 0; i < interface_declaration -> NumInterfaceModifiers(); i++)
  424.     {
  425.         AstModifier *modifier = interface_declaration -> InterfaceModifier(i);
  426.  
  427.         switch(modifier -> kind)
  428.         {
  429.         case Ast::ABSTRACT:
  430.             if (access_flags.ACC_ABSTRACT())
  431.             {
  432.                 ReportSemError(SemanticError::DUPLICATE_MODIFIER,
  433.                                modifier -> modifier_kind_token,
  434.                                modifier -> modifier_kind_token);
  435.             }
  436.             else
  437.             {
  438.                 ReportSemError(SemanticError::OBSOLESCENT_ABSTRACT,
  439.                                modifier -> modifier_kind_token,
  440.                                modifier -> modifier_kind_token);
  441.             }
  442.             break;
  443.         case Ast::PUBLIC:
  444.             if(access_flags.ACC_PUBLIC())
  445.             {
  446.                 ReportSemError(SemanticError::DUPLICATE_ACCESS_MODIFIER,
  447.                                modifier -> modifier_kind_token,
  448.                                modifier -> modifier_kind_token);
  449.             }
  450.             else 
  451.             {
  452.                 if (control.option.pedantic)
  453.                     ReportSemError(SemanticError::REDUNDANT_PUBLIC,
  454.                                    modifier -> modifier_kind_token,
  455.                                    modifier -> modifier_kind_token);
  456.                 access_flags.SetACC_PUBLIC();
  457.             }
  458.             break;
  459.         case Ast::STATIC: // TODO: Need to confirm that this is valid !!!
  460.             if(access_flags.ACC_STATIC())
  461.             {
  462.                 ReportSemError(SemanticError::DUPLICATE_MODIFIER,
  463.                                modifier -> modifier_kind_token,
  464.                                modifier -> modifier_kind_token);
  465.             }
  466.             else 
  467.             {
  468.                 if(control.option.pedantic)
  469.                     ReportSemError(SemanticError::REDUNDANT_STATIC,
  470.                                    modifier -> modifier_kind_token,
  471.                                    modifier -> modifier_kind_token);
  472.                 access_flags.SetACC_STATIC();
  473.             }
  474.             break;
  475.         case Ast::STRICTFP:
  476.             if (access_flags.ACC_STRICTFP())
  477.             {
  478.                 ReportSemError(SemanticError::DUPLICATE_MODIFIER,
  479.                                modifier -> modifier_kind_token,
  480.                                modifier -> modifier_kind_token);
  481.             }
  482.             else access_flags.SetACC_STRICTFP();
  483.             break;
  484.         default:
  485.             ReportSemError(SemanticError::INVALID_INTERFACE_MODIFIER,
  486.                            modifier -> modifier_kind_token,
  487.                            modifier -> modifier_kind_token,
  488.                            lex_stream -> NameString(modifier -> modifier_kind_token));
  489.             break;
  490.         }
  491.     }
  492.  
  493.     access_flags.SetACC_INTERFACE();
  494.     access_flags.SetACC_ABSTRACT(); // every interface is implicitly abstract
  495.     access_flags.SetACC_STATIC();   // every inner interface is implicitly static
  496.     access_flags.SetACC_PUBLIC();   // interface contained interfaces are implicitly public
  497.  
  498.     return access_flags;
  499. }
  500.  
  501. AccessFlags Semantic::ProcessNestedInterfaceModifiers(AstInterfaceDeclaration *interface_declaration)
  502. {
  503.     AccessFlags access_flags;
  504.  
  505.     for (int i = 0; i < interface_declaration -> NumInterfaceModifiers(); i++)
  506.     {
  507.         AstModifier *modifier = interface_declaration -> InterfaceModifier(i);
  508.  
  509.         switch(modifier -> kind)
  510.         {
  511.         case Ast::ABSTRACT:
  512.             if (access_flags.ACC_ABSTRACT())
  513.             {
  514.                 ReportSemError(SemanticError::DUPLICATE_MODIFIER,
  515.                                modifier -> modifier_kind_token,
  516.                                modifier -> modifier_kind_token);
  517.             }
  518.             else
  519.             {
  520.                 ReportSemError(SemanticError::OBSOLESCENT_ABSTRACT,
  521.                                modifier -> modifier_kind_token,
  522.                                modifier -> modifier_kind_token);
  523.             }
  524.             break;
  525.         case Ast::PUBLIC:
  526.             if (access_flags.ACC_PUBLIC() || access_flags.ACC_PROTECTED() || access_flags.ACC_PRIVATE())
  527.             {
  528.                 ReportSemError(SemanticError::DUPLICATE_ACCESS_MODIFIER,
  529.                                modifier -> modifier_kind_token,
  530.                                modifier -> modifier_kind_token);
  531.             }
  532.             else access_flags.SetACC_PUBLIC();
  533.             break;
  534.         case Ast::PRIVATE:
  535.             if (access_flags.ACC_PUBLIC() || access_flags.ACC_PROTECTED() || access_flags.ACC_PRIVATE())
  536.             {
  537.                 ReportSemError(SemanticError::DUPLICATE_ACCESS_MODIFIER,
  538.                                modifier -> modifier_kind_token,
  539.                                modifier -> modifier_kind_token);
  540.             }
  541.             else access_flags.SetACC_PRIVATE();
  542.             break;
  543.         case Ast::PROTECTED:
  544.             if (access_flags.ACC_PUBLIC() || access_flags.ACC_PROTECTED() || access_flags.ACC_PRIVATE())
  545.             {
  546.                 ReportSemError(SemanticError::DUPLICATE_ACCESS_MODIFIER,
  547.                                modifier -> modifier_kind_token,
  548.                                modifier -> modifier_kind_token);
  549.             }
  550.             else access_flags.SetACC_PROTECTED();
  551.             break;
  552.         case Ast::STATIC: // TODO: Need to confirm that this is valid !!!
  553.             if (access_flags.ACC_STATIC())
  554.             {
  555.                 ReportSemError(SemanticError::DUPLICATE_MODIFIER,
  556.                                modifier -> modifier_kind_token,
  557.                                modifier -> modifier_kind_token);
  558.             }
  559.             else if (control.option.pedantic)
  560.             {
  561.                 ReportSemError(SemanticError::REDUNDANT_STATIC,
  562.                                modifier -> modifier_kind_token,
  563.                                modifier -> modifier_kind_token);
  564.                 access_flags.SetACC_STATIC();
  565.             }
  566.  
  567.             break;
  568.         case Ast::STRICTFP:
  569.             if (access_flags.ACC_STRICTFP())
  570.             {
  571.                 ReportSemError(SemanticError::DUPLICATE_MODIFIER,
  572.                                modifier -> modifier_kind_token,
  573.                                modifier -> modifier_kind_token);
  574.             }
  575.             else access_flags.SetACC_STRICTFP();
  576.             break;
  577.         default:
  578.             ReportSemError(SemanticError::INVALID_INTERFACE_MODIFIER,
  579.                            modifier -> modifier_kind_token,
  580.                            modifier -> modifier_kind_token,
  581.                            lex_stream -> NameString(modifier -> modifier_kind_token));
  582.             break;
  583.         }
  584.     }
  585.  
  586.     access_flags.SetACC_INTERFACE();
  587.     access_flags.SetACC_ABSTRACT(); // every interface is implicitly abstract
  588.     access_flags.SetACC_STATIC();   // every inner interface is implicitly static
  589.  
  590.     return access_flags;
  591. }
  592.  
  593.  
  594. AccessFlags Semantic::ProcessFieldModifiers(AstFieldDeclaration *field_declaration)
  595. {
  596.     AccessFlags access_flags;
  597.  
  598.     for (int i = 0; i < field_declaration -> NumVariableModifiers(); i++)
  599.     {
  600.         AstModifier *modifier = field_declaration -> VariableModifier(i);
  601.  
  602.         switch(modifier -> kind)
  603.         {
  604.             case Ast::PUBLIC:
  605.                  if (access_flags.ACC_PUBLIC() || access_flags.ACC_PROTECTED() || access_flags.ACC_PRIVATE())
  606.                  {
  607.                      ReportSemError(SemanticError::DUPLICATE_ACCESS_MODIFIER,
  608.                                     modifier -> modifier_kind_token,
  609.                                     modifier -> modifier_kind_token);
  610.                  }
  611.                  else access_flags.SetACC_PUBLIC();
  612.                  break;
  613.             case Ast::PROTECTED:
  614.                  if (access_flags.ACC_PUBLIC() || access_flags.ACC_PROTECTED() || access_flags.ACC_PRIVATE())
  615.                  {
  616.                      ReportSemError(SemanticError::DUPLICATE_ACCESS_MODIFIER,
  617.                                     modifier -> modifier_kind_token,
  618.                                     modifier -> modifier_kind_token);
  619.                  }
  620.                  else access_flags.SetACC_PROTECTED();
  621.                  break;
  622.             case Ast::PRIVATE:
  623.                  if (access_flags.ACC_PUBLIC() || access_flags.ACC_PROTECTED() || access_flags.ACC_PRIVATE())
  624.                  {
  625.                      ReportSemError(SemanticError::DUPLICATE_ACCESS_MODIFIER,
  626.                                     modifier -> modifier_kind_token,
  627.                                     modifier -> modifier_kind_token);
  628.                  }
  629.                  else access_flags.SetACC_PRIVATE();
  630.                  break;
  631.             case Ast::STATIC:
  632.                  if (access_flags.ACC_STATIC())
  633.                  {
  634.                      ReportSemError(SemanticError::DUPLICATE_MODIFIER,
  635.                                     modifier -> modifier_kind_token,
  636.                                     modifier -> modifier_kind_token);
  637.                  }
  638.                  else access_flags.SetACC_STATIC();
  639.                  break;
  640.             case Ast::FINAL:
  641.                  if (access_flags.ACC_FINAL())
  642.                  {
  643.                      ReportSemError(SemanticError::DUPLICATE_MODIFIER,
  644.                                     modifier -> modifier_kind_token,
  645.                                     modifier -> modifier_kind_token);
  646.                  }
  647.                  else access_flags.SetACC_FINAL();
  648.  
  649.                  if (access_flags.ACC_VOLATILE())
  650.                  {
  651.                      ReportSemError(SemanticError::FINAL_VOLATILE,
  652.                                     modifier -> modifier_kind_token,
  653.                                     modifier -> modifier_kind_token);
  654.                  }
  655.                  break;
  656.             case Ast::TRANSIENT:
  657.                  if (access_flags.ACC_TRANSIENT())
  658.                  {
  659.                      ReportSemError(SemanticError::DUPLICATE_MODIFIER,
  660.                                     modifier -> modifier_kind_token,
  661.                                     modifier -> modifier_kind_token);
  662.                  }
  663.                  else access_flags.SetACC_TRANSIENT();
  664.                  break;
  665.             case Ast::VOLATILE:
  666.                  if (access_flags.ACC_VOLATILE())
  667.                  {
  668.                      ReportSemError(SemanticError::DUPLICATE_MODIFIER,
  669.                                     modifier -> modifier_kind_token,
  670.                                     modifier -> modifier_kind_token);
  671.                  }
  672.                  else access_flags.SetACC_VOLATILE();
  673.  
  674.                  if (access_flags.ACC_FINAL())
  675.                  {
  676.                      ReportSemError(SemanticError::VOLATILE_FINAL,
  677.                                     modifier -> modifier_kind_token,
  678.                                     modifier -> modifier_kind_token);
  679.                  }
  680.                  break;
  681.             default:
  682.                  ReportSemError(SemanticError::INVALID_FIELD_MODIFIER,
  683.                                 modifier -> modifier_kind_token,
  684.                                 modifier -> modifier_kind_token,
  685.                                 lex_stream -> NameString(modifier -> modifier_kind_token));
  686.                  break;
  687.         }
  688.     }
  689.  
  690.     return access_flags;
  691. }
  692.  
  693.  
  694. AccessFlags Semantic::ProcessLocalModifiers(AstLocalVariableDeclarationStatement *local_declaration)
  695. {
  696.     AccessFlags access_flags;
  697.  
  698.     for (int i = 0; i < local_declaration -> NumLocalModifiers(); i++)
  699.     {
  700.         AstModifier *modifier = local_declaration -> LocalModifier(i);
  701.  
  702.         if (modifier -> kind == Ast::FINAL)
  703.         {
  704.             if (access_flags.ACC_FINAL())
  705.             {
  706.                 ReportSemError(SemanticError::DUPLICATE_MODIFIER,
  707.                                modifier -> modifier_kind_token,
  708.                                modifier -> modifier_kind_token);
  709.             }
  710.             else access_flags.SetACC_FINAL();
  711.         }
  712.         else
  713.         {
  714.             ReportSemError(SemanticError::INVALID_LOCAL_MODIFIER,
  715.                            modifier -> modifier_kind_token,
  716.                            modifier -> modifier_kind_token,
  717.                            lex_stream -> NameString(modifier -> modifier_kind_token));
  718.         }
  719.     }
  720.  
  721.     return access_flags;
  722. }
  723.  
  724.  
  725. AccessFlags Semantic::ProcessFormalModifiers(AstFormalParameter *parameter_declaration)
  726. {
  727.     AccessFlags access_flags;
  728.  
  729.     for (int i = 0; i < parameter_declaration -> NumParameterModifiers(); i++)
  730.     {
  731.         AstModifier *modifier = parameter_declaration -> ParameterModifier(i);
  732.  
  733.         if (modifier -> kind == Ast::FINAL)
  734.         {
  735.             if (access_flags.ACC_FINAL())
  736.             {
  737.                 ReportSemError(SemanticError::DUPLICATE_MODIFIER,
  738.                                modifier -> modifier_kind_token,
  739.                                modifier -> modifier_kind_token);
  740.             }
  741.             else access_flags.SetACC_FINAL();
  742.         }
  743.         else
  744.         {
  745.             ReportSemError(SemanticError::INVALID_LOCAL_MODIFIER,
  746.                            modifier -> modifier_kind_token,
  747.                            modifier -> modifier_kind_token,
  748.                            lex_stream -> NameString(modifier -> modifier_kind_token));
  749.         }
  750.     }
  751.  
  752.     return access_flags;
  753. }
  754.  
  755.  
  756. AccessFlags Semantic::ProcessMethodModifiers(AstMethodDeclaration *method_declaration)
  757. {
  758.     AccessFlags access_flags;
  759.  
  760.     for (int i = 0; i < method_declaration -> NumMethodModifiers(); i++)
  761.     {
  762.         AstModifier *modifier = method_declaration -> MethodModifier(i);
  763.  
  764.         switch(modifier -> kind)
  765.         {
  766.             case Ast::PUBLIC:
  767.                  if (access_flags.ACC_PUBLIC() || access_flags.ACC_PROTECTED() || access_flags.ACC_PRIVATE())
  768.                  {
  769.                      ReportSemError(SemanticError::DUPLICATE_ACCESS_MODIFIER,
  770.                                     modifier -> modifier_kind_token,
  771.                                     modifier -> modifier_kind_token);
  772.                  }
  773.                  else access_flags.SetACC_PUBLIC();
  774.                  break;
  775.             case Ast::PROTECTED:
  776.                  if (access_flags.ACC_PUBLIC() || access_flags.ACC_PROTECTED() || access_flags.ACC_PRIVATE())
  777.                  {
  778.                      ReportSemError(SemanticError::DUPLICATE_ACCESS_MODIFIER,
  779.                                     modifier -> modifier_kind_token,
  780.                                     modifier -> modifier_kind_token);
  781.                  }
  782.                  else access_flags.SetACC_PROTECTED();
  783.                  break;
  784.             case Ast::PRIVATE:
  785.                  if (access_flags.ACC_PUBLIC() || access_flags.ACC_PROTECTED() || access_flags.ACC_PRIVATE())
  786.                  {
  787.                      ReportSemError(SemanticError::DUPLICATE_ACCESS_MODIFIER,
  788.                                     modifier -> modifier_kind_token,
  789.                                     modifier -> modifier_kind_token);
  790.                  }
  791.                  else access_flags.SetACC_PRIVATE();
  792.  
  793.                  if (access_flags.ACC_ABSTRACT())
  794.                  {
  795.                      ReportSemError(SemanticError::ABSTRACT_METHOD_MODIFIER_CONFLICT,
  796.                                     modifier -> modifier_kind_token,
  797.                                     modifier -> modifier_kind_token,
  798.                                     lex_stream -> NameString(modifier -> modifier_kind_token));
  799.                  }
  800.                  break;
  801.             case Ast::STATIC:
  802.                  if (access_flags.ACC_STATIC())
  803.                  {
  804.                      ReportSemError(SemanticError::DUPLICATE_MODIFIER,
  805.                                     modifier -> modifier_kind_token,
  806.                                     modifier -> modifier_kind_token);
  807.                  }
  808.                  else access_flags.SetACC_STATIC();
  809.  
  810.                  if (access_flags.ACC_ABSTRACT())
  811.                  {
  812.                      ReportSemError(SemanticError::ABSTRACT_METHOD_MODIFIER_CONFLICT,
  813.                                     modifier -> modifier_kind_token,
  814.                                     modifier -> modifier_kind_token,
  815.                                     lex_stream -> NameString(modifier -> modifier_kind_token));
  816.                  }
  817.                  break;
  818.             case Ast::STRICTFP:
  819.                  if (access_flags.ACC_STRICTFP())
  820.                  {
  821.                      ReportSemError(SemanticError::DUPLICATE_MODIFIER,
  822.                                     modifier -> modifier_kind_token,
  823.                                     modifier -> modifier_kind_token);
  824.                  }
  825.                  else access_flags.SetACC_STRICTFP();
  826.                  break;
  827.             case Ast::ABSTRACT:
  828.                  if (access_flags.ACC_ABSTRACT())
  829.                  {
  830.                      ReportSemError(SemanticError::DUPLICATE_MODIFIER,
  831.                                     modifier -> modifier_kind_token,
  832.                                     modifier -> modifier_kind_token);
  833.                  }
  834.                  else access_flags.SetACC_ABSTRACT();
  835.  
  836.                  if (access_flags.ACC_PRIVATE() || access_flags.ACC_STATIC() ||
  837.                      access_flags.ACC_FINAL()   || access_flags.ACC_NATIVE() || access_flags.ACC_SYNCHRONIZED())
  838.                  {
  839.                      ReportSemError(SemanticError::BAD_ABSTRACT_METHOD_MODIFIER,
  840.                                     modifier -> modifier_kind_token,
  841.                                     modifier -> modifier_kind_token);
  842.                  }
  843.                  break;
  844.             case Ast::FINAL:
  845.                  if (access_flags.ACC_FINAL())
  846.                  {
  847.                      ReportSemError(SemanticError::DUPLICATE_MODIFIER,
  848.                                     modifier -> modifier_kind_token,
  849.                                     modifier -> modifier_kind_token);
  850.                  }
  851.                  else access_flags.SetACC_FINAL();
  852.  
  853.                  if (access_flags.ACC_ABSTRACT())
  854.                  {
  855.                      ReportSemError(SemanticError::ABSTRACT_METHOD_MODIFIER_CONFLICT,
  856.                                     modifier -> modifier_kind_token,
  857.                                     modifier -> modifier_kind_token,
  858.                                     lex_stream -> NameString(modifier -> modifier_kind_token));
  859.                  }
  860.                  break;
  861.             case Ast::NATIVE:
  862.                  if (access_flags.ACC_NATIVE())
  863.                  {
  864.                      ReportSemError(SemanticError::DUPLICATE_MODIFIER,
  865.                                     modifier -> modifier_kind_token,
  866.                                     modifier -> modifier_kind_token);
  867.                  }
  868.                  else access_flags.SetACC_NATIVE();
  869.  
  870.                  if (access_flags.ACC_ABSTRACT())
  871.                  {
  872.                      ReportSemError(SemanticError::ABSTRACT_METHOD_MODIFIER_CONFLICT,
  873.                                     modifier -> modifier_kind_token,
  874.                                     modifier -> modifier_kind_token,
  875.                                     lex_stream -> NameString(modifier -> modifier_kind_token));
  876.                  }
  877.                  break;
  878.             case Ast::SYNCHRONIZED:
  879.                  if (access_flags.ACC_SYNCHRONIZED())
  880.                  {
  881.                      ReportSemError(SemanticError::DUPLICATE_MODIFIER,
  882.                                     modifier -> modifier_kind_token,
  883.                                     modifier -> modifier_kind_token);
  884.                  }
  885.                  else access_flags.SetACC_SYNCHRONIZED();
  886.  
  887.                  if (access_flags.ACC_ABSTRACT())
  888.                  {
  889.                      ReportSemError(SemanticError::ABSTRACT_METHOD_MODIFIER_CONFLICT,
  890.                                     modifier -> modifier_kind_token,
  891.                                     modifier -> modifier_kind_token,
  892.                                     lex_stream -> NameString(modifier -> modifier_kind_token));
  893.                  }
  894.                  break;
  895.             default:
  896.                  ReportSemError(SemanticError::INVALID_METHOD_MODIFIER,
  897.                                 modifier -> modifier_kind_token,
  898.                                 modifier -> modifier_kind_token,
  899.                                 lex_stream -> NameString(modifier -> modifier_kind_token));
  900.                  break;
  901.         }
  902.     }
  903.  
  904.     return access_flags;
  905. }
  906.  
  907.  
  908. AccessFlags Semantic::ProcessInterfaceMethodModifiers(AstMethodDeclaration *method_declaration)
  909. {
  910.     AccessFlags access_flags;
  911.  
  912.     for (int i = 0; i < method_declaration -> NumMethodModifiers(); i++)
  913.     {
  914.         AstModifier *modifier = method_declaration -> MethodModifier(i);
  915.  
  916.         switch(modifier -> kind)
  917.         {
  918.             case Ast::PUBLIC:
  919.                  if (access_flags.ACC_PUBLIC())
  920.                  {
  921.                      ReportSemError(SemanticError::DUPLICATE_MODIFIER,
  922.                                     modifier -> modifier_kind_token,
  923.                                     modifier -> modifier_kind_token);
  924.                  }
  925.                  else
  926.                  {
  927.                      if (control.option.pedantic)
  928.                          ReportSemError(SemanticError::REDUNDANT_PUBLIC,
  929.                                         modifier -> modifier_kind_token,
  930.                                         modifier -> modifier_kind_token);
  931.                      access_flags.SetACC_PUBLIC();
  932.                  }
  933.                  break;
  934.             case Ast::ABSTRACT:
  935.                  if (access_flags.ACC_ABSTRACT())
  936.                  {
  937.                      ReportSemError(SemanticError::DUPLICATE_MODIFIER,
  938.                                     modifier -> modifier_kind_token,
  939.                                     modifier -> modifier_kind_token);
  940.                  }
  941.                  else
  942.                  {
  943.                      if (control.option.pedantic)
  944.                          ReportSemError(SemanticError::REDUNDANT_ABSTRACT,
  945.                                         modifier -> modifier_kind_token,
  946.                                         modifier -> modifier_kind_token);
  947.                      access_flags.SetACC_ABSTRACT();
  948.                  }
  949.                  break;
  950.             default:
  951.                  ReportSemError(SemanticError::INVALID_SIGNATURE_MODIFIER,
  952.                                 modifier -> modifier_kind_token,
  953.                                 modifier -> modifier_kind_token,
  954.                                 lex_stream -> NameString(modifier -> modifier_kind_token));
  955.                  break;
  956.         }
  957.     }
  958.  
  959.     //
  960.     // Every method declaration in the body of an interface is implicitly "public" and "abstract"
  961.     //
  962.     access_flags.SetACC_ABSTRACT();
  963.     access_flags.SetACC_PUBLIC();
  964.  
  965.     return access_flags;
  966. }
  967.  
  968.  
  969. AccessFlags Semantic::ProcessConstructorModifiers(AstConstructorDeclaration *constructor_declaration)
  970. {
  971.     AccessFlags access_flags;
  972.  
  973.     for (int i = 0; i < constructor_declaration -> NumConstructorModifiers(); i++)
  974.     {
  975.         AstModifier *modifier = constructor_declaration -> ConstructorModifier(i);
  976.  
  977.         switch(modifier -> kind)
  978.         {
  979.             case Ast::PUBLIC:
  980.                  if (access_flags.ACC_PUBLIC() || access_flags.ACC_PROTECTED() || access_flags.ACC_PRIVATE())
  981.                  {
  982.                      ReportSemError(SemanticError::DUPLICATE_ACCESS_MODIFIER,
  983.                                     modifier -> modifier_kind_token,
  984.                                     modifier -> modifier_kind_token);
  985.                  }
  986.                  else access_flags.SetACC_PUBLIC();
  987.                  break;
  988.             case Ast::PROTECTED:
  989.                  if (access_flags.ACC_PUBLIC() || access_flags.ACC_PROTECTED() || access_flags.ACC_PRIVATE())
  990.                  {
  991.                      ReportSemError(SemanticError::DUPLICATE_ACCESS_MODIFIER,
  992.                                     modifier -> modifier_kind_token,
  993.                                     modifier -> modifier_kind_token);
  994.                  }
  995.                  else access_flags.SetACC_PROTECTED();
  996.                  break;
  997.             case Ast::PRIVATE:
  998.                  if (access_flags.ACC_PUBLIC() || access_flags.ACC_PROTECTED() || access_flags.ACC_PRIVATE())
  999.                  {
  1000.                      ReportSemError(SemanticError::DUPLICATE_ACCESS_MODIFIER,
  1001.                                     modifier -> modifier_kind_token,
  1002.                                     modifier -> modifier_kind_token);
  1003.                  }
  1004.                  else access_flags.SetACC_PRIVATE();
  1005.                  break;
  1006.             default:
  1007.                  ReportSemError(SemanticError::INVALID_CONSTRUCTOR_MODIFIER,
  1008.                                 modifier -> modifier_kind_token,
  1009.                                 modifier -> modifier_kind_token,
  1010.                                 lex_stream -> NameString(modifier -> modifier_kind_token));
  1011.                  break;
  1012.         }
  1013.     }
  1014.  
  1015.     return access_flags;
  1016. }
  1017.  
  1018.  
  1019. AccessFlags Semantic::ProcessConstantModifiers(AstFieldDeclaration *field_declaration)
  1020. {
  1021.     AccessFlags access_flags;
  1022.  
  1023.     for (int i = 0; i < field_declaration -> NumVariableModifiers(); i++)
  1024.     {
  1025.         AstModifier *modifier = field_declaration -> VariableModifier(i);
  1026.  
  1027.         switch(modifier -> kind)
  1028.         {
  1029.             case Ast::PUBLIC:
  1030.                  if (access_flags.ACC_PUBLIC())
  1031.                  {
  1032.                      ReportSemError(SemanticError::DUPLICATE_MODIFIER,
  1033.                                     modifier -> modifier_kind_token,
  1034.                                     modifier -> modifier_kind_token);
  1035.                  }
  1036.                  else
  1037.                  {
  1038.                      if (control.option.pedantic)
  1039.                          ReportSemError(SemanticError::REDUNDANT_PUBLIC,
  1040.                                         modifier -> modifier_kind_token,
  1041.                                         modifier -> modifier_kind_token);
  1042.                      access_flags.SetACC_PUBLIC();
  1043.                  }
  1044.                  break;
  1045.             case Ast::STATIC:
  1046.                  if (access_flags.ACC_STATIC())
  1047.                  {
  1048.                      ReportSemError(SemanticError::DUPLICATE_MODIFIER,
  1049.                                     modifier -> modifier_kind_token,
  1050.                                     modifier -> modifier_kind_token);
  1051.                  }
  1052.                  else
  1053.                  {
  1054.                      if (control.option.pedantic)
  1055.                          ReportSemError(SemanticError::REDUNDANT_STATIC,
  1056.                                         modifier -> modifier_kind_token,
  1057.                                         modifier -> modifier_kind_token);
  1058.                      access_flags.SetACC_STATIC();
  1059.                  }
  1060.                  break;
  1061.             case Ast::FINAL:
  1062.                  if (access_flags.ACC_FINAL())
  1063.                  {
  1064.                      ReportSemError(SemanticError::DUPLICATE_MODIFIER,
  1065.                                     modifier -> modifier_kind_token,
  1066.                                     modifier -> modifier_kind_token);
  1067.                  }
  1068.                  else
  1069.                  {
  1070.                      if (control.option.pedantic)
  1071.                          ReportSemError(SemanticError::REDUNDANT_FINAL,
  1072.                                         modifier -> modifier_kind_token,
  1073.                                         modifier -> modifier_kind_token);
  1074.                      access_flags.SetACC_FINAL();
  1075.                  }
  1076.                  break;
  1077.             default:
  1078.                  ReportSemError(SemanticError::INVALID_CONSTANT_MODIFIER,
  1079.                                 modifier -> modifier_kind_token,
  1080.                                 modifier -> modifier_kind_token,
  1081.                                 lex_stream -> NameString(modifier -> modifier_kind_token));
  1082.                  break;
  1083.         }
  1084.     }
  1085.  
  1086.     //
  1087.     // Every constant (field) declaration in the body of an interface is implicitly "public", "static" and "final"
  1088.     //
  1089.     access_flags.SetACC_PUBLIC();
  1090.     access_flags.SetACC_STATIC();
  1091.     access_flags.SetACC_FINAL();
  1092.  
  1093.     return access_flags;
  1094. }
  1095.  
  1096. #ifdef    HAVE_JIKES_NAMESPACE
  1097. }            // Close namespace Jikes block
  1098. #endif
  1099.  
  1100.