/* * SimpleEditorDocument.java * * Created on 23 novembre 2006, 17:03 * * To change this template, choose Tools | Template Manager * and open the template in the editor. */package simpleeditor;import antlr.LexerSharedInputState;import antlr.Token;import antlr.TokenStreamException;import com.sun.java_cup.internal.runtime.Scanner;import simpleeditor.lexer.JavaLexer;import java.io.IOException;import java.io.InputStream;import javax.swing.event.DocumentEvent;import javax.swing.text.AttributeSet;import javax.swing.text.BadLocationException;import javax.swing.text.Element;import javax.swing.text.GapContent;import javax.swing.text.PlainDocument;import javax.swing.text.Segment;/** * * @author YVZOU */public class SimpleEditorDocument extends PlainDocument { /** Creates a new instance of SimpleEditorDocument */ public SimpleEditorDocument() { super(new GapContent(1024)); } public SimpleEditorLexer createLexer() { try { return new SimpleEditorLexer(); } catch (IOException ex) { return null; } } public int getScannerStart(int p) { Element elem = getDefaultRootElement(); int lineNum = elem.getElementIndex(p); Element line = elem.getElement(lineNum); return line.getStartOffset(); } /** * Updates document structure as a result of text insertion. This * will happen within a write lock. The superclass behavior of * updating the line map is executed followed by marking any comment * areas that should backtracked before scanning. * * @param chng the change event * @param attr the set of attributes */ protected void insertUpdate(DefaultDocumentEvent chng, AttributeSet attr) { super.insertUpdate(chng, attr); // update comment marks Element root = getDefaultRootElement(); DocumentEvent.ElementChange ec = chng.getChange(root); if (ec != null) { Element[] added = ec.getChildrenAdded(); boolean inComment = false; for (int i = 0; i < added.length; i++) { Element elem = added[i]; int p0 = elem.getStartOffset(); int p1 = elem.getEndOffset(); String s; try { s = getText(p0, p1 - p0); } catch (BadLocationException bl) { s = null; } } } } /** * Updates any document structure as a result of text removal. * This will happen within a write lock. The superclass behavior of * updating the line map is executed followed by placing a lexical * update command on the analyzer queue. * * @param chng the change event */ protected void removeUpdate(DefaultDocumentEvent chng) { super.removeUpdate(chng); } class DocumentInputStream extends InputStream { Segment segment; int p0; // start position int p1; // end position int pos; // pos in document int index; // index into array of the segment public DocumentInputStream(int p0, int p1) { this.segment = new Segment(); this.p0 = p0; this.p1 = Math.min(getLength(), p1); pos = p0; try { loadSegment(); } catch (IOException ioe) { throw new Error("unexpected: " + ioe); } } /** * Reads the next byte of data from this input stream. The value * byte is returned as an <code>int</code> in the range * <code>0</code> to <code>255</code>. If no byte is available * because the end of the stream has been reached, the value * <code>-1</code> is returned. This method blocks until input data * is available, the end of the stream is detected, or an exception * is thrown. * <p> * A subclass must provide an implementation of this method. * * @return the next byte of data, or <code>-1</code> if the end of the * stream is reached. * @exception IOException if an I/O error occurs. * @since JDK1.0 */ public int read() throws IOException { if (index >= (segment.offset + segment.count)) { if (pos >= p1) { // no more data return -1; } loadSegment(); } return segment.array[index++]; } void loadSegment() throws IOException { try { int n = Math.min(1024, p1 - pos); getText(pos, n, segment); pos += n; index = segment.offset; } catch (BadLocationException e) { throw new IOException("Bad location"); } } int getPosition() { return pos; } } public class SimpleEditorLexer { private JavaLexer lexer; private DocumentInputStream is; Token t; int p0; SimpleEditorLexer() throws IOException { is = new DocumentInputStream(0, getLength()); lexer = new JavaLexer(is); } /** * Sets the range of the scanner. This should be called * to reinitialize the scanner to the desired range of * coverage. */ public void setRange(int p0, int p1) throws IOException { is = new DocumentInputStream(p0, p1); lexer = new JavaLexer(is); this.p0 = p0; } /** * This fetches the starting location of the current * token in the document. */ public final int getStartOffset() { int begOffs = 0;//(int) (is.getPosition()); return p0 + begOffs; } /** * This fetches the ending location of the current * token in the document. */ public final int getEndOffset() { int endOffs = (int) (is.getPosition()); int end = p0 + endOffs; System.out.println("end:" + end); return end; } void scan() { try { // System.out.println("Lexer valide " + (lexer!=null)); t = lexer.nextToken(); } catch (TokenStreamException ex) { return; } } Token getCurrentToken() { return t; } }}