Attachment #5324 for bug #22173

This Bugzilla instance is a read-only archive of historic NetBeans bug reports. To report a bug in NetBeans please follow the project's instructions for reporting issues.

View | Details | Raw Unified | Return to bug 22173
Collapse All | Expand All




 * @version 1.00
 */

public abstract class IncrementalAlgorithm extends Object {
    // most of the methods should be protected I guess
    
    /** Create the lexer input positioned to the location
     * of the begining of the token that would be returned
     * by the call to the <CODE>next()</CODE>.
     */
    public abstract LexerInput createInput();
    
    public abstract int relocate (int x);

    public abstract int readLookahead ();
    public abstract int readLookback ();
    public abstract Object readState ();
    
    public abstract void storeLookahead (int lookahead);
    public abstract void storeLookback (int lookback);
    public abstract void storeState (Object state);

    public abstract boolean hasNext ();
    public abstract boolean hasPrevious ();
    public abstract Token next ();
    public abstract Token previous ();
    
    public abstract void add (Token t);
    public abstract void remove ();

    /** Use incremental algorithm to update the list of tokens.
     * @param it token iterator that allows to iterate over the list of tokens

     * @param length length (and type) of the modification.<BR>
     *  &gt;0 means insert and &lt;0 means remove.
     */
    protected final void update(Lexer lexer, int offset, int length) {
        org.netbeans.modules.lexer.inc.Algorithm.INSTANCE.update(this, lexer, offset, length);
    }

}




package org.netbeans.modules.lexer.inc;

import org.netbeans.api.lexer.Token;
import org.netbeans.api.lexer.TokenIterator;
import org.netbeans.api.lexer.LexerInput;
import java.util.NoSuchElementException;


 * @version 1.00
 */

public abstract class AbstractTokenIterator extends org.netbeans.api.lexer.IncrementalAlgorithm {
    
    /** Empty array of tokens used initially as tokens array. */
    private static final Token[] EMPTY_TOKEN_ARRAY = new Token[0];

