+++ /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.diagnose;
-
-import org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration;
-import org.eclipse.jdt.internal.compiler.ast.FieldDeclaration;
-import org.eclipse.jdt.internal.compiler.ast.Initializer;
-import org.eclipse.jdt.internal.compiler.ast.TypeDeclaration;
-import org.eclipse.jdt.internal.compiler.lookup.CompilerModifiers;
-
-public class RangeUtil {
-
- // flags
- public static final int NO_FLAG = 0;
- public static final int LBRACE_MISSING = 1;
- public static final int IGNORE = 2;
-
- static class RangeResult {
- private static final int INITIAL_SIZE = 10;
- int pos;
- int[] intervalStarts;
- int[] intervalEnds;
- int[] intervalFlags;
-
- RangeResult() {
- this.pos = 0;
- this.intervalStarts = new int[INITIAL_SIZE];
- this.intervalEnds = new int[INITIAL_SIZE];
- this.intervalFlags = new int[INITIAL_SIZE];
- }
-
- void addInterval(int start, int end){
- addInterval(start, end, NO_FLAG);
- }
-
- void addInterval(int start, int end, int flags){
- if(pos >= intervalStarts.length) {
- System.arraycopy(intervalStarts, 0, intervalStarts = new int[pos * 2], 0, pos);
- System.arraycopy(intervalEnds, 0, intervalEnds = new int[pos * 2], 0, pos);
- System.arraycopy(intervalFlags, 0, intervalFlags = new int[pos * 2], 0, pos);
- }
- intervalStarts[pos] = start;
- intervalEnds[pos] = end;
- intervalFlags[pos] = flags;
- pos++;
- }
-
- int[][] getRanges() {
- int[] resultStarts = new int[pos];
- int[] resultEnds = new int[pos];
- int[] resultFlags = new int[pos];
-
- System.arraycopy(intervalStarts, 0, resultStarts, 0, pos);
- System.arraycopy(intervalEnds, 0, resultEnds, 0, pos);
- System.arraycopy(intervalFlags, 0, resultFlags, 0, pos);
-
- if (resultStarts.length > 1) {
- quickSort(resultStarts, resultEnds, resultFlags, 0, resultStarts.length - 1);
- }
- return new int[][]{resultStarts, resultEnds, resultFlags};
- }
-
- private void quickSort(int[] list, int[] list2, int[] list3, int left, int right) {
- int original_left= left;
- int original_right= right;
- int mid= list[(left + right) / 2];
- do {
- while (compare(list[left], mid) < 0) {
- left++;
- }
- while (compare(mid, list[right]) < 0) {
- right--;
- }
- if (left <= right) {
- int tmp= list[left];
- list[left]= list[right];
- list[right]= tmp;
-
- tmp = list2[left];
- list2[left]= list2[right];
- list2[right]= tmp;
-
- tmp = list3[left];
- list3[left]= list3[right];
- list3[right]= tmp;
-
- left++;
- right--;
- }
- } while (left <= right);
-
- if (original_left < right) {
- quickSort(list, list2, list3, original_left, right);
- }
- if (left < original_right) {
- quickSort(list, list2, list3, left, original_right);
- }
- }
-
- private int compare(int i1, int i2) {
- return i1 - i2;
- }
- }
-
-
-
- public static boolean containsErrorInSignature(AbstractMethodDeclaration method){
- return method.sourceEnd + 1 == method.bodyStart || method.bodyEnd == method.declarationSourceEnd;
- }
-
- public static int[][] computeDietRange(TypeDeclaration[] types) {
- if(types == null || types.length == 0) {
- return new int[3][0];
- } else {
- RangeResult result = new RangeResult();
- computeDietRange0(types, result);
- return result.getRanges();
- }
- }
-
- private static void computeDietRange0(TypeDeclaration[] types, RangeResult result) {
- for (int j = 0; j < types.length; j++) {
- //members
- TypeDeclaration[] memberTypeDeclarations = types[j].memberTypes;
- if(memberTypeDeclarations != null && memberTypeDeclarations.length > 0) {
- computeDietRange0(types[j].memberTypes, result);
- }
- //methods
- AbstractMethodDeclaration[] methods = types[j].methods;
- if (methods != null) {
- int length = methods.length;
- for (int i = 0; i < length; i++) {
- AbstractMethodDeclaration method = methods[i];
- if(containsIgnoredBody(method)) {
- if(containsErrorInSignature(method)) {
- method.errorInSignature = true;
- result.addInterval(method.declarationSourceStart, method.declarationSourceEnd, IGNORE);
- } else {
- int flags = method.sourceEnd + 1 == method.bodyStart ? LBRACE_MISSING : NO_FLAG;
- result.addInterval(method.bodyStart, method.bodyEnd, flags);
- }
- }
- }
- }
-
- //initializers
- FieldDeclaration[] fields = types[j].fields;
- if (fields != null) {
- int length = fields.length;
- for (int i = 0; i < length; i++) {
- if (fields[i] instanceof Initializer) {
- Initializer initializer = (Initializer)fields[i];
- if(initializer.declarationSourceEnd == initializer.bodyEnd){
- initializer.errorInSignature = true;
- result.addInterval(initializer.declarationSourceStart, initializer.declarationSourceEnd, IGNORE);
- } else {
- result.addInterval(initializer.bodyStart, initializer.bodyEnd);
- }
- }
- }
- }
- }
- }
-
- public static boolean isInInterval(int start, int end, int[] intervalStart, int[] intervalEnd) {
- int length = intervalStart.length;
- for (int i = 0; i < length; i++) {
- if(intervalStart[i] <= start && intervalEnd[i] >= end) {
- return true;
- } else if(intervalStart[i] > end) {
- return false;
- }
- }
- return false;
- }
-
- public static int getPreviousInterval(int start, int end, int[] intervalStart, int[] intervalEnd) {
- int length = intervalStart.length;
- for (int i = 0; i < length; i++) {
- if(intervalStart[i] > end) {
- return i - 1;
- }
- }
- return length - 1;
- }
-
- public static boolean containsIgnoredBody(AbstractMethodDeclaration method){
- return !method.isDefaultConstructor()
- && !method.isClinit()
- && (method.modifiers & CompilerModifiers.AccSemicolonBody) == 0;
- }
-}
projects / org.ibex.tool.git / blobdiff