| gvSIG desktop 1

package com.iver.utiles.console.jedit;

/*

 * JavaScriptTokenMarker.java - JavaScript token marker

 * Copyright (C) 1999 Slava Pestov

 *

 * You may use and modify this package for any purpose. Redistribution is

 * permitted, in both source and binary form, provided that this notice

 * remains intact in all source distributions of this package.

 */

import javax.swing.text.Segment;

/**

 * JavaScript token marker.

 *

 * @author Slava Pestov

 * @version $Id$

 */

public class JavaScriptTokenMarker extends CTokenMarker

{

	public JavaScriptTokenMarker()

	{

		super(false,getKeywords());

	}

	public static KeywordMap getKeywords()

	{

		if(javaScriptKeywords == null)

		{

			javaScriptKeywords = new KeywordMap(false);

			javaScriptKeywords.add("function",Token.KEYWORD3);

			javaScriptKeywords.add("var",Token.KEYWORD3);

			javaScriptKeywords.add("else",Token.KEYWORD1);

			javaScriptKeywords.add("for",Token.KEYWORD1);

			javaScriptKeywords.add("if",Token.KEYWORD1);

			javaScriptKeywords.add("in",Token.KEYWORD1);

			javaScriptKeywords.add("new",Token.KEYWORD1);

			javaScriptKeywords.add("return",Token.KEYWORD1);

			javaScriptKeywords.add("while",Token.KEYWORD1);

			javaScriptKeywords.add("with",Token.KEYWORD1);

			javaScriptKeywords.add("break",Token.KEYWORD1);

			javaScriptKeywords.add("case",Token.KEYWORD1);

			javaScriptKeywords.add("continue",Token.KEYWORD1);

			javaScriptKeywords.add("default",Token.KEYWORD1);

			javaScriptKeywords.add("false",Token.LABEL);

			javaScriptKeywords.add("this",Token.LABEL);

			javaScriptKeywords.add("true",Token.LABEL);

		}

		return javaScriptKeywords;

	}

	// private members

	private static KeywordMap javaScriptKeywords;

}

package com.iver.utiles.console.jedit;

/*

 * IDLTokenMarker.java - IDL token marker

 * Copyright (C) 1999 Slava Pestov

 * Copyright (C) 1999 Juha Lindfors

 *

 * You may use and modify this package for any purpose. Redistribution is

 * permitted, in both source and binary form, provided that this notice

 * remains intact in all source distributions of this package.

 */

import javax.swing.text.Segment;

/**

 * IDL token marker.

 *

 * @author Slava Pestov

 * @author Juha Lindfors

 * @version $Id$

 */

public class IDLTokenMarker extends CTokenMarker

{

	public IDLTokenMarker()

	{

		super(true,getKeywords());

	}

	public static KeywordMap getKeywords()

	{

		if(idlKeywords == null)

		{

			idlKeywords = new KeywordMap(false);

			idlKeywords.add("any",      Token.KEYWORD3);

			idlKeywords.add("attribute",Token.KEYWORD1);

			idlKeywords.add("boolean",  Token.KEYWORD3);

			idlKeywords.add("case",     Token.KEYWORD1);

			idlKeywords.add("char",     Token.KEYWORD3);

			idlKeywords.add("const",    Token.KEYWORD1);

			idlKeywords.add("context",  Token.KEYWORD1);

			idlKeywords.add("default",  Token.KEYWORD1);

			idlKeywords.add("double",   Token.KEYWORD3);

			idlKeywords.add("enum",     Token.KEYWORD3);

			idlKeywords.add("exception",Token.KEYWORD1);

			idlKeywords.add("FALSE",    Token.LITERAL2);

			idlKeywords.add("fixed",    Token.KEYWORD1);

			idlKeywords.add("float",    Token.KEYWORD3);

			idlKeywords.add("in",       Token.KEYWORD1);

			idlKeywords.add("inout",    Token.KEYWORD1);

			idlKeywords.add("interface",Token.KEYWORD1);

			idlKeywords.add("long",     Token.KEYWORD3);

			idlKeywords.add("module",   Token.KEYWORD1);

			idlKeywords.add("Object",   Token.KEYWORD3);

			idlKeywords.add("octet",    Token.KEYWORD3);

			idlKeywords.add("oneway",   Token.KEYWORD1);

			idlKeywords.add("out",      Token.KEYWORD1);

			idlKeywords.add("raises",   Token.KEYWORD1);

			idlKeywords.add("readonly", Token.KEYWORD1);

			idlKeywords.add("sequence", Token.KEYWORD3);

			idlKeywords.add("short",    Token.KEYWORD3);

			idlKeywords.add("string",   Token.KEYWORD3);

			idlKeywords.add("struct",   Token.KEYWORD3);

			idlKeywords.add("switch",   Token.KEYWORD1);

			idlKeywords.add("TRUE",     Token.LITERAL2);

			idlKeywords.add("typedef",  Token.KEYWORD3);

			idlKeywords.add("unsigned", Token.KEYWORD3);

			idlKeywords.add("union",    Token.KEYWORD3);

			idlKeywords.add("void",     Token.KEYWORD3);

			idlKeywords.add("wchar",    Token.KEYWORD3);

			idlKeywords.add("wstring",  Token.KEYWORD3);

		}

		return idlKeywords;

	}