        return (iterIndex < getTokenCount());
    }

    public Token next() {
        try {
            Token token = tokenArray[getRawIndex(iterIndex)];
            lastRetIterIndex = iterIndex;

        return (iterIndex > 0);
    }

    public Token previous() {
        try {
            int prevIndex = iterIndex - 1;
            Token token = tokenArray[getRawIndex(prevIndex)];





import org.netbeans.api.lexer.Token;
import org.netbeans.api.lexer.TokenConstants;
import org.netbeans.api.lexer.IncrementalAlgorithm;
import org.netbeans.api.lexer.Lexer;
import org.netbeans.api.lexer.LexerInput;
import org.netbeans.modules.lexer.util.IntegerCache;

        return org.netbeans.modules.lexer.util.Compatibility.getLength(t);
    }

    protected int getLookahead(IncrementalAlgorithm it) {
        return it.readLookahead ();
    }

    protected int getLookback(IncrementalAlgorithm it) {
        return it.readLookback ();
        return (lb == null) ? -1 : lb.intValue();
    }
    
    protected Object getState(IncrementalAlgorithm it) {
        return it.readState ();
    }
    
    protected void setLookahead(IncrementalAlgorithm it, int lookahead) {
        it.storeLookahead (lookahead);
    }

    protected void setLookback(IncrementalAlgorithm it, int lookback) {
        it.storeLookback (lookback);
    }
    
    protected void setState(IncrementalAlgorithm it, Object state) {
        it.storeState (state);
    }
    
    public void update(IncrementalAlgorithm it, Lexer lexer, int offset, int length) {
        if (length == 0) {
            return;
        }

Lines 14-20 Link Here

(-)lexer/libsrc/org/netbeans/modules/lexer/inc/OffsetTokenIterator.java (-1 lines)
14	package org.netbeans.modules.lexer.inc;	14	package org.netbeans.modules.lexer.inc;
15		15
16	import org.netbeans.api.lexer.Token;	16	import org.netbeans.api.lexer.Token;
17	import org.netbeans.api.lexer.TokenIterator;
18	import org.netbeans.api.lexer.LexerInput;	17	import org.netbeans.api.lexer.LexerInput;
19		18
20	/**	19	/**

Lines 15-21 Link Here

(-)lexer/libsrc/org/netbeans/modules/lexer/inc/TextTokenIterator.java (-1 lines)
15		15
16	import org.netbeans.api.lexer.TokenId;	16	import org.netbeans.api.lexer.TokenId;
17	import org.netbeans.api.lexer.Token;	17	import org.netbeans.api.lexer.Token;
18	import org.netbeans.api.lexer.TokenIterator;
19	import org.netbeans.api.lexer.LexerInput;	18	import org.netbeans.api.lexer.LexerInput;
20	import org.netbeans.modules.lexer.inc.OffsetTokenIterator;	19	import org.netbeans.modules.lexer.inc.OffsetTokenIterator;
21		20

Lines 15-21 Link Here

(-)lexer/libsrc/org/netbeans/modules/lexer/swing/TokenDocument.java (-1 lines)
15		15
16	import javax.swing.text.StyledDocument;	16	import javax.swing.text.StyledDocument;
17	import org.netbeans.api.lexer.Language;	17	import org.netbeans.api.lexer.Language;
18	import org.netbeans.api.lexer.TokenIterator;
19		18
20	/**	19	/**
21	* Document maintaining the list of tokens over its text.	20	* Document maintaining the list of tokens over its text.

Return to bug 22173

Lines 41-47 Link Here

(-)lexer/libsrc/org/netbeans/api/lexer/IncrementalAlgorithm.java (-3 / +28 lines)
41	* @version 1.00	41	* @version 1.00
42	*/	42	*/
43		43
44	public class IncrementalAlgorithm {	44	public abstract class IncrementalAlgorithm extends Object {
		45	// most of the methods should be protected I guess
		46
		47	/** Create the lexer input positioned to the location
		48	* of the begining of the token that would be returned
		49	* by the call to the <CODE>next()</CODE>.
		50	*/
		51	public abstract LexerInput createInput();
		52
		53	public abstract int relocate (int x);
		54
		55	public abstract int readLookahead ();
		56	public abstract int readLookback ();
		57	public abstract Object readState ();
		58
		59	public abstract void storeLookahead (int lookahead);
		60	public abstract void storeLookback (int lookback);
		61	public abstract void storeState (Object state);
		62
		63	public abstract boolean hasNext ();
		64	public abstract boolean hasPrevious ();
		65	public abstract Token next ();
		66	public abstract Token previous ();
		67
		68	public abstract void add (Token t);
		69	public abstract void remove ();
45		70
46	/** Use incremental algorithm to update the list of tokens.	71	/** Use incremental algorithm to update the list of tokens.
47	* @param it token iterator that allows to iterate over the list of tokens	72	* @param it token iterator that allows to iterate over the list of tokens
Lines 50-57 Link Here
50	* @param length length (and type) of the modification.<BR>	75	* @param length length (and type) of the modification.<BR>
51	* >0 means insert and <0 means remove.	76	* >0 means insert and <0 means remove.
52	*/	77	*/
53	public static void update(TokenIterator it, Lexer lexer, int offset, int length) {	78	protected final void update(Lexer lexer, int offset, int length) {
54	org.netbeans.modules.lexer.inc.Algorithm.INSTANCE.update(it, lexer, offset, length);	79	org.netbeans.modules.lexer.inc.Algorithm.INSTANCE.update(this, lexer, offset, length);
55	}	80	}
56		81
57	}	82	}

Lines 15-21 Link Here

(-)lexer/libsrc/org/netbeans/modules/lexer/inc/Algorithm.java (-15 / +14 lines)
15		15
16	import org.netbeans.api.lexer.Token;	16	import org.netbeans.api.lexer.Token;
17	import org.netbeans.api.lexer.TokenConstants;	17	import org.netbeans.api.lexer.TokenConstants;
18	import org.netbeans.api.lexer.TokenIterator;	18	import org.netbeans.api.lexer.IncrementalAlgorithm;
19	import org.netbeans.api.lexer.Lexer;	19	import org.netbeans.api.lexer.Lexer;
20	import org.netbeans.api.lexer.LexerInput;	20	import org.netbeans.api.lexer.LexerInput;
21	import org.netbeans.modules.lexer.util.IntegerCache;	21	import org.netbeans.modules.lexer.util.IntegerCache;
Lines 46-77 Link Here
46	return org.netbeans.modules.lexer.util.Compatibility.getLength(t);	46	return org.netbeans.modules.lexer.util.Compatibility.getLength(t);
47	}	47	}
48		48
49	protected int getLookahead(TokenIterator it) {	49	protected int getLookahead(IncrementalAlgorithm it) {
50	return ((Integer)it.getAttribute(TokenConstants.LOOKAHEAD)).intValue();	50	return it.readLookahead ();
51	}	51	}
52		52
53	protected int getLookback(TokenIterator it) {	53	protected int getLookback(IncrementalAlgorithm it) {
54	Integer lb = (Integer)it.getAttribute(TokenConstants.LOOKBACK);	54	return it.readLookback ();
55	return (lb == null) ? -1 : lb.intValue();
56	}	55	}
57		56
58	protected Object getState(TokenIterator it) {	57	protected Object getState(IncrementalAlgorithm it) {
59	return it.getAttribute(TokenConstants.STATE);	58	return it.readState ();
60	}	59	}
61		60
62	protected void setLookahead(TokenIterator it, int lookahead) {	61	protected void setLookahead(IncrementalAlgorithm it, int lookahead) {
63	it.setAttribute(TokenConstants.LOOKAHEAD, getInteger(lookahead));	62	it.storeLookahead (lookahead);
64	}	63	}
65		64
66	protected void setLookback(TokenIterator it, int lookback) {	65	protected void setLookback(IncrementalAlgorithm it, int lookback) {
67	it.setAttribute(TokenConstants.LOOKBACK, getInteger(lookback));	66	it.storeLookback (lookback);
68	}	67	}
69		68
70	protected void setState(TokenIterator it, Object state) {	69	protected void setState(IncrementalAlgorithm it, Object state) {
71	it.setAttribute(TokenConstants.STATE, state);	70	it.storeState (state);
72	}	71	}
73		72
74	public void update(TokenIterator it, Lexer lexer, int offset, int length) {	73	public void update(IncrementalAlgorithm it, Lexer lexer, int offset, int length) {
75	if (length == 0) {	74	if (length == 0) {
76	return;	75	return;
77	}	76	}