net.sourceforge.phpeclipse/src/net/sourceforge/phpeclipse/internal/compiler/ast/Clinit.java

   1 /*******************************************************************************
   2  * Copyright (c) 2000, 2003 IBM Corporation and others.
   3  * All rights reserved. This program and the accompanying materials
   4  * are made available under the terms of the Common Public License v1.0
   5  * which accompanies this distribution, and is available at
   6  * http://www.eclipse.org/legal/cpl-v10.html
   7  *
   8  * Contributors:
   9  *     IBM Corporation - initial API and implementation
  10  *******************************************************************************/
  11 package net.sourceforge.phpeclipse.internal.compiler.ast;
  12
  13 import net.sourceforge.phpdt.internal.compiler.CompilationResult;
  14 import net.sourceforge.phpdt.internal.compiler.IAbstractSyntaxTreeVisitor;
  15 import net.sourceforge.phpdt.internal.compiler.flow.ExceptionHandlingFlowContext;
  16 import net.sourceforge.phpdt.internal.compiler.flow.FlowInfo;
  17 import net.sourceforge.phpdt.internal.compiler.flow.InitializationFlowContext;
  18 import net.sourceforge.phpdt.internal.compiler.lookup.ClassScope;
  19 import net.sourceforge.phpdt.internal.compiler.lookup.FieldBinding;
  20 import net.sourceforge.phpdt.internal.compiler.lookup.MethodScope;
  21 import net.sourceforge.phpdt.internal.compiler.lookup.SourceTypeBinding;
  22 import net.sourceforge.phpdt.internal.compiler.parser.UnitParser;
  23 import net.sourceforge.phpdt.internal.compiler.problem.AbortMethod;
  24
  25 public class Clinit extends AbstractMethodDeclaration {
  26
  27         public final static char[] ConstantPoolName = "<clinit>".toCharArray(); //$NON-NLS-1$
  28
  29         private FieldBinding assertionSyntheticFieldBinding = null;
  30         private FieldBinding classLiteralSyntheticField = null;
  31
  32         public Clinit(CompilationResult compilationResult) {
  33                 super(compilationResult);
  34                 modifiers = 0;
  35                 selector = ConstantPoolName;
  36         }
  37
  38         public void analyseCode(
  39                 ClassScope classScope,
  40                 InitializationFlowContext staticInitializerFlowContext,
  41                 FlowInfo flowInfo) {
  42
  43                 if (ignoreFurtherInvestigation)
  44                         return;
  45                 try {
  46                         ExceptionHandlingFlowContext clinitContext =
  47                                 new ExceptionHandlingFlowContext(
  48                                         staticInitializerFlowContext.parent,
  49                                         this,
  50                                         NoExceptions,
  51                                         scope,
  52                                         FlowInfo.DEAD_END);
  53
  54                         // check for missing returning path
  55                         this.needFreeReturn = flowInfo.isReachable();
  56
  57                         // check missing blank final field initializations
  58                         flowInfo = flowInfo.mergedWith(staticInitializerFlowContext.initsOnReturn);
  59                         FieldBinding[] fields = scope.enclosingSourceType().fields();
  60                         for (int i = 0, count = fields.length; i < count; i++) {
  61                                 FieldBinding field;
  62                                 if ((field = fields[i]).isStatic()
  63                                         && field.isFinal()
  64                                         && (!flowInfo.isDefinitelyAssigned(fields[i]))) {
  65                                         scope.problemReporter().uninitializedBlankFinalField(
  66                                                 field,
  67                                                 scope.referenceType().declarationOf(field));
  68                                         // can complain against the field decl, since only one <clinit>
  69                                 }
  70                         }
  71                         // check static initializers thrown exceptions
  72                         staticInitializerFlowContext.checkInitializerExceptions(
  73                                 scope,
  74                                 clinitContext,
  75                                 flowInfo);
  76                 } catch (AbortMethod e) {
  77                         this.ignoreFurtherInvestigation = true;
  78                 }
  79         }
  80
  81         /**
  82          * Bytecode generation for a <clinit> method
  83          *
  84          * @param classScope org.eclipse.jdt.internal.compiler.lookup.ClassScope
  85          * @param classFile org.eclipse.jdt.internal.compiler.codegen.ClassFile
  86          */
  87 //      public void generateCode(ClassScope classScope, ClassFile classFile) {
  88 //
  89 //              int clinitOffset = 0;
  90 //              if (ignoreFurtherInvestigation) {
  91 //                      // should never have to add any <clinit> problem method
  92 //                      return;
  93 //              }
  94 //              try {
  95 //                      clinitOffset = classFile.contentsOffset;
  96 //                      this.generateCode(classScope, classFile, clinitOffset);
  97 //              } catch (AbortMethod e) {
  98 //                      // should never occur
  99 //                      // the clinit referenceContext is the type declaration
 100 //                      // All clinit problems will be reported against the type: AbortType instead of AbortMethod
 101 //                      // reset the contentsOffset to the value before generating the clinit code
 102 //                      // decrement the number of method info as well.
 103 //                      // This is done in the addProblemMethod and addProblemConstructor for other
 104 //                      // cases.
 105 //                      if (e.compilationResult == CodeStream.RESTART_IN_WIDE_MODE) {
 106 //                              // a branch target required a goto_w, restart code gen in wide mode.
 107 //                              try {
 108 //                                      if (statements != null) {
 109 //                                              for (int i = 0, max = statements.length; i < max; i++)
 110 //                                                      statements[i].resetStateForCodeGeneration();
 111 //                                      }
 112 //                                      classFile.contentsOffset = clinitOffset;
 113 //                                      classFile.methodCount--;
 114 //                                      classFile.codeStream.wideMode = true; // request wide mode
 115 //                                      this.generateCode(classScope, classFile, clinitOffset);
 116 //                                      // restart method generation
 117 //                              } catch (AbortMethod e2) {
 118 //                                      classFile.contentsOffset = clinitOffset;
 119 //                                      classFile.methodCount--;
 120 //                              }
 121 //                      } else {
 122 //                              // produce a problem method accounting for this fatal error
 123 //                              classFile.contentsOffset = clinitOffset;
 124 //                              classFile.methodCount--;
 125 //                      }
 126 //              }
 127 //      }
 128
 129         /**
 130          * Bytecode generation for a <clinit> method
 131          *
 132          * @param classScope org.eclipse.jdt.internal.compiler.lookup.ClassScope
 133          * @param classFile org.eclipse.jdt.internal.compiler.codegen.ClassFile
 134          */
 135 //      private void generateCode(
 136 //              ClassScope classScope,
 137 //              ClassFile classFile,
 138 //              int clinitOffset) {
 139 //
 140 //              ConstantPool constantPool = classFile.constantPool;
 141 //              int constantPoolOffset = constantPool.currentOffset;
 142 //              int constantPoolIndex = constantPool.currentIndex;
 143 //              classFile.generateMethodInfoHeaderForClinit();
 144 //              int codeAttributeOffset = classFile.contentsOffset;
 145 //              classFile.generateCodeAttributeHeader();
 146 //              CodeStream codeStream = classFile.codeStream;
 147 //              this.resolve(classScope);
 148 //
 149 //              codeStream.reset(this, classFile);
 150 //              TypeDeclaration declaringType = classScope.referenceContext;
 151 //
 152 //              // initialize local positions - including initializer scope.
 153 //              MethodScope staticInitializerScope = declaringType.staticInitializerScope;
 154 //              staticInitializerScope.computeLocalVariablePositions(0, codeStream);
 155 //
 156 //              // 1.4 feature
 157 //              // This has to be done before any other initialization
 158 //              if (this.assertionSyntheticFieldBinding != null) {
 159 //                      // generate code related to the activation of assertion for this class
 160 //                      codeStream.generateClassLiteralAccessForType(
 161 //                              classScope.enclosingSourceType(),
 162 //                              classLiteralSyntheticField);
 163 //                      codeStream.invokeJavaLangClassDesiredAssertionStatus();
 164 //                      Label falseLabel = new Label(codeStream);
 165 //                      codeStream.ifne(falseLabel);
 166 //                      codeStream.iconst_1();
 167 //                      Label jumpLabel = new Label(codeStream);
 168 //                      codeStream.goto_(jumpLabel);
 169 //                      falseLabel.place();
 170 //                      codeStream.iconst_0();
 171 //                      jumpLabel.place();
 172 //                      codeStream.putstatic(this.assertionSyntheticFieldBinding);
 173 //              }
 174 //              // generate initializers
 175 //              if (declaringType.fields != null) {
 176 //                      for (int i = 0, max = declaringType.fields.length; i < max; i++) {
 177 //                              FieldDeclaration fieldDecl;
 178 //                              if ((fieldDecl = declaringType.fields[i]).isStatic()) {
 179 //                                      fieldDecl.generateCode(staticInitializerScope, codeStream);
 180 //                              }
 181 //                      }
 182 //              }
 183 //              if (codeStream.position == 0) {
 184 //                      // do not need to output a Clinit if no bytecodes
 185 //                      // so we reset the offset inside the byte array contents.
 186 //                      classFile.contentsOffset = clinitOffset;
 187 //                      // like we don't addd a method we need to undo the increment on the method count
 188 //                      classFile.methodCount--;
 189 //                      // reset the constant pool to its state before the clinit
 190 //                      constantPool.resetForClinit(constantPoolIndex, constantPoolOffset);
 191 //              } else {
 192 //                      if (this.needFreeReturn) {
 193 //                              int oldPosition = codeStream.position;
 194 //                              codeStream.return_();
 195 //                              codeStream.updateLocalVariablesAttribute(oldPosition);
 196 //                      }
 197 //                      // Record the end of the clinit: point to the declaration of the class
 198 //                      codeStream.recordPositionsFrom(0, declaringType.sourceStart);
 199 //                      classFile.completeCodeAttributeForClinit(codeAttributeOffset);
 200 //              }
 201 //      }
 202
 203         public boolean isClinit() {
 204
 205                 return true;
 206         }
 207
 208         public boolean isInitializationMethod() {
 209
 210                 return true;
 211         }
 212
 213         public boolean isStatic() {
 214
 215                 return true;
 216         }
 217
 218         public void parseStatements(UnitParser parser, CompilationUnitDeclaration unit) {
 219                 //the clinit is filled by hand ....
 220         }
 221
 222         public void resolve(ClassScope scope) {
 223
 224                 this.scope = new MethodScope(scope, scope.referenceContext, true);
 225         }
 226
 227         public String toString(int tab) {
 228
 229                 String s = ""; //$NON-NLS-1$
 230                 s = s + tabString(tab);
 231                 s = s + "<clinit>()"; //$NON-NLS-1$
 232                 s = s + toStringStatements(tab + 1);
 233                 return s;
 234         }
 235
 236         public void traverse(
 237                 IAbstractSyntaxTreeVisitor visitor,
 238                 ClassScope classScope) {
 239
 240                 visitor.visit(this, classScope);
 241                 visitor.endVisit(this, classScope);
 242         }
 243
 244         // 1.4 feature
 245         public void addSupportForAssertion(FieldBinding assertionSyntheticFieldBinding) {
 246
 247                 this.assertionSyntheticFieldBinding = assertionSyntheticFieldBinding;
 248
 249                 // we need to add the field right now, because the field infos are generated before the methods
 250                 SourceTypeBinding sourceType =
 251                         this.scope.outerMostMethodScope().enclosingSourceType();
 252                 this.classLiteralSyntheticField =
 253                         sourceType.addSyntheticField(sourceType, scope);
 254         }
 255
 256 }