	// private members

	private static KeywordMap idlKeywords;

}

package com.iver.utiles.console.jedit;

/*

 * MakefileTokenMarker.java - Makefile token marker

 * Copyright (C) 1998, 1999 Slava Pestov

 *

 * You may use and modify this package for any purpose. Redistribution is

 * permitted, in both source and binary form, provided that this notice

 * remains intact in all source distributions of this package.

 */

import javax.swing.text.Segment;

/**

 * Makefile token marker.

 *

 * @author Slava Pestov

 * @version $Id$

 */

public class MakefileTokenMarker extends TokenMarker

{

	// public members

	public byte markTokensImpl(byte token, Segment line, int lineIndex)

	{

		char[] array = line.array;

		int offset = line.offset;

		int lastOffset = offset;

		int length = line.count + offset;

		boolean backslash = false;

loop:		for(int i = offset; i < length; i++)

		{

			int i1 = (i+1);

			char c = array[i];

			if(c == '\\')

			{

				backslash = !backslash;

				continue;

			}

			switch(token)

			{

			case Token.NULL:

				switch(c)

				{

				case ':': case '=': case ' ': case '\t':

					backslash = false;

					if(lastOffset == offset)

					{

						addToken(i1 - lastOffset,Token.KEYWORD1);

						lastOffset = i1;

					}

					break;

				case '#':

					if(backslash)

						backslash = false;

					else

					{

						addToken(i - lastOffset,token);

						addToken(length - i,Token.COMMENT1);

						lastOffset = length;

						break loop;

					}

					break;

				case '$':

					if(backslash)

						backslash = false;

					else if(lastOffset != offset)

					{

						addToken(i - lastOffset,token);

						lastOffset = i;

						if(length - i > 1)

						{

							char c1 = array[i1];

							if(c1 == '(' || c1 == '{')

								token = Token.KEYWORD2;

							else

							{

								addToken(2,Token.KEYWORD2);

								lastOffset += 2;

								i++;

							}

						}

					}

					break;

				case '"':

					if(backslash)

						backslash = false;

					else

					{

						addToken(i - lastOffset,token);

						token = Token.LITERAL1;

						lastOffset = i;

					}

					break;

				case '\'':

					if(backslash)

						backslash = false;

					else

					{

						addToken(i - lastOffset,token);

						token = Token.LITERAL2;

						lastOffset = i;

					}

					break;

				default:

					backslash = false;

					break;

				}

			case Token.KEYWORD2:

				backslash = false;

				if(c == ')' || c == '}')

				{

					addToken(i1 - lastOffset,token);

					token = Token.NULL;

					lastOffset = i1;

				}

				break;

			case Token.LITERAL1:

				if(backslash)

					backslash = false;

				else if(c == '"')

				{

					addToken(i1 - lastOffset,token);

					token = Token.NULL;

					lastOffset = i1;

				}

				else

					backslash = false;

				break;

			case Token.LITERAL2:

				if(backslash)

					backslash = false;

				else if(c == '\'')

				{

					addToken(i1 - lastOffset,Token.LITERAL1);

					token = Token.NULL;

					lastOffset = i1;

				}

				else

					backslash = false;

				break;

			}

		}

		switch(token)

		{

		case Token.KEYWORD2:

			addToken(length - lastOffset,Token.INVALID);

			token = Token.NULL;

			break;

		case Token.LITERAL2:

			addToken(length - lastOffset,Token.LITERAL1);

			break;

		default:

			addToken(length - lastOffset,token);

			break;

		}

		return token;

	}

}

package com.iver.utiles.console.jedit;

/*

 * TextUtilities.java - Utility functions used by the text area classes

 * Copyright (C) 1999 Slava Pestov

 *

 * You may use and modify this package for any purpose. Redistribution is

 * permitted, in both source and binary form, provided that this notice

 * remains intact in all source distributions of this package.

 */

import javax.swing.text.*;

/**

 * Class with several utility functions used by the text area component.

 * @author Slava Pestov

 * @version $Id$

 */

public class TextUtilities

{

	/**

	 * Returns the offset of the bracket matching the one at the

	 * specified offset of the document, or -1 if the bracket is

	 * unmatched (or if the character is not a bracket).

	 * @param doc The document

	 * @param offset The offset

	 * @exception BadLocationException If an out-of-bounds access

	 * was attempted on the document text

	 */

