net.sourceforge.phpeclipse/src/net/sourceforge/phpdt/internal/compiler/parser/RecoveredElement.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.phpdt.internal.compiler.parser;
  12
  13 import net.sourceforge.phpeclipse.internal.compiler.ast.AstNode;
  14 import net.sourceforge.phpeclipse.internal.compiler.ast.Block;
  15 import net.sourceforge.phpeclipse.internal.compiler.ast.FieldDeclaration;
  16 import net.sourceforge.phpeclipse.internal.compiler.ast.Statement;
  17
  18 /**
  19  * Internal structure for parsing recovery
  20  */
  21
  22 public class RecoveredElement {
  23
  24         public RecoveredElement parent;
  25         public int bracketBalance;
  26         public boolean foundOpeningBrace;
  27         protected Parser recoveringParser;
  28 public RecoveredElement(RecoveredElement parent, int bracketBalance){
  29         this(parent, bracketBalance, null);
  30 }
  31 public RecoveredElement(RecoveredElement parent, int bracketBalance, Parser parser){
  32         this.parent = parent;
  33         this.bracketBalance = bracketBalance;
  34         this.recoveringParser = parser;
  35 }
  36 /*
  37  *      Record a method declaration
  38  */
  39 //public RecoveredElement add(AbstractMethodDeclaration methodDeclaration, int bracketBalance) {
  40 //
  41 //      /* default behavior is to delegate recording to parent if any */
  42 //      if (parent == null) {
  43 //              return this; // ignore
  44 //      } else {
  45 //              this.updateSourceEndIfNecessary(this.previousAvailableLineEnd(methodDeclaration.declarationSourceStart - 1));
  46 //              return this.parent.add(methodDeclaration, bracketBalance);
  47 //      }
  48 //}
  49 /*
  50  * Record a nested block declaration
  51  */
  52 public RecoveredElement add(Block nestedBlockDeclaration, int bracketBalance) {
  53
  54         /* default behavior is to delegate recording to parent if any */
  55         if (parent == null) {
  56                 return this; // ignore
  57         } else {
  58                 this.updateSourceEndIfNecessary(this.previousAvailableLineEnd(nestedBlockDeclaration.sourceStart - 1));
  59                 return this.parent.add(nestedBlockDeclaration, bracketBalance);
  60         }
  61 }
  62 /*
  63  * Record a field declaration
  64  */
  65 //public RecoveredElement add(FieldDeclaration fieldDeclaration, int bracketBalance) {
  66 //
  67 //      /* default behavior is to delegate recording to parent if any */
  68 //      if (parent == null) {
  69 //              return this; // ignore
  70 //      } else {
  71 //              this.updateSourceEndIfNecessary(this.previousAvailableLineEnd(fieldDeclaration.declarationSourceStart - 1));
  72 //              return this.parent.add(fieldDeclaration, bracketBalance);
  73 //      }
  74 //}
  75 ///*
  76 // *    Record an import reference
  77 // */
  78 //public RecoveredElement add(ImportReference importReference, int bracketBalance){
  79 //
  80 //      /* default behavior is to delegate recording to parent if any */
  81 //      if (parent == null) {
  82 //              return this; // ignore
  83 //      } else {
  84 //              this.updateSourceEndIfNecessary(this.previousAvailableLineEnd(importReference.declarationSourceStart - 1));
  85 //              return this.parent.add(importReference, bracketBalance);
  86 //      }
  87 //}
  88 ///*
  89 // * Record a local declaration
  90 // */
  91 //public RecoveredElement add(LocalDeclaration localDeclaration, int bracketBalance) {
  92 //
  93 //      /* default behavior is to delegate recording to parent if any */
  94 //      if (parent == null) {
  95 //              return this; // ignore
  96 //      } else {
  97 //              this.updateSourceEndIfNecessary(this.previousAvailableLineEnd(localDeclaration.declarationSourceStart - 1));
  98 //              return this.parent.add(localDeclaration, bracketBalance);
  99 //      }
 100 //}
 101 /*
 102  * Record a statement
 103  */
 104 public RecoveredElement add(Statement statement, int bracketBalance) {
 105
 106         /* default behavior is to delegate recording to parent if any */
 107         if (parent == null) {
 108                 return this; // ignore
 109         } else {
 110                 this.updateSourceEndIfNecessary(this.previousAvailableLineEnd(statement.sourceStart - 1));
 111                 return this.parent.add(statement, bracketBalance);
 112         }
 113 }
 114 /*
 115  *      Record a type declaration
 116  */
 117 //public RecoveredElement add(TypeDeclaration typeDeclaration, int bracketBalance){
 118 //
 119 //      /* default behavior is to delegate recording to parent if any */
 120 //      if (parent == null) {
 121 //              return this; // ignore
 122 //      } else {
 123 //              this.updateSourceEndIfNecessary(this.previousAvailableLineEnd(typeDeclaration.declarationSourceStart - 1));
 124 //              return this.parent.add(typeDeclaration, bracketBalance);
 125 //      }
 126 //}
 127 /*
 128  * Answer the depth of this element, considering the parent link.
 129  */
 130 public int depth(){
 131         int depth = 0;
 132         RecoveredElement current = this;
 133         while ((current = current.parent) != null) depth++;
 134         return depth;
 135 }
 136 /*
 137  * Answer the enclosing method node, or null if none
 138  */
 139 //public RecoveredInitializer enclosingInitializer(){
 140 //      RecoveredElement current = this;
 141 //      while (current != null){
 142 //              if (current instanceof RecoveredInitializer){
 143 //                      return (RecoveredInitializer) current;
 144 //              }
 145 //              current = current.parent;
 146 //      }
 147 //      return null;
 148 //}
 149 /*
 150  * Answer the enclosing method node, or null if none
 151  */
 152 //public RecoveredMethod enclosingMethod(){
 153 //      RecoveredElement current = this;
 154 //      while (current != null){
 155 //              if (current instanceof RecoveredMethod){
 156 //                      return (RecoveredMethod) current;
 157 //              }
 158 //              current = current.parent;
 159 //      }
 160 //      return null;
 161 //}
 162 /*
 163  * Answer the enclosing type node, or null if none
 164  */
 165 //public RecoveredType enclosingType(){
 166 //      RecoveredElement current = this;
 167 //      while (current != null){
 168 //              if (current instanceof RecoveredType){
 169 //                      return (RecoveredType) current;
 170 //              }
 171 //              current = current.parent;
 172 //      }
 173 //      return null;
 174 //}
 175 /*
 176  * Answer the closest specified parser
 177  */
 178 public Parser parser(){
 179         RecoveredElement current = this;
 180         while (current != null){
 181                 if (current.recoveringParser != null){
 182                         return current.recoveringParser;
 183                 }
 184                 current = current.parent;
 185         }
 186         return null;
 187 }
 188 /*
 189  * Answer the associated parsed structure
 190  */
 191 public AstNode parseTree(){
 192         return null;
 193 }
 194 /*
 195  * Iterate the enclosing blocks and tag them so as to preserve their content
 196  */
 197 //public void preserveEnclosingBlocks(){
 198 //      RecoveredElement current = this;
 199 //      while (current != null){
 200 //              if (current instanceof RecoveredBlock){
 201 //                      ((RecoveredBlock)current).preserveContent = true;
 202 //              }
 203 //              if (current instanceof RecoveredType){ // for anonymous types
 204 //                      ((RecoveredType)current).preserveContent = true;
 205 //              }
 206 //              current = current.parent;
 207 //      }
 208 //}
 209 /*
 210  * Answer the position of the previous line end if
 211  * there is nothing but spaces in between it and the
 212  * line end. Used to trim spaces on unclosed elements.
 213  */
 214 public int previousAvailableLineEnd(int position){
 215
 216         Parser parser = this.parser();
 217         if (parser == null) return position;
 218
 219         Scanner scanner = parser.scanner;
 220         if (scanner.lineEnds == null) return position;
 221
 222         int index = scanner.getLineNumber(position);
 223         if (index < 2) return position;
 224         int previousLineEnd = scanner.lineEnds[index-2];
 225
 226         char[] source = scanner.source;
 227         for (int i = previousLineEnd+1; i < position; i++){
 228                 if (!(source[i] == ' ' || source[i] == '\t')) return position;
 229         }
 230         return previousLineEnd;
 231 }
 232 /*
 233  * Answer the very source end of the corresponding parse node
 234  */
 235 public int sourceEnd(){
 236         return 0;
 237 }
 238 protected String tabString(int tab) {
 239         StringBuffer result = new StringBuffer();
 240         for (int i = tab; i > 0; i--) {
 241                 result.append("  "); //$NON-NLS-1$
 242         }
 243         return result.toString();
 244 }
 245 /*
 246  * Answer the top node
 247  */
 248 public RecoveredElement topElement(){
 249         RecoveredElement current = this;
 250         while (current.parent != null){
 251                 current = current.parent;
 252         }
 253         return current;
 254 }
 255 public String toString() {
 256         return toString(0);
 257 }
 258 public String toString(int tab) {
 259         return super.toString();
 260 }
 261 /*
 262  * Answer the enclosing type node, or null if none
 263  */
 264 //public RecoveredType type(){
 265 //      RecoveredElement current = this;
 266 //      while (current != null){
 267 //              if (current instanceof RecoveredType){
 268 //                      return (RecoveredType) current;
 269 //              }
 270 //              current = current.parent;
 271 //      }
 272 //      return null;
 273 //}
 274 /*
 275  * Update the bodyStart of the corresponding parse node
 276  */
 277 public void updateBodyStart(int bodyStart){
 278         this.foundOpeningBrace = true;
 279 }
 280 /*
 281  * Update the corresponding parse node from parser state which
 282  * is about to disappear because of restarting recovery
 283  */
 284 public void updateFromParserState(){
 285 }
 286 /*
 287  * A closing brace got consumed, might have closed the current element,
 288  * in which case both the currentElement is exited
 289  */
 290 public RecoveredElement updateOnClosingBrace(int braceStart, int braceEnd){
 291         if ((--bracketBalance <= 0) && (parent != null)){
 292                 this.updateSourceEndIfNecessary(braceEnd);
 293                 return parent;
 294         }
 295         return this;
 296 }
 297 /*
 298  * An opening brace got consumed, might be the expected opening one of the current element,
 299  * in which case the bodyStart is updated.
 300  */
 301 public RecoveredElement updateOnOpeningBrace(int braceEnd){
 302
 303         if (bracketBalance++ == 0){
 304                 this.updateBodyStart(braceEnd + 1);
 305                 return this;
 306         }
 307         return null; // no update is necessary
 308 }
 309 /*
 310  * Final update the corresponding parse node
 311  */
 312 public void updateParseTree(){
 313 }
 314 /*
 315  * Update the declarationSourceEnd of the corresponding parse node
 316  */
 317 public void updateSourceEndIfNecessary(int sourceEnd){
 318 }
 319 }