--- /dev/null
+/*******************************************************************************
+ * Copyright (c) 2000, 2004 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Common Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/cpl-v10.html
+ *
+ * Contributors:
+ * IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.jdt.internal.compiler.parser;
+
+import org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration;
+import org.eclipse.jdt.internal.compiler.ast.ASTNode;
+import org.eclipse.jdt.internal.compiler.ast.Block;
+import org.eclipse.jdt.internal.compiler.ast.FieldDeclaration;
+import org.eclipse.jdt.internal.compiler.ast.Initializer;
+import org.eclipse.jdt.internal.compiler.ast.Statement;
+import org.eclipse.jdt.internal.compiler.ast.TypeDeclaration;
+import org.eclipse.jdt.internal.compiler.ast.TypeReference;
+import org.eclipse.jdt.internal.compiler.lookup.CompilerModifiers;
+
+/**
+ * Internal type structure for parsing recovery
+ */
+
+public class RecoveredType extends RecoveredStatement implements TerminalTokens, CompilerModifiers {
+ public TypeDeclaration typeDeclaration;
+
+ public RecoveredType[] memberTypes;
+ public int memberTypeCount;
+ public RecoveredField[] fields;
+ public int fieldCount;
+ public RecoveredMethod[] methods;
+ public int methodCount;
+
+ public boolean preserveContent = false; // only used for anonymous types
+ public int bodyEnd;
+
+public RecoveredType(TypeDeclaration typeDeclaration, RecoveredElement parent, int bracketBalance){
+ super(typeDeclaration, parent, bracketBalance);
+ this.typeDeclaration = typeDeclaration;
+ this.foundOpeningBrace = !bodyStartsAtHeaderEnd();
+ if(this.foundOpeningBrace) {
+ this.bracketBalance++;
+ }
+}
+public RecoveredElement add(AbstractMethodDeclaration methodDeclaration, int bracketBalanceValue) {
+
+ /* do not consider a method starting passed the type end (if set)
+ it must be belonging to an enclosing type */
+ if (typeDeclaration.declarationSourceEnd != 0
+ && methodDeclaration.declarationSourceStart > typeDeclaration.declarationSourceEnd){
+ return this.parent.add(methodDeclaration, bracketBalanceValue);
+ }
+
+ if (methods == null) {
+ methods = new RecoveredMethod[5];
+ methodCount = 0;
+ } else {
+ if (methodCount == methods.length) {
+ System.arraycopy(
+ methods,
+ 0,
+ (methods = new RecoveredMethod[2 * methodCount]),
+ 0,
+ methodCount);
+ }
+ }
+ RecoveredMethod element = new RecoveredMethod(methodDeclaration, this, bracketBalanceValue, this.recoveringParser);
+ methods[methodCount++] = element;
+
+ /* consider that if the opening brace was not found, it is there */
+ if (!foundOpeningBrace){
+ foundOpeningBrace = true;
+ this.bracketBalance++;
+ }
+ /* if method not finished, then method becomes current */
+ if (methodDeclaration.declarationSourceEnd == 0) return element;
+ return this;
+}
+public RecoveredElement add(Block nestedBlockDeclaration,int bracketBalanceValue) {
+ int modifiers = AccDefault;
+ if(this.parser().recoveredStaticInitializerStart != 0) {
+ modifiers = AccStatic;
+ }
+ return this.add(new Initializer(nestedBlockDeclaration, modifiers), bracketBalanceValue);
+}
+public RecoveredElement add(FieldDeclaration fieldDeclaration, int bracketBalanceValue) {
+
+ /* do not consider a field starting passed the type end (if set)
+ it must be belonging to an enclosing type */
+ if (typeDeclaration.declarationSourceEnd != 0
+ && fieldDeclaration.declarationSourceStart > typeDeclaration.declarationSourceEnd) {
+ return this.parent.add(fieldDeclaration, bracketBalanceValue);
+ }
+ if (fields == null) {
+ fields = new RecoveredField[5];
+ fieldCount = 0;
+ } else {
+ if (fieldCount == fields.length) {
+ System.arraycopy(
+ fields,
+ 0,
+ (fields = new RecoveredField[2 * fieldCount]),
+ 0,
+ fieldCount);
+ }
+ }
+ RecoveredField element = fieldDeclaration.isField()
+ ? new RecoveredField(fieldDeclaration, this, bracketBalanceValue)
+ : new RecoveredInitializer(fieldDeclaration, this, bracketBalanceValue);
+ fields[fieldCount++] = element;
+
+ /* consider that if the opening brace was not found, it is there */
+ if (!foundOpeningBrace){
+ foundOpeningBrace = true;
+ this.bracketBalance++;
+ }
+ /* if field not finished, then field becomes current */
+ if (fieldDeclaration.declarationSourceEnd == 0) return element;
+ return this;
+}
+public RecoveredElement add(TypeDeclaration memberTypeDeclaration, int bracketBalanceValue) {
+
+ /* do not consider a type starting passed the type end (if set)
+ it must be belonging to an enclosing type */
+ if (typeDeclaration.declarationSourceEnd != 0
+ && memberTypeDeclaration.declarationSourceStart > typeDeclaration.declarationSourceEnd){
+ return this.parent.add(memberTypeDeclaration, bracketBalanceValue);
+ }
+
+ if ((memberTypeDeclaration.bits & ASTNode.IsAnonymousTypeMASK) != 0){
+ if (this.methodCount > 0) {
+ // add it to the last method body
+ RecoveredMethod lastMethod = this.methods[this.methodCount-1];
+ lastMethod.methodDeclaration.bodyEnd = 0; // reopen method
+ lastMethod.methodDeclaration.declarationSourceEnd = 0; // reopen method
+ lastMethod.bracketBalance++; // expect one closing brace
+ return lastMethod.add(memberTypeDeclaration, bracketBalanceValue);
+ } else {
+ // ignore
+ return this;
+ }
+ }
+
+ if (memberTypes == null) {
+ memberTypes = new RecoveredType[5];
+ memberTypeCount = 0;
+ } else {
+ if (memberTypeCount == memberTypes.length) {
+ System.arraycopy(
+ memberTypes,
+ 0,
+ (memberTypes = new RecoveredType[2 * memberTypeCount]),
+ 0,
+ memberTypeCount);
+ }
+ }
+ RecoveredType element = new RecoveredType(memberTypeDeclaration, this, bracketBalanceValue);
+ memberTypes[memberTypeCount++] = element;
+
+ /* consider that if the opening brace was not found, it is there */
+ if (!foundOpeningBrace){
+ foundOpeningBrace = true;
+ this.bracketBalance++;
+ }
+ /* if member type not finished, then member type becomes current */
+ if (memberTypeDeclaration.declarationSourceEnd == 0) return element;
+ return this;
+}
+/*
+ * Answer the body end of the corresponding parse node
+ */
+public int bodyEnd(){
+ if (bodyEnd == 0) return typeDeclaration.declarationSourceEnd;
+ return bodyEnd;
+}
+public boolean bodyStartsAtHeaderEnd(){
+ if (typeDeclaration.superInterfaces == null){
+ if (typeDeclaration.superclass == null){
+ return typeDeclaration.bodyStart == typeDeclaration.sourceEnd+1;
+ } else {
+ return typeDeclaration.bodyStart == typeDeclaration.superclass.sourceEnd+1;
+ }
+ } else {
+ return typeDeclaration.bodyStart
+ == typeDeclaration.superInterfaces[typeDeclaration.superInterfaces.length-1].sourceEnd+1;
+ }
+}
+/*
+ * Answer the enclosing type node, or null if none
+ */
+public RecoveredType enclosingType(){
+ RecoveredElement current = parent;
+ while (current != null){
+ if (current instanceof RecoveredType){
+ return (RecoveredType) current;
+ }
+ current = current.parent;
+ }
+ return null;
+}
+public char[] name(){
+ return typeDeclaration.name;
+}
+/*
+ * Answer the associated parsed structure
+ */
+public ASTNode parseTree(){
+ return typeDeclaration;
+}
+/*
+ * Answer the very source end of the corresponding parse node
+ */
+public int sourceEnd(){
+ return this.typeDeclaration.declarationSourceEnd;
+}
+public String toString(int tab) {
+ StringBuffer result = new StringBuffer(tabString(tab));
+ result.append("Recovered type:\n"); //$NON-NLS-1$
+ if ((typeDeclaration.bits & ASTNode.IsAnonymousTypeMASK) != 0) {
+ result.append(tabString(tab));
+ result.append(" "); //$NON-NLS-1$
+ }
+ typeDeclaration.print(tab + 1, result);
+ if (this.memberTypes != null) {
+ for (int i = 0; i < this.memberTypeCount; i++) {
+ result.append("\n"); //$NON-NLS-1$
+ result.append(this.memberTypes[i].toString(tab + 1));
+ }
+ }
+ if (this.fields != null) {
+ for (int i = 0; i < this.fieldCount; i++) {
+ result.append("\n"); //$NON-NLS-1$
+ result.append(this.fields[i].toString(tab + 1));
+ }
+ }
+ if (this.methods != null) {
+ for (int i = 0; i < this.methodCount; i++) {
+ result.append("\n"); //$NON-NLS-1$
+ result.append(this.methods[i].toString(tab + 1));
+ }
+ }
+ return result.toString();
+}
+/*
+ * Update the bodyStart of the corresponding parse node
+ */
+public void updateBodyStart(int bodyStart){
+ this.foundOpeningBrace = true;
+ this.typeDeclaration.bodyStart = bodyStart;
+}
+public Statement updatedStatement(){
+
+ // ignore closed anonymous type
+ if ((typeDeclaration.bits & ASTNode.IsAnonymousTypeMASK) != 0 && !this.preserveContent){
+ return null;
+ }
+
+ TypeDeclaration updatedType = this.updatedTypeDeclaration();
+ if ((updatedType.bits & ASTNode.IsAnonymousTypeMASK) != 0){
+ /* in presence of an anonymous type, we want the full allocation expression */
+ return updatedType.allocation;
+ }
+ return updatedType;
+}
+public TypeDeclaration updatedTypeDeclaration(){
+
+ /* update member types */
+ if (memberTypeCount > 0){
+ int existingCount = typeDeclaration.memberTypes == null ? 0 : typeDeclaration.memberTypes.length;
+ TypeDeclaration[] memberTypeDeclarations = new TypeDeclaration[existingCount + memberTypeCount];
+ if (existingCount > 0){
+ System.arraycopy(typeDeclaration.memberTypes, 0, memberTypeDeclarations, 0, existingCount);
+ }
+ // may need to update the declarationSourceEnd of the last type
+ if (memberTypes[memberTypeCount - 1].typeDeclaration.declarationSourceEnd == 0){
+ int bodyEndValue = bodyEnd();
+ memberTypes[memberTypeCount - 1].typeDeclaration.declarationSourceEnd = bodyEndValue;
+ memberTypes[memberTypeCount - 1].typeDeclaration.bodyEnd = bodyEndValue;
+ }
+ for (int i = 0; i < memberTypeCount; i++){
+ memberTypeDeclarations[existingCount + i] = memberTypes[i].updatedTypeDeclaration();
+ }
+ typeDeclaration.memberTypes = memberTypeDeclarations;
+ }
+ /* update fields */
+ if (fieldCount > 0){
+ int existingCount = typeDeclaration.fields == null ? 0 : typeDeclaration.fields.length;
+ FieldDeclaration[] fieldDeclarations = new FieldDeclaration[existingCount + fieldCount];
+ if (existingCount > 0){
+ System.arraycopy(typeDeclaration.fields, 0, fieldDeclarations, 0, existingCount);
+ }
+ // may need to update the declarationSourceEnd of the last field
+ if (fields[fieldCount - 1].fieldDeclaration.declarationSourceEnd == 0){
+ int temp = bodyEnd();
+ fields[fieldCount - 1].fieldDeclaration.declarationSourceEnd = temp;
+ fields[fieldCount - 1].fieldDeclaration.declarationEnd = temp;
+ }
+ for (int i = 0; i < fieldCount; i++){
+ fieldDeclarations[existingCount + i] = fields[i].updatedFieldDeclaration();
+ }
+ typeDeclaration.fields = fieldDeclarations;
+ }
+ /* update methods */
+ int existingCount = typeDeclaration.methods == null ? 0 : typeDeclaration.methods.length;
+ boolean hasConstructor = false, hasRecoveredConstructor = false;
+ int defaultConstructorIndex = -1;
+ if (methodCount > 0){
+ AbstractMethodDeclaration[] methodDeclarations = new AbstractMethodDeclaration[existingCount + methodCount];
+ for (int i = 0; i < existingCount; i++){
+ AbstractMethodDeclaration m = typeDeclaration.methods[i];
+ if (m.isDefaultConstructor()) defaultConstructorIndex = i;
+ methodDeclarations[i] = m;
+ }
+ // may need to update the declarationSourceEnd of the last method
+ if (methods[methodCount - 1].methodDeclaration.declarationSourceEnd == 0){
+ int bodyEndValue = bodyEnd();
+ methods[methodCount - 1].methodDeclaration.declarationSourceEnd = bodyEndValue;
+ methods[methodCount - 1].methodDeclaration.bodyEnd = bodyEndValue;
+ }
+ for (int i = 0; i < methodCount; i++){
+ AbstractMethodDeclaration updatedMethod = methods[i].updatedMethodDeclaration();
+ if (updatedMethod.isConstructor()) hasRecoveredConstructor = true;
+ methodDeclarations[existingCount + i] = updatedMethod;
+ }
+ typeDeclaration.methods = methodDeclarations;
+ hasConstructor = typeDeclaration.checkConstructors(this.parser());
+ } else {
+ for (int i = 0; i < existingCount; i++){
+ if (typeDeclaration.methods[i].isConstructor()) hasConstructor = true;
+ }
+ }
+ /* add clinit ? */
+ if (typeDeclaration.needClassInitMethod()){
+ boolean alreadyHasClinit = false;
+ for (int i = 0; i < existingCount; i++){
+ if (typeDeclaration.methods[i].isClinit()){
+ alreadyHasClinit = true;
+ break;
+ }
+ }
+ if (!alreadyHasClinit) typeDeclaration.addClinit();
+ }
+ /* add default constructor ? */
+ if (defaultConstructorIndex >= 0 && hasRecoveredConstructor){
+ /* should discard previous default construtor */
+ AbstractMethodDeclaration[] methodDeclarations = new AbstractMethodDeclaration[typeDeclaration.methods.length - 1];
+ if (defaultConstructorIndex != 0){
+ System.arraycopy(typeDeclaration.methods, 0, methodDeclarations, 0, defaultConstructorIndex);
+ }
+ if (defaultConstructorIndex != typeDeclaration.methods.length-1){
+ System.arraycopy(
+ typeDeclaration.methods,
+ defaultConstructorIndex+1,
+ methodDeclarations,
+ defaultConstructorIndex,
+ typeDeclaration.methods.length - defaultConstructorIndex - 1);
+ }
+ typeDeclaration.methods = methodDeclarations;
+ } else {
+ if (!hasConstructor && !typeDeclaration.isInterface()) {// if was already reduced, then constructor
+ boolean insideFieldInitializer = false;
+ RecoveredElement parentElement = this.parent;
+ while (parentElement != null){
+ if (parentElement instanceof RecoveredField){
+ insideFieldInitializer = true;
+ break;
+ }
+ parentElement = parentElement.parent;
+ }
+ typeDeclaration.createsInternalConstructor(!parser().diet || insideFieldInitializer, true);
+ }
+ }
+ if (parent instanceof RecoveredType){
+ typeDeclaration.bits |= ASTNode.IsMemberTypeMASK;
+ } else if (parent instanceof RecoveredMethod){
+ typeDeclaration.bits |= ASTNode.IsLocalTypeMASK;
+ }
+ return typeDeclaration;
+}
+/*
+ * Update the corresponding parse node from parser state which
+ * is about to disappear because of restarting recovery
+ */
+public void updateFromParserState(){
+
+ if(this.bodyStartsAtHeaderEnd()){
+ Parser parser = this.parser();
+ /* might want to recover implemented interfaces */
+ // protection for bugs 15142
+ if (parser.listLength > 0 && parser.astLengthPtr > 0){ // awaiting interface type references
+ int length = parser.astLengthStack[parser.astLengthPtr];
+ int astPtr = parser.astPtr - length;
+ boolean canConsume = astPtr >= 0;
+ if(canConsume) {
+ if((!(parser.astStack[astPtr] instanceof TypeDeclaration))) {
+ canConsume = false;
+ }
+ for (int i = 1, max = length + 1; i < max; i++) {
+ if(!(parser.astStack[astPtr + i ] instanceof TypeReference)) {
+ canConsume = false;
+ }
+ }
+ }
+ if(canConsume) {
+ parser.consumeClassHeaderImplements();
+ // will reset typeListLength to zero
+ // thus this check will only be performed on first errorCheck after class X implements Y,Z,
+ }
+ }
+ }
+}
+/*
+ * A closing brace got consumed, might have closed the current element,
+ * in which case both the currentElement is exited
+ */
+public RecoveredElement updateOnClosingBrace(int braceStart, int braceEnd){
+ if ((--bracketBalance <= 0) && (parent != null)){
+ this.updateSourceEndIfNecessary(braceStart, braceEnd);
+ this.bodyEnd = braceStart - 1;
+ return parent;
+ }
+ return this;
+}
+/*
+ * An opening brace got consumed, might be the expected opening one of the current element,
+ * in which case the bodyStart is updated.
+ */
+public RecoveredElement updateOnOpeningBrace(int braceStart, int braceEnd){
+ /* in case the opening brace is not close enough to the signature, ignore it */
+ if (bracketBalance == 0){
+ /*
+ if (parser.scanner.searchLineNumber(typeDeclaration.sourceEnd)
+ != parser.scanner.searchLineNumber(braceEnd)){
+ */
+ Parser parser = this.parser();
+ switch(parser.lastIgnoredToken){
+ case -1 :
+ case TokenNameextends :
+ case TokenNameimplements :
+ if (parser.recoveredStaticInitializerStart == 0) break;
+ default:
+ this.foundOpeningBrace = true;
+ bracketBalance = 1; // pretend the brace was already there
+ }
+ }
+ // might be an initializer
+ if (this.bracketBalance == 1){
+ Block block = new Block(0);
+ Parser parser = this.parser();
+ block.sourceStart = parser.scanner.startPosition;
+ Initializer init;
+ if (parser.recoveredStaticInitializerStart == 0){
+ init = new Initializer(block, AccDefault);
+ } else {
+ init = new Initializer(block, AccStatic);
+ init.declarationSourceStart = parser.recoveredStaticInitializerStart;
+ }
+ init.bodyStart = parser.scanner.currentPosition;
+ return this.add(init, 1);
+ }
+ return super.updateOnOpeningBrace(braceStart, braceEnd);
+}
+public void updateParseTree(){
+ this.updatedTypeDeclaration();
+}
+/*
+ * Update the declarationSourceEnd of the corresponding parse node
+ */
+public void updateSourceEndIfNecessary(int start, int end){
+ if (this.typeDeclaration.declarationSourceEnd == 0){
+ this.bodyEnd = 0;
+ this.typeDeclaration.declarationSourceEnd = end;
+ this.typeDeclaration.bodyEnd = end;
+ }
+}
+}
projects / org.ibex.tool.git / blobdiff