	public static int findMatchingBracket(Document doc, int offset)

		throws BadLocationException

	{

		if(doc.getLength() == 0)

			return -1;

		char c = doc.getText(offset,1).charAt(0);

		char cprime; // c` - corresponding character

		boolean direction; // true = back, false = forward

		switch(c)

		{

		case '(': cprime = ')'; direction = false; break;

		case ')': cprime = '('; direction = true; break;

		case '[': cprime = ']'; direction = false; break;

		case ']': cprime = '['; direction = true; break;

		case '{': cprime = '}'; direction = false; break;

		case '}': cprime = '{'; direction = true; break;

		default: return -1;

		}

		int count;

		// How to merge these two cases is left as an exercise

		// for the reader.

		// Go back or forward

		if(direction)

		{

			// Count is 1 initially because we have already

			// `found' one closing bracket

			count = 1;

			// Get text[0,offset-1];

			String text = doc.getText(0,offset);

			// Scan backwards

			for(int i = offset - 1; i >= 0; i--)

			{

				// If text[i] == c, we have found another

				// closing bracket, therefore we will need

				// two opening brackets to complete the

				// match.

				char x = text.charAt(i);

				if(x == c)

					count++;

				// If text[i] == cprime, we have found a

				// opening bracket, so we return i if

				// --count == 0

				else if(x == cprime)

				{

					if(--count == 0)

						return i;

				}

			}

		}

		else

		{

			// Count is 1 initially because we have already

			// `found' one opening bracket

			count = 1;

			// So we don't have to + 1 in every loop

			offset++;

			// Number of characters to check

			int len = doc.getLength() - offset;

			// Get text[offset+1,len];

			String text = doc.getText(offset,len);

			// Scan forwards

			for(int i = 0; i < len; i++)

			{

				// If text[i] == c, we have found another

				// opening bracket, therefore we will need

				// two closing brackets to complete the

				// match.

				char x = text.charAt(i);

				if(x == c)

					count++;

				// If text[i] == cprime, we have found an

				// closing bracket, so we return i if

				// --count == 0

				else if(x == cprime)

				{

					if(--count == 0)

						return i + offset;

				}

			}

		}

		// Nothing found

		return -1;

	}

	/**

	 * Locates the start of the word at the specified position.

	 * @param line The text

	 * @param pos The position

	 */

	public static int findWordStart(String line, int pos, String noWordSep)

	{

		char ch = line.charAt(pos - 1);

		if(noWordSep == null)

			noWordSep = "";

		boolean selectNoLetter = (!Character.isLetterOrDigit(ch)

			&& noWordSep.indexOf(ch) == -1);

		int wordStart = 0;

		for(int i = pos - 1; i >= 0; i--)

		{

			ch = line.charAt(i);

			if(selectNoLetter ^ (!Character.isLetterOrDigit(ch) &&

				noWordSep.indexOf(ch) == -1))

			{

				wordStart = i + 1;

				break;

			}

		}

		return wordStart;

	}

	/**

	 * Locates the end of the word at the specified position.

	 * @param line The text

	 * @param pos The position

	 */

	public static int findWordEnd(String line, int pos, String noWordSep)

	{

		char ch = line.charAt(pos);

		if(noWordSep == null)

			noWordSep = "";

		boolean selectNoLetter = (!Character.isLetterOrDigit(ch)

			&& noWordSep.indexOf(ch) == -1);

		int wordEnd = line.length();

		for(int i = pos; i < line.length(); i++)

		{

			ch = line.charAt(i);

			if(selectNoLetter ^ (!Character.isLetterOrDigit(ch) &&

				noWordSep.indexOf(ch) == -1))

			{

				wordEnd = i;

				break;

			}

		}

		return wordEnd;

	}

}

package com.iver.utiles.console.jedit;

/*

 * Token.java - Generic token

 * Copyright (C) 1998, 1999 Slava Pestov

 *

 * You may use and modify this package for any purpose. Redistribution is

 * permitted, in both source and binary form, provided that this notice

 * remains intact in all source distributions of this package.

 */

/**

 * A linked list of tokens. Each token has three fields - a token

 * identifier, which is a byte value that can be looked up in the

 * array returned by <code>SyntaxDocument.getColors()</code>

 * to get a color value, a length value which is the length of the

 * token in the text, and a pointer to the next token in the list.

 *

 * @author Slava Pestov

 * @version $Id$

 */

public class Token

{

	/**

	 * Normal text token id. This should be used to mark

	 * normal text.

	 */

	public static final byte NULL = 0;

	/**

	 * Comment 1 token id. This can be used to mark a comment.

	 */

	public static final byte COMMENT1 = 1;

	/**

	 * Comment 2 token id. This can be used to mark a comment.

	 */

	public static final byte COMMENT2 = 2;

