net.sourceforge.phpeclipse/src/net/sourceforge/phpdt/internal/compiler/parser/RecoveredElement.java

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