tokenmarker.java

Java写的文本编辑器

			a = pattern.array[pattern.offset + k];
			b = line.array[pos + k];

			// break out and check the next rule if there is a mismatch
			if (
				!(
					a == b ||
					context.rules.getIgnoreCase() &&
					(
						Character.toLowerCase(a) == b ||
						a == Character.toLowerCase(b)
					)
				)
			) return true;
		}

		if (escaped)
		{
			pos += pattern.count - 1;
			return false;
		}
		else if ((checkRule.action & IS_ESCAPE) == IS_ESCAPE)
		{
			escaped = true;
			pos += pattern.count - 1;
			return false;
		}

		// handle soft spans
		if (context.inRule != checkRule && context.inRule != null
			&& (context.inRule.action & SOFT_SPAN) != 0)
		{
			if ((context.inRule.action & NO_WORD_BREAK) == NO_WORD_BREAK)
			{
				info.addToken(pos - lastOffset, Token.INVALID);
			}
			else
			{
				info.addToken(pos - lastOffset,context.inRule.token);
			}
			lastOffset = lastKeyword = pos;
			context.inRule = null;
		}

		if (context.inRule == null)
		{
			if ((checkRule.action & AT_LINE_START) == AT_LINE_START)
			{
				if (
					(((checkRule.action & MARK_PREVIOUS) != 0) ?
					lastKeyword :
					pos) != line.offset
				)
				{
					return true;
				}
			}

			markKeyword(info, line, lastKeyword, pos);

			if ((checkRule.action & MARK_PREVIOUS) != MARK_PREVIOUS)
			{
				lastKeyword = pos + pattern.count;

				if ((checkRule.action & WHITESPACE) == WHITESPACE)
				{
					return false; // break out of inner for loop to check next char
				}

				// mark previous sequence as NULL (plain text)
				if (lastOffset < pos)
				{
					info.addToken(pos - lastOffset,
						context.rules.getDefault());
				}
			}

			switch(checkRule.action & MAJOR_ACTIONS)
			{
			case 0:
				// this is a plain sequence rule
				info.addToken(pattern.count,checkRule.token);
				lastOffset = pos + pattern.count;

				break;
			case SPAN:
				context.inRule = checkRule;

				if ((checkRule.action & DELEGATE) != DELEGATE)
				{
					if ((checkRule.action & EXCLUDE_MATCH) == EXCLUDE_MATCH)
					{
						info.addToken(pattern.count,
							context.rules.getDefault());
						lastOffset = pos + pattern.count;
					}
					else
					{
						lastOffset = pos;
					}
				}
				else
				{
					String setName = new String(checkRule.searchChars,
						checkRule.sequenceLengths[0] + checkRule.sequenceLengths[1],
						checkRule.sequenceLengths[2]);

					ParserRuleSet delegateSet = getRuleSet(setName);

					if (delegateSet != null)
					{
						if ((checkRule.action & EXCLUDE_MATCH) == EXCLUDE_MATCH)
						{
							info.addToken(pattern.count,
								context.rules.getDefault());
						}
						else
						{
							info.addToken(pattern.count,checkRule.token);
						}
						lastOffset = pos + pattern.count;

						context = new LineContext(delegateSet, context);
					}
				}

				break;
			case EOL_SPAN:
				if ((checkRule.action & EXCLUDE_MATCH) == EXCLUDE_MATCH)
				{
					info.addToken(pattern.count,
						context.rules.getDefault());
					info.addToken(lineLength - (pos + pattern.count),
						checkRule.token);
				}
				else
				{
					info.addToken(lineLength - pos,
						checkRule.token);
				}
				lastOffset = lineLength;
				lastKeyword = lineLength;
				pos = lineLength;

				return false;
			case MARK_PREVIOUS:
				if (lastKeyword > lastOffset)
				{
					info.addToken(lastKeyword - lastOffset,
						context.rules.getDefault());
					lastOffset = lastKeyword;
				}

				if ((checkRule.action & EXCLUDE_MATCH) == EXCLUDE_MATCH)
				{
					info.addToken(pos - lastOffset, checkRule.token);
					info.addToken(pattern.count,
						context.rules.getDefault());
				}
				else
				{
					info.addToken(pos - lastOffset + pattern.count,
						checkRule.token);
				}
				lastOffset = pos + pattern.count;

				break;
			case MARK_FOLLOWING:
				context.inRule = checkRule;
				if ((checkRule.action & EXCLUDE_MATCH) == EXCLUDE_MATCH)
				{
					info.addToken(pattern.count,
						context.rules.getDefault());
					lastOffset = pos + pattern.count;
				}
				else
				{
					lastOffset = pos;
				}

				break;
			default:
				throw new InternalError("Unhandled major action");
			}

			lastKeyword = lastOffset;

			pos += (pattern.count - 1); // move pos to last character of match sequence
			return false; // break out of inner for loop to check next char
		}
		else if ((checkRule.action & SPAN) == SPAN)
		{
			if ((checkRule.action & DELEGATE) != DELEGATE)
			{
				context.inRule = null;
				if ((checkRule.action & EXCLUDE_MATCH) == EXCLUDE_MATCH)
				{
					info.addToken(pos - lastOffset,checkRule.token);
					info.addToken(pattern.count,
						context.rules.getDefault());
				}
				else
				{
					info.addToken((pos + pattern.count) - lastOffset,
						checkRule.token);
				}
				lastKeyword = lastOffset = pos + pattern.count;

				pos += (pattern.count - 1); // move pos to last character of match sequence
			}

			return false; // break out of inner for loop to check next char
		}
		return true;
	}

	private void markKeyword(Buffer.LineInfo info, Segment line,
		int start, int end)
	{
		KeywordMap keywords = context.rules.getKeywords();

		int len = end - start;

		// do digits
		if(context.rules.getHighlightDigits())
		{
			boolean digit = true;
			char[] array = line.array;
			boolean octal = false;
			boolean hex = false;
			boolean seenSomeDigits = false;
loop:			for(int i = 0; i < len; i++)
			{
				char ch = array[start+i];
				switch(ch)
				{
				case '0':
					if(i == 0)
						octal = true;
					seenSomeDigits = true;
					continue loop;
				case '1': case '2': case '3':
				case '4': case '5': case '6':
				case '7': case '8': case '9':
					seenSomeDigits = true;
					continue loop;
				case 'x': case 'X':
					if(octal && i == 1)
					{
						hex = true;
						continue loop;
					}
					else
						break;
				case 'd': case 'D':
					if(hex)
						continue loop;
					else
						break;
				case 'f': case 'F':
					if(hex || seenSomeDigits)
						continue loop;
					else
						break;
				case 'l': case 'L':
					if(seenSomeDigits)
						continue loop;
					else
						break;
				case 'e': case 'E':
					if(seenSomeDigits)
						continue loop;
					else
						break;
				case 'a': case 'A': case 'b': case 'B':
				case 'c': case 'C':
					if(hex)
						continue loop;
					else
						break;
				case '.': case '-':
					// normally, this shouldn't be
					// necessary, because most modes
					// define '.' and '-' SEQs. However,
					// in props mode, we can't define
					// such a SEQ because it would
					// break the AT_LINE_START
					// MARK_PREVIOUS rule.
					continue loop;
				default:
					break;
				}

				// if we ended up here, then we have found a
				// non-digit character.
				digit = false;
				break loop;
			}

			// if we got this far with digit = true, then the keyword
			// consists of all digits. Add it as such.
			if(digit)
			{
				if(start != lastOffset)
				{
					info.addToken(start - lastOffset,
						context.rules.getDefault());
				}
				info.addToken(len,Token.DIGIT);
				lastKeyword = lastOffset = end;

				return;
			}
		}

		if(keywords != null)
		{
			byte id = keywords.lookup(line, start, len);

			if(id != Token.NULL)
			{
				if(start != lastOffset)
				{
					info.addToken(start - lastOffset,
						context.rules.getDefault());
				}
				info.addToken(len, id);
				lastKeyword = lastOffset = end;
			}
		}
	}

	public static class LineContext
	{
		public LineContext parent;
		public ParserRule inRule;
		public ParserRuleSet rules;

		public LineContext(ParserRule r, ParserRuleSet rs)
		{
			inRule = r;
			rules = rs;
		}

		public LineContext(ParserRuleSet rs, LineContext lc)
		{
			rules = rs;
			parent = (lc == null ? null : (LineContext)lc.clone());
		}

		public LineContext(ParserRule r)
		{
			inRule = r;
		}

		public LineContext()
		{
		}

		public Object clone()
		{
			LineContext lc = new LineContext();
			lc.inRule = inRule;
			lc.rules = rules;
			lc.parent = (parent == null) ? null : (LineContext) parent.clone();

			return lc;
		}
	}
}