	/**

	 * Literal 1 token id. This can be used to mark a string

	 * literal (eg, C mode uses this to mark "..." literals)

	 */

	public static final byte LITERAL1 = 3;

	/**

	 * Literal 2 token id. This can be used to mark an object

	 * literal (eg, Java mode uses this to mark true, false, etc)

	 */

	public static final byte LITERAL2 = 4;

	/**

	 * Label token id. This can be used to mark labels

	 * (eg, C mode uses this to mark ...: sequences)

	 */

	public static final byte LABEL = 5;

	/**

	 * Keyword 1 token id. This can be used to mark a

	 * keyword. This should be used for general language

	 * constructs.

	 */

	public static final byte KEYWORD1 = 6;

	/**

	 * Keyword 2 token id. This can be used to mark a

	 * keyword. This should be used for preprocessor

	 * commands, or variables.

	 */

	public static final byte KEYWORD2 = 7;

	/**

	 * Keyword 3 token id. This can be used to mark a

	 * keyword. This should be used for data types.

	 */

	public static final byte KEYWORD3 = 8;

	/**

	 * Operator token id. This can be used to mark an

	 * operator. (eg, SQL mode marks +, -, etc with this

	 * token type)

	 */

	public static final byte OPERATOR = 9;

	/**

	 * Invalid token id. This can be used to mark invalid

	 * or incomplete tokens, so the user can easily spot

	 * syntax errors.

	 */

	public static final byte INVALID = 10;

	/**

	 * The total number of defined token ids.

	 */

	public static final byte ID_COUNT = 11;

	/**

	 * The first id that can be used for internal state

	 * in a token marker.

	 */

	public static final byte INTERNAL_FIRST = 100;

	/**

	 * The last id that can be used for internal state

	 * in a token marker.

	 */

	public static final byte INTERNAL_LAST = 126;

	/**

	 * The token type, that along with a length of 0

	 * marks the end of the token list.

	 */

	public static final byte END = 127;

	/**

	 * The length of this token.

	 */

	public int length;

	/**

	 * The id of this token.

	 */

	public byte id;

	/**

	 * The next token in the linked list.

	 */

	public Token next;

	/**

	 * Creates a new token.

	 * @param length The length of the token

	 * @param id The id of the token

	 */

	public Token(int length, byte id)

	{

		this.length = length;

		this.id = id;

	}

	/**

	 * Returns a string representation of this token.

	 */

	public String toString()

	{

		return "[id=" + id + ",length=" + length + "]";

	}

}

package com.iver.utiles.console.jedit;

/*

 * TokenMarker.java - Generic token marker

 * Copyright (C) 1998, 1999 Slava Pestov

 *

 * You may use and modify this package for any purpose. Redistribution is

 * permitted, in both source and binary form, provided that this notice

 * remains intact in all source distributions of this package.

 */

import javax.swing.text.Segment;

import java.util.*;

/**

 * A token marker that splits lines of text into tokens. Each token carries

 * a length field and an indentification tag that can be mapped to a color

 * for painting that token.<p>

 *

 * For performance reasons, the linked list of tokens is reused after each

 * line is tokenized. Therefore, the return value of <code>markTokens</code>

 * should only be used for immediate painting. Notably, it cannot be

 * cached.

 *

 * @author Slava Pestov

 * @version $Id$

 *

 * @see org.gjt.sp.jedit.syntax.Token

 */

public abstract class TokenMarker

{

	/**

	 * A wrapper for the lower-level <code>markTokensImpl</code> method

	 * that is called to split a line up into tokens.

	 * @param line The line

	 * @param lineIndex The line number

	 */

	public Token markTokens(Segment line, int lineIndex)

	{

		if(lineIndex >= length)

		{

			throw new IllegalArgumentException("Tokenizing invalid line: "

				+ lineIndex);

		}

		lastToken = null;

		LineInfo info = lineInfo[lineIndex];

		LineInfo prev;

		if(lineIndex == 0)

			prev = null;

		else

			prev = lineInfo[lineIndex - 1];

		byte oldToken = info.token;

		byte token = markTokensImpl(prev == null ?

			Token.NULL : prev.token,line,lineIndex);

		info.token = token;

		/*

		 * This is a foul hack. It stops nextLineRequested

		 * from being cleared if the same line is marked twice.

		 *

		 * Why is this necessary? It's all JEditTextArea's fault.

		 * When something is inserted into the text, firing a

		 * document event, the insertUpdate() method shifts the

		 * caret (if necessary) by the amount inserted.

		 *

		 * All caret movement is handled by the select() method,

		 * which eventually pipes the new position to scrollTo()

		 * and calls repaint().

		 *

		 * Note that at this point in time, the new line hasn't

		 * yet been painted; the caret is moved first.

		 *

		 * scrollTo() calls offsetToX(), which tokenizes the line

		 * unless it is being called on the last line painted

		 * (in which case it uses the text area's painter cached

		 * token list). What scrollTo() does next is irrelevant.

		 *

		 * After scrollTo() has done it's job, repaint() is

		 * called, and eventually we end up in paintLine(), whose

		 * job is to paint the changed line. It, too, calls

		 * markTokens().

		 *

		 * The problem was that if the line started a multiline

		 * token, the first markTokens() (done in offsetToX())

		 * would set nextLineRequested (because the line end

		 * token had changed) but the second would clear it

		 * (because the line was the same that time) and therefore

		 * paintLine() would never know that it needed to repaint

		 * subsequent lines.

		 *

		 * This bug took me ages to track down, that's why I wrote

		 * all the relevant info down so that others wouldn't

		 * duplicate it.

		 */

		 if(!(lastLine == lineIndex && nextLineRequested))

			nextLineRequested = (oldToken != token);

		lastLine = lineIndex;

		addToken(0,Token.END);

		return firstToken;

	}

