]> git.uio.no Git - ifi-stolz-refaktor.git/blobdiff - case-study/jdt-after/ui/org/eclipse/jdt/internal/ui/text/JavaCodeReader.java
Case Study: adding data and statistics
[ifi-stolz-refaktor.git] / case-study / jdt-after / ui / org / eclipse / jdt / internal / ui / text / JavaCodeReader.java
diff --git a/case-study/jdt-after/ui/org/eclipse/jdt/internal/ui/text/JavaCodeReader.java b/case-study/jdt-after/ui/org/eclipse/jdt/internal/ui/text/JavaCodeReader.java
new file mode 100644 (file)
index 0000000..cfb3885
--- /dev/null
@@ -0,0 +1,290 @@
+/*******************************************************************************
+ * Copyright (c) 2000, 2011 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.jdt.internal.ui.text;
+
+
+import java.io.IOException;
+
+import org.eclipse.jface.internal.text.html.SingleCharReader;
+
+import org.eclipse.jface.text.BadLocationException;
+import org.eclipse.jface.text.Document;
+import org.eclipse.jface.text.IDocument;
+
+import org.eclipse.jdt.internal.ui.JavaPlugin;
+
+
+/**
+ * Reads from a document either forwards or backwards. May be configured to
+ * skip comments and strings.
+ */
+public class JavaCodeReader extends SingleCharReader {
+
+       /** The EOF character */
+       public static final int EOF= -1;
+
+       private boolean fSkipComments= false;
+       private boolean fSkipStrings= false;
+       private boolean fForward= false;
+
+       private IDocument fDocument;
+       private int fOffset;
+
+       private int fEnd= -1;
+       private int fCachedLineNumber= -1;
+       private int fCachedLineOffset= -1;
+
+
+       public JavaCodeReader() {
+       }
+
+       /**
+        * Returns the offset of the last read character. Should only be called after read has been called.
+        */
+       public int getOffset() {
+               return fForward ? fOffset -1 : fOffset;
+       }
+
+       public void configureForwardReader(IDocument document, int offset, int length, boolean skipComments, boolean skipStrings) throws IOException {
+               fDocument= document;
+               fOffset= offset;
+               fSkipComments= skipComments;
+               fSkipStrings= skipStrings;
+
+               fForward= true;
+               fEnd= Math.min(fDocument.getLength(), fOffset + length);
+       }
+
+       public void configureBackwardReader(IDocument document, int offset, boolean skipComments, boolean skipStrings) throws IOException {
+               fDocument= document;
+               fOffset= offset;
+               fSkipComments= skipComments;
+               fSkipStrings= skipStrings;
+
+               fForward= false;
+               try {
+                       fCachedLineNumber= fDocument.getLineOfOffset(fOffset);
+               } catch (BadLocationException x) {
+                       throw new IOException(x.getMessage());
+               }
+       }
+
+       /*
+        * @see Reader#close()
+        */
+       @Override
+       public void close() throws IOException {
+               fDocument= null;
+       }
+
+       /*
+        * @see SingleCharReader#read()
+        */
+       @Override
+       public int read() throws IOException {
+               try {
+                       return fForward ? readForwards() : readBackwards();
+               } catch (BadLocationException x) {
+                       throw new IOException(x.getMessage());
+               }
+       }
+
+       private void gotoCommentEnd() throws BadLocationException {
+               while (fOffset < fEnd) {
+                       char current= fDocument.getChar(fOffset++);
+                       if (current == '*') {
+                               if (fOffset < fEnd && fDocument.getChar(fOffset) == '/') {
+                                       ++ fOffset;
+                                       return;
+                               }
+                       }
+               }
+       }
+
+       private void gotoStringEnd(char delimiter) throws BadLocationException {
+               while (fOffset < fEnd) {
+                       char current= fDocument.getChar(fOffset++);
+                       if (current == '\\') {
+                               // ignore escaped characters
+                               ++ fOffset;
+                       } else if (current == delimiter) {
+                               return;
+                       }
+               }
+       }
+
+       private void gotoLineEnd() throws BadLocationException {
+               int line= fDocument.getLineOfOffset(fOffset);
+               fOffset= fDocument.getLineOffset(line + 1);
+       }
+
+       private int readForwards() throws BadLocationException {
+               while (fOffset < fEnd) {
+                       char current= fDocument.getChar(fOffset++);
+
+                       switch (current) {
+                               case '/':
+
+                                       if (fSkipComments && fOffset < fEnd) {
+                                               char next= fDocument.getChar(fOffset);
+                                               if (next == '*') {
+                                                       // a comment starts, advance to the comment end
+                                                       ++ fOffset;
+                                                       gotoCommentEnd();
+                                                       continue;
+                                               } else if (next == '/') {
+                                                       // '//'-comment starts, advance to the line end
+                                                       gotoLineEnd();
+                                                       continue;
+                                               }
+                                       }
+
+                                       return current;
+
+                               case '"':
+                               case '\'':
+
+                                       if (fSkipStrings) {
+                                               gotoStringEnd(current);
+                                               continue;
+                                       }
+
+                                       return current;
+                       }
+
+                       return current;
+               }
+
+               return EOF;
+       }
+
+       private void handleSingleLineComment() throws BadLocationException {
+               int line= fDocument.getLineOfOffset(fOffset);
+               if (line < fCachedLineNumber) {
+                       fCachedLineNumber= line;
+                       fCachedLineOffset= fDocument.getLineOffset(line);
+                       int offset= fOffset;
+                       while (fCachedLineOffset < offset) {
+                               char current= fDocument.getChar(offset--);
+                               if (current == '/' && fCachedLineOffset <= offset && fDocument.getChar(offset) == '/') {
+                                       fOffset= offset;
+                                       return;
+                               }
+                       }
+               }
+       }
+
+       private void gotoCommentStart() throws BadLocationException {
+               while (0 < fOffset) {
+                       char current= fDocument.getChar(fOffset--);
+                       if (current == '*' && 0 <= fOffset && fDocument.getChar(fOffset) == '/')
+                               return;
+               }
+       }
+
+       private void gotoStringStart(char delimiter) throws BadLocationException {
+               while (0 < fOffset) {
+                       char current= fDocument.getChar(fOffset);
+                       if (current == delimiter) {
+                               if ( !(0 <= fOffset && fDocument.getChar(fOffset -1) == '\\'))
+                                       return;
+                       }
+                       -- fOffset;
+               }
+       }
+
+       private int readBackwards() throws BadLocationException {
+
+               while (0 < fOffset) {
+                       -- fOffset;
+
+                       handleSingleLineComment();
+
+                       char current= fDocument.getChar(fOffset);
+                       switch (current) {
+                               case '/':
+
+                                       if (fSkipComments && fOffset > 1) {
+                                               char next= fDocument.getChar(fOffset - 1);
+                                               if (next == '*') {
+                                                       // a comment ends, advance to the comment start
+                                                       fOffset -= 2;
+                                                       gotoCommentStart();
+                                                       continue;
+                                               }
+                                       }
+
+                                       return current;
+
+                               case '"':
+                               case '\'':
+
+                                       if (fSkipStrings) {
+                                               -- fOffset;
+                                               gotoStringStart(current);
+                                               continue;
+                                       }
+
+                                       return current;
+                       }
+
+                       return current;
+               }
+
+               return EOF;
+       }
+
+       public int generated_2147504054850208463(IDocument document) {
+               int i;
+               try {
+                       configureForwardReader(document, 0, document.getLength(), true, false);
+                       int c= read();
+                       while (c != -1 && (c == '\r' || c == '\n' || c == '\t')) {
+                               c= read();
+                       }
+                       i= getOffset();
+                       close();
+               } catch (IOException ex) {
+                       i= 0;
+               } finally {
+                       try {
+                               close();
+                       } catch (IOException ex) {
+                               JavaPlugin.log(ex);
+                       }
+               }
+               return i;
+       }
+
+       public int generated_7874533990116476454(String source) {
+               IDocument document= new Document(source);
+               int i;
+               try {
+                       configureForwardReader(document, 0, document.getLength(), true, false);
+                       int c= read();
+                       while (c != -1 && (c == '\r' || c == '\n')) {
+                               c= read();
+                       }
+                       i= getOffset();
+                       close();
+               } catch (IOException ex) {
+                       i= 0;
+               } finally {
+                       try {
+                               close();
+                       } catch (IOException ex) {
+                               JavaPlugin.log(ex);
+                       }
+               }
+               return i;
+       }
+}
+