	/**

	 * An abstract method that splits a line up into tokens. It

	 * should parse the line, and call <code>addToken()</code> to

	 * add syntax tokens to the token list. Then, it should return

	 * the initial token type for the next line.<p>

	 *

	 * For example if the current line contains the start of a 

	 * multiline comment that doesn't end on that line, this method

	 * should return the comment token type so that it continues on

	 * the next line.

	 *

	 * @param token The initial token type for this line

	 * @param line The line to be tokenized

	 * @param lineIndex The index of the line in the document,

	 * starting at 0

	 * @return The initial token type for the next line

	 */

	protected abstract byte markTokensImpl(byte token, Segment line,

		int lineIndex);

	/**

	 * Returns if the token marker supports tokens that span multiple

	 * lines. If this is true, the object using this token marker is

	 * required to pass all lines in the document to the

	 * <code>markTokens()</code> method (in turn).<p>

	 *

	 * The default implementation returns true; it should be overridden

	 * to return false on simpler token markers for increased speed.

	 */

	public boolean supportsMultilineTokens()

	{

		return true;

	}

	/**

	 * Informs the token marker that lines have been inserted into

	 * the document. This inserts a gap in the <code>lineInfo</code>

	 * array.

	 * @param index The first line number

	 * @param lines The number of lines 

	 */

	public void insertLines(int index, int lines)

	{

		if(lines <= 0)

			return;

		length += lines;

		ensureCapacity(length);

		int len = index + lines;

		System.arraycopy(lineInfo,index,lineInfo,len,

			lineInfo.length - len);

		for(int i = index + lines - 1; i >= index; i--)

		{

			lineInfo[i] = new LineInfo();

		}

	}

	/**

	 * Informs the token marker that line have been deleted from

	 * the document. This removes the lines in question from the

	 * <code>lineInfo</code> array.

	 * @param index The first line number

	 * @param lines The number of lines

	 */

	public void deleteLines(int index, int lines)

	{

		if (lines <= 0)

			return;

		int len = index + lines;

		length -= lines;

		System.arraycopy(lineInfo,len,lineInfo,

			index,lineInfo.length - len);

	}

	/**

	 * Returns the number of lines in this token marker.

	 */

	public int getLineCount()

	{

		return length;

	}

	/**

	 * Returns true if the next line should be repainted. This

	 * will return true after a line has been tokenized that starts

	 * a multiline token that continues onto the next line.

	 */

	public boolean isNextLineRequested()

	{

		return nextLineRequested;

	}

	// protected members

	/**

	 * The first token in the list. This should be used as the return

	 * value from <code>markTokens()</code>.

	 */

	protected Token firstToken;

	/**

	 * The last token in the list. New tokens are added here.

	 * This should be set to null before a new line is to be tokenized.

	 */

	protected Token lastToken;

	/**

	 * An array for storing information about lines. It is enlarged and

	 * shrunk automatically by the <code>insertLines()</code> and

	 * <code>deleteLines()</code> methods.

	 */

	protected LineInfo[] lineInfo;

	/**

	 * The number of lines in the model being tokenized. This can be

	 * less than the length of the <code>lineInfo</code> array.

	 */

	protected int length;

	/**

	 * The last tokenized line.

	 */

	protected int lastLine;

	/**

	 * True if the next line should be painted.

	 */

	protected boolean nextLineRequested;

	/**

	 * Creates a new <code>TokenMarker</code>. This DOES NOT create

	 * a lineInfo array; an initial call to <code>insertLines()</code>

	 * does that.

	 */

	protected TokenMarker()

	{

		lastLine = -1;

	}

	/**

	 * Ensures that the <code>lineInfo</code> array can contain the

	 * specified index. This enlarges it if necessary. No action is

	 * taken if the array is large enough already.<p>

	 *

	 * It should be unnecessary to call this under normal

	 * circumstances; <code>insertLine()</code> should take care of

	 * enlarging the line info array automatically.

	 *

	 * @param index The array index

	 */

	protected void ensureCapacity(int index)

	{

		if(lineInfo == null)

			lineInfo = new LineInfo[index + 1];

		else if(lineInfo.length <= index)

		{

			LineInfo[] lineInfoN = new LineInfo[(index + 1) * 2];

			System.arraycopy(lineInfo,0,lineInfoN,0,

					 lineInfo.length);

			lineInfo = lineInfoN;

		}

	}

	/**

	 * Adds a token to the token list.

	 * @param length The length of the token

	 * @param id The id of the token

	 */

	protected void addToken(int length, byte id)

	{

		if(id >= Token.INTERNAL_FIRST && id <= Token.INTERNAL_LAST)

			throw new InternalError("Invalid id: " + id);

		if(length == 0 && id != Token.END)

			return;

		if(firstToken == null)

		{

			firstToken = new Token(length,id);

			lastToken = firstToken;

		}

		else if(lastToken == null)

		{

			lastToken = firstToken;

			firstToken.length = length;

			firstToken.id = id;

		}

		else if(lastToken.next == null)

		{

			lastToken.next = new Token(length,id);

			lastToken = lastToken.next;

		}

		else

		{

			lastToken = lastToken.next;

			lastToken.length = length;

			lastToken.id = id;

		}

	}

	/**

	 * Inner class for storing information about tokenized lines.

	 */

	public class LineInfo

	{

		/**

		 * Creates a new LineInfo object with token = Token.NULL

		 * and obj = null.

		 */

		public LineInfo()

		{

		}

		/**

		 * Creates a new LineInfo object with the specified

		 * parameters.

		 */

		public LineInfo(byte token, Object obj)

		{

			this.token = token;

			this.obj = obj;

		}

		/**

		 * The id of the last token of the line.

		 */

		public byte token;

		/**

		 * This is for use by the token marker implementations

		 * themselves. It can be used to store anything that

		 * is an object and that needs to exist on a per-line

		 * basis.

		 */

		public Object obj;

	}

}

package com.iver.utiles.console.jedit;

/*

 * SyntaxUtilities.java - Utility functions used by syntax colorizing

 * Copyright (C) 1999 Slava Pestov

 *

 * You may use and modify this package for any purpose. Redistribution is

 * permitted, in both source and binary form, provided that this notice

 * remains intact in all source distributions of this package.

 */

import javax.swing.text.*;

import java.awt.*;

/**

 * Class with several utility functions used by jEdit's syntax colorizing

 * subsystem.

 *

 * @author Slava Pestov

 * @version $Id$

 */

public class SyntaxUtilities

{

	/**

	 * Checks if a subregion of a <code>Segment</code> is equal to a

	 * string.

	 * @param ignoreCase True if case should be ignored, false otherwise

	 * @param text The segment

	 * @param offset The offset into the segment

	 * @param match The string to match

	 */

	public static boolean regionMatches(boolean ignoreCase, Segment text,

					    int offset, String match)

	{

		int length = offset + match.length();

		char[] textArray = text.array;

		if(length > text.offset + text.count)

			return false;

		for(int i = offset, j = 0; i < length; i++, j++)

		{

			char c1 = textArray[i];

			char c2 = match.charAt(j);

			if(ignoreCase)

			{

				c1 = Character.toUpperCase(c1);

				c2 = Character.toUpperCase(c2);

			}

			if(c1 != c2)

				return false;

		}

		return true;

	}

	/**

	 * Checks if a subregion of a <code>Segment</code> is equal to a

	 * character array.

	 * @param ignoreCase True if case should be ignored, false otherwise

	 * @param text The segment

	 * @param offset The offset into the segment

	 * @param match The character array to match

	 */

	public static boolean regionMatches(boolean ignoreCase, Segment text,

					    int offset, char[] match)

	{

		int length = offset + match.length;

		char[] textArray = text.array;

		if(length > text.offset + text.count)

			return false;

		for(int i = offset, j = 0; i < length; i++, j++)

		{

			char c1 = textArray[i];

			char c2 = match[j];

			if(ignoreCase)

			{

				c1 = Character.toUpperCase(c1);

				c2 = Character.toUpperCase(c2);

			}

			if(c1 != c2)

				return false;

		}

		return true;

	}

	/**

	 * Returns the default style table. This can be passed to the

	 * <code>setStyles()</code> method of <code>SyntaxDocument</code>

	 * to use the default syntax styles.

	 */

	public static SyntaxStyle[] getDefaultSyntaxStyles()

	{

		SyntaxStyle[] styles = new SyntaxStyle[Token.ID_COUNT];

		styles[Token.COMMENT1] = new SyntaxStyle(Color.black,true,false);

		styles[Token.COMMENT2] = new SyntaxStyle(new Color(0x990033),true,false);

		styles[Token.KEYWORD1] = new SyntaxStyle(Color.black,false,true);

		styles[Token.KEYWORD2] = new SyntaxStyle(Color.magenta,false,false);

		styles[Token.KEYWORD3] = new SyntaxStyle(new Color(0x009600),false,false);

		styles[Token.LITERAL1] = new SyntaxStyle(new Color(0x650099),false,false);

		styles[Token.LITERAL2] = new SyntaxStyle(new Color(0x650099),false,true);

		styles[Token.LABEL] = new SyntaxStyle(new Color(0x990033),false,true);

		styles[Token.OPERATOR] = new SyntaxStyle(Color.black,false,true);

		styles[Token.INVALID] = new SyntaxStyle(Color.red,false,true);

		return styles;

	}

	/**

	 * Paints the specified line onto the graphics context. Note that this

	 * method munges the offset and count values of the segment.

	 * @param line The line segment

	 * @param tokens The token list for the line

	 * @param styles The syntax style list

	 * @param expander The tab expander used to determine tab stops. May

	 * be null

	 * @param gfx The graphics context

	 * @param x The x co-ordinate

	 * @param y The y co-ordinate

	 * @return The x co-ordinate, plus the width of the painted string

	 */

	public static int paintSyntaxLine(Segment line, Token tokens,

		SyntaxStyle[] styles, TabExpander expander, Graphics gfx,

		int x, int y)

	{

		Font defaultFont = gfx.getFont();

		Color defaultColor = gfx.getColor();

		int offset = 0;

		for(;;)

		{

			byte id = tokens.id;

			if(id == Token.END)

				break;

			int length = tokens.length;

			if(id == Token.NULL)

			{

				if(!defaultColor.equals(gfx.getColor()))

					gfx.setColor(defaultColor);

				if(!defaultFont.equals(gfx.getFont()))

					gfx.setFont(defaultFont);

			}

			else

				styles[id].setGraphicsFlags(gfx,defaultFont);

			line.count = length;

			x = Utilities.drawTabbedText(line,x,y,gfx,expander,0);

			line.offset += length;

			offset += length;

			tokens = tokens.next;

		}

		return x;

	}

	// private members

	private SyntaxUtilities() {}

}

package com.iver.utiles.console.jedit;

/*

 * KeywordMap.java - Fast keyword->id map

 * Copyright (C) 1998, 1999 Slava Pestov

 * Copyright (C) 1999 Mike Dillon

 *

 * You may use and modify this package for any purpose. Redistribution is

 * permitted, in both source and binary form, provided that this notice

 * remains intact in all source distributions of this package.

 */

import javax.swing.text.Segment;

/**

 * A <code>KeywordMap</code> is similar to a hashtable in that it maps keys

 * to values. However, the `keys' are Swing segments. This allows lookups of

 * text substrings without the overhead of creating a new string object.

 * <p>

 * This class is used by <code>CTokenMarker</code> to map keywords to ids.

 *

 * @author Slava Pestov, Mike Dillon

 * @version $Id$

 */

public class KeywordMap

{

	/**

	 * Creates a new <code>KeywordMap</code>.

	 * @param ignoreCase True if keys are case insensitive

	 */

	public KeywordMap(boolean ignoreCase)

	{

		this(ignoreCase, 52);

		this.ignoreCase = ignoreCase;

	}

	/**

	 * Creates a new <code>KeywordMap</code>.

	 * @param ignoreCase True if the keys are case insensitive

	 * @param mapLength The number of `buckets' to create.

	 * A value of 52 will give good performance for most maps.

	 */

	public KeywordMap(boolean ignoreCase, int mapLength)

	{

		this.mapLength = mapLength;

		this.ignoreCase = ignoreCase;

		map = new Keyword[mapLength];

	}

	/**

	 * Looks up a key.

	 * @param text The text segment

	 * @param offset The offset of the substring within the text segment

	 * @param length The length of the substring

	 */

	public byte lookup(Segment text, int offset, int length)

	{

		if(length == 0)

			return Token.NULL;

		Keyword k = map[getSegmentMapKey(text, offset, length)];

		while(k != null)

		{

			if(length != k.keyword.length)

			{

				k = k.next;

				continue;

			}

			if(SyntaxUtilities.regionMatches(ignoreCase,text,offset,

				k.keyword))

				return k.id;

			k = k.next;

		}

		return Token.NULL;

	}

	/**

	 * Adds a key-value mapping.

	 * @param keyword The key

	 * @Param id The value

	 */

	public void add(String keyword, byte id)

	{

		int key = getStringMapKey(keyword);

		map[key] = new Keyword(keyword.toCharArray(),id,map[key]);

	}

	/**

	 * Returns true if the keyword map is set to be case insensitive,

	 * false otherwise.

	 */

	public boolean getIgnoreCase()

	{

		return ignoreCase;

	}

	/**

	 * Sets if the keyword map should be case insensitive.

	 * @param ignoreCase True if the keyword map should be case

	 * insensitive, false otherwise

	 */

	public void setIgnoreCase(boolean ignoreCase)

	{

		this.ignoreCase = ignoreCase;

	}

	// protected members

	protected int mapLength;

	protected int getStringMapKey(String s)

	{

		return (Character.toUpperCase(s.charAt(0)) +

				Character.toUpperCase(s.charAt(s.length()-1)))

				% mapLength;

	}

	protected int getSegmentMapKey(Segment s, int off, int len)

	{

		return (Character.toUpperCase(s.array[off]) +

				Character.toUpperCase(s.array[off + len - 1]))

				% mapLength;

	}

	// private members

	class Keyword

	{

		public Keyword(char[] keyword, byte id, Keyword next)

		{

			this.keyword = keyword;

			this.id = id;

			this.next = next;

		}

		public char[] keyword;

		public byte id;

		public Keyword next;

	}

	private Keyword[] map;

	private boolean ignoreCase;

}

package com.iver.utiles.console.jedit;

/*

 * PythonTokenMarker.java - Python token marker

 * Copyright (C) 1999 Jonathan Revusky

 * Copyright (C) 1998, 1999 Slava Pestov

 *

 * You may use and modify this package for any purpose. Redistribution is

 * permitted, in both source and binary form, provided that this notice

 * remains intact in all source distributions of this package.

 */

import javax.swing.text.Segment;

/**

 * Python token marker.

 *

 * @author Jonathan Revusky

 * @version $Id$

 */

public class PythonTokenMarker extends TokenMarker

{

	private static final byte TRIPLEQUOTE1 = Token.INTERNAL_FIRST;

	private static final byte TRIPLEQUOTE2 = Token.INTERNAL_LAST;

	public PythonTokenMarker()

	{

		this.keywords = getKeywords();

	}

	public byte markTokensImpl(byte token, Segment line, int lineIndex)

	{

		char[] array = line.array;

		int offset = line.offset;

		lastOffset = offset;

		lastKeyword = offset;

		int length = line.count + offset;

		boolean backslash = false;

loop:		for(int i = offset; i < length; i++)

		{

			int i1 = (i+1);

			char c = array[i];

			if(c == '\\')

			{

				backslash = !backslash;

				continue;

			}

			switch(token)

			{

			case Token.NULL:

				switch(c)

				{

				case '#':

					if(backslash)

						backslash = false;

					else

					{

						doKeyword(line,i,c);

						addToken(i - lastOffset,token);

						addToken(length - i,Token.COMMENT1);

						lastOffset = lastKeyword = length;

						break loop;

					}

					break;

				case '"':

					doKeyword(line,i,c);

					if(backslash)

						backslash = false;

					else

					{

						addToken(i - lastOffset,token);

						if(SyntaxUtilities.regionMatches(false,

							line,i1,"\"\""))

						{

							token = TRIPLEQUOTE1;

						}

						else

						{

							token = Token.LITERAL1;

						}

						lastOffset = lastKeyword = i;

					}

					break;

				case '\'':

					doKeyword(line,i,c);

					if(backslash)

						backslash = false;

					else

					{

						addToken(i - lastOffset,token);

						if(SyntaxUtilities.regionMatches(false,

							line,i1,"''"))

						{

							token = TRIPLEQUOTE2;

						}

						else

						{

							token = Token.LITERAL2;

						}

						lastOffset = lastKeyword = i;

					}

					break;

				default:

					backslash = false;

					if(!Character.isLetterOrDigit(c)

						&& c != '_')

						doKeyword(line,i,c);

					break;

				}

				break;

			case Token.LITERAL1:

				if(backslash)

					backslash = false;

				else if(c == '"')

				{

					addToken(i1 - lastOffset,token);

					token = Token.NULL;

					lastOffset = lastKeyword = i1;

				}

				break;

			case Token.LITERAL2:

				if(backslash)

					backslash = false;

				else if(c == '\'')

				{

					addToken(i1 - lastOffset,Token.LITERAL1);

					token = Token.NULL;

					lastOffset = lastKeyword = i1;

				}

				break;

			case TRIPLEQUOTE1:

				if(backslash)

					backslash = false;

				else if(SyntaxUtilities.regionMatches(false,

					line,i,"\"\"\""))

				{

					addToken((i+=4) - lastOffset,

						Token.LITERAL1);

					token = Token.NULL;

					lastOffset = lastKeyword = i;

				}

				break;

			case TRIPLEQUOTE2:

				if(backslash)

					backslash = false;