redcar-javamateview 0.2

data/src/com/redcareditor/mate/ParserScheduler.java

@@ -0,0 +1,237 @@
+package com.redcareditor.mate;
+
+import org.eclipse.swt.events.ModifyEvent;
+import org.eclipse.swt.events.ModifyListener;
+import org.eclipse.swt.events.SelectionEvent;
+import org.eclipse.swt.events.SelectionListener;
+import org.eclipse.swt.events.VerifyEvent;
+import org.eclipse.swt.events.VerifyListener;
+
+import org.eclipse.jface.text.IDocumentListener;
+import org.eclipse.jface.text.IViewportListener;
+import org.eclipse.jface.text.JFaceTextUtil;
+import org.eclipse.jface.text.DocumentEvent;
+
+import com.redcareditor.mate.document.swt.SwtMateTextLocation;
+import com.redcareditor.onig.Range;
+
+public class ParserScheduler {
+	public static int LOOK_AHEAD = 300;
+	public static boolean synchronousParsing = false;
+	public int lookAhead;
+	public int lastVisibleLine;
+	public boolean alwaysParseAll;
+	public boolean enabled;
+	public RangeSet changes;
+	public int deactivationLevel;
+
+	public int modifyStart, modifyEnd;
+	public String modifyText;
+	public ParseThunk thunk;
+	public Parser parser;
+
+	public int parsed_upto;	
+	public SwtMateTextLocation parsedUpto;
+
+	public ParserScheduler(Parser parser) {
+		this.parser = parser;
+		lookAhead = LOOK_AHEAD;
+		lastVisibleLine = 0;
+		changes = new RangeSet();
+		deactivationLevel = 0;
+		alwaysParseAll = false;
+		modifyStart = -1;
+		enabled = true;
+		setParsedUpto(0);
+		attachListeners();
+	}
+	
+	public void close() {
+		if (thunk != null) {
+			thunk.stop();
+			thunk = null;
+		}
+		removeListeners();
+	}
+
+	private VerifyListener verifyListener;
+	private ModifyListener modifyListener;
+	private IViewportListener viewportListener;
+	private IDocumentListener documentListener;
+	
+	public void attachListeners() {
+		viewportListener = new IViewportListener() {
+			public void viewportChanged(int verticalOffset) {
+				viewportScrolledCallback();
+			}
+		};
+		
+		parser.mateText.viewer.addViewportListener(viewportListener);
+		
+		documentListener = new IDocumentListener() {
+			public void documentAboutToBeChanged(DocumentEvent e) {
+				verifyEventCallback(e.fOffset, e.fOffset + e.fLength, e.fText);
+			}
+			
+			public void documentChanged(DocumentEvent e) {
+				modifyEventCallback();
+			}
+		};
+		parser.mateText.getDocument().addDocumentListener(documentListener);
+	}
+	
+	public void removeListeners() {
+		parser.mateText.viewer.removeViewportListener(viewportListener);
+		parser.mateText.getDocument().removeDocumentListener(documentListener);
+	}
+
+	public void verifyEventCallback(int start, int end, String text) {
+		if (enabled) {
+			modifyStart = start;
+			modifyEnd   = end;
+			modifyText  = text;
+		}
+	}
+	
+	public void modifyEventCallback() {
+		if (enabled) {
+			changes.add(
+				parser.getLineAtOffset(modifyStart), 
+				parser.getLineAtOffset(modifyStart + modifyText.length())
+			);
+			modifyStart = -1;
+			modifyEnd   = -1;
+			modifyText  = null;
+			if (deactivationLevel == 0)
+				processChanges();
+		}
+	}
+
+	public void viewportScrolledCallback() {
+		if (enabled) {
+			lastVisibleLineChanged(JFaceTextUtil.getBottomIndex(parser.mateText.getTextWidget()));
+		}
+	}
+	
+	public void deactivate() {
+		deactivationLevel++;
+	}
+	
+	public void reactivate() {
+		deactivationLevel--;
+		if (deactivationLevel < 0) 
+			deactivationLevel = 0;
+		if (deactivationLevel == 0)
+			processChanges();
+	}
+	
+	// Process all change ranges.
+	public void processChanges() {
+		int thisParsedUpto = -1;
+		// System.out.printf("process_changes (lastVisibleLine: %d) (charCount = %d)\n", lastVisibleLine, document.getLength());
+		for (Range range : changes) {
+			if (range.end > thisParsedUpto && range.start <= lastVisibleLine + lookAhead) {
+				int rangeEnd;
+				if (alwaysParseAll) {
+					rangeEnd = parser.getLineCount() - 1;
+				} else {
+					rangeEnd = Math.min(lastVisibleLine + lookAhead, range.end);
+				}
+				//System.out.printf("parseRange from processChanges\n");
+				thisParsedUpto = parseRange(range.start, rangeEnd);
+			}
+			int startOffset = parser.getOffsetAtLine(range.start);
+			int endOffset   = parser.getOffsetAtLine(range.end);
+			parser.styledText.redrawRange(startOffset, endOffset - startOffset, false);
+		}
+		//		System.out.printf("%s\n", root.pretty(0));
+		changes.ranges.clear();
+	}
+
+	public void thunkFrom(int lineIx) {
+		if (thunk != null) {
+			thunk.delayAndUpdate(lineIx);
+		}
+		else {
+			if (lineIx <= parser.getLineCount() - 1) {
+				thunk = new ParseThunk(parser, lineIx);
+				if (ParserScheduler.synchronousParsing) {
+					thunk.execute();
+				}
+			}
+		}
+	}
+
+	// Parse from from_line to *at least* to_line. Will parse
+	// more if necessary. Returns the index of the last line
+	// parsed.
+	public int parseRange(int fromLine, int toLine) {
+		//System.out.printf("parse_range(%d, %d)\n", fromLine, toLine);
+
+		int lineIx = fromLine;
+		boolean scopeChanged = false;
+		boolean scopeEverChanged = false;
+		while (lineIx <= toLine) {
+			scopeChanged = parser.parseLine(lineIx);
+			if (scopeChanged) {
+				if (scopeEverChanged == false && getParsedUpto() > lineIx) {
+					//System.out.printf(parser.root.pretty(4));
+					//System.out.printf("-- clearFrom(%d) --\n", lineIx);
+					parser.clearFrom(parser.getOffsetAtLine(lineIx + 1));
+					//System.out.printf(parser.root.pretty(4));
+				}
+				setParsedUpto(lineIx);
+				scopeEverChanged = true;
+			}
+			lineIx++;
+		}
+		if (scopeEverChanged) {
+			thunkFrom(lineIx);
+		}
+
+		return toLine;
+	}
+	
+	public int parseOnwards(int fromLine) {
+		// The widget can be disposed between the Thunk being created and being executed.
+		if (parser.styledText.isDisposed())
+			return -1;
+		int lineIx = fromLine;
+		int lineCount = parser.getLineCount();
+		int lastLine = Math.min(lastVisibleLine + LOOK_AHEAD, lineCount - 1);
+		int toLine = Math.min(fromLine + LOOK_AHEAD, lastLine);
+		while (lineIx <= toLine) {
+			parser.parseLine(lineIx);
+			setParsedUpto(lineIx);
+			parser.redrawLine(lineIx);
+			lineIx++;
+		}
+		
+		return lineIx;
+	}
+	
+	public void lastVisibleLineChanged(int newLastVisibleLine) {
+		int oldLastVisibleLine = lastVisibleLine;
+		//System.out.printf("lastVisibleLineChanged(%d)\n", newLastVisibleLine);
+		this.lastVisibleLine = newLastVisibleLine;
+		//System.out.printf("lastVisibleLine: %d, lookAhead: %d, getParsedUpto: %d\n", lastVisibleLine, lookAhead, getParsedUpto());
+		if (lastVisibleLine + lookAhead >= getParsedUpto() && getParsedUpto() < parser.getLineCount() - 1) {
+			int endRange = Math.min(parser.getLineCount() - 1, lastVisibleLine + lookAhead);
+			thunkFrom(getParsedUpto());
+		}
+	}
+	
+	public void setParsedUpto(int line_ix) {
+		if (parsedUpto == null) {
+			parsedUpto = (SwtMateTextLocation) parser.mateDocument.getTextLocation(0, 0);
+			parser.mateDocument.addTextLocation("lefts", parsedUpto);
+		}
+		parsedUpto.offset = parser.getOffsetAtLine(line_ix);
+	}
+	
+	public int getParsedUpto() {
+		// System.out.printf("parsedUpto %d,%d (/%d)\n", parsedUpto.getOffset(), parsedUpto.getLength(), parser.getCharCount());
+		return parser.getLineAtOffset(parsedUpto.getOffset());
+	}
+	
+}

data/src/com/redcareditor/mate/Pattern.java

@@ -0,0 +1,152 @@
+package com.redcareditor.mate;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import com.redcareditor.plist.Dict;
+import com.redcareditor.plist.PlistNode;
+
+public class Pattern {
+	public Grammar grammar;
+	public String name;
+	public boolean disabled;
+
+	public static Pattern createPattern(List<Pattern> allPatterns, Dict dict) {
+		if (dict.containsElement("match")) {
+			return new SinglePattern(allPatterns, dict);
+		}
+
+		if (dict.containsElement("include")) {
+			return new IncludePattern(dict);
+		}
+
+		if (dict.containsElement("begin")) {
+			return new DoublePattern(allPatterns, dict);
+		}
+
+		return null;
+	}
+
+	public static Map<Integer, String> makeCapturesFromPlist(Dict pd) {
+		if (pd == null)
+			return new HashMap<Integer, String>();
+		Dict pcd;
+		String ns;
+		Map<Integer, String> captures = new HashMap<Integer, String>();
+		for (String sCapnum : pd.value.keySet()) {
+			int capnum = Integer.parseInt(sCapnum);
+			pcd = pd.getDictionary(sCapnum);
+			ns = pcd.getString("name");
+//			System.out.printf("capture: %d, %s\n", capnum, ns);
+			captures.put((Integer) capnum, ns);
+		}
+		return captures;
+	}
+
+	public static void replaceIncludePatterns(List<Pattern> patterns, Grammar grammar) {
+		replaceRepositoryIncludes(patterns, grammar);
+		replaceBaseAndSelfIncludes(patterns, grammar);
+	}
+
+	public static void replaceRepositoryIncludes(List<Pattern> patterns, Grammar grammar) {
+		int i = 0;
+		while (i < patterns.size()) {
+			Pattern p = patterns.get(i);
+			if (p instanceof IncludePattern && p.name.startsWith("#")) {
+				// System.out.printf("repo include: %s\n", p.name);
+				String reponame = p.name.substring(1, p.name.length());
+				List<Pattern> repositoryEntryPatterns = grammar.repository.get(reponame);
+				if (repositoryEntryPatterns != null) {
+					// System.out.printf("  got %d patterns\n", repositoryEntryPatterns.size());
+					patterns.remove(i);
+					patterns.addAll(i, repositoryEntryPatterns);
+					i--;
+				} else {
+					System.out.printf("warning: couldn't find repository key '%s' in grammar '%s'\n", reponame,
+							grammar.name);
+				}
+			}
+			i++;
+		}
+	}
+
+	public static void replaceBaseAndSelfIncludes(List<Pattern> patterns, Grammar grammar) {
+		boolean alreadySelf = false; // some patterns have $self twice
+		Grammar ng;
+		int i = 0;
+		while (i < patterns.size()) {
+			Pattern p = patterns.get(i);
+			if (p instanceof IncludePattern) {
+				if (p.name.startsWith("$")) {
+					if ((p.name.equals("$self") || p.name.equals("$base")) && !alreadySelf) {
+						alreadySelf = true;
+						patterns.remove(i);
+						patterns.addAll(i, grammar.patterns);
+						i--;
+					}
+				//} else if ((ng = Grammar.findByScopeName(p.name)) != null) {
+				//	ng.initForUse();
+				//	patterns.remove(i);
+				//	patterns.addAll(i, ng.patterns);
+				//	i--;
+				}
+			}
+			i++;
+		}
+	}
+
+	private static void removePatterns(List<Pattern> patlist, List<Pattern> ps) {
+		for (Pattern p : ps) {
+			patlist.remove(p);
+		}
+	}
+
+	private static void addPatterns(List<Pattern> patlist, List<Pattern> ps) {
+		for (Pattern p : ps) {
+			patlist.add(p);
+		}
+	}
+
+	public void setDisabled(Dict dict) {
+		PlistNode<?> plistNode = dict.value.get("disabled");
+		int intn;
+		if (plistNode != null) {
+			if (plistNode.value instanceof String) {
+				String strn = dict.getString("disabled");
+				intn = Integer.parseInt(strn);
+			}
+			else {
+				intn = dict.getInt("disabled");
+			}
+			switch (intn) {
+			case 1:
+				disabled = true;
+				break;
+			default:
+				disabled = false;
+				break;
+			}
+		} else {
+			disabled = false;
+		}
+	}
+	
+	public String prettyName() {
+		if (name == null) {
+			if (this instanceof SinglePattern) {
+				return ((SinglePattern) this).match.pattern;
+			}
+			else if (this instanceof DoublePattern) {
+				return ((DoublePattern) this).begin.pattern;
+			}
+			else {
+				return "unknown";
+			}
+		}
+		else {
+			return name;
+		}
+	}
+}

data/src/com/redcareditor/mate/RangeSet.java

@@ -0,0 +1,91 @@
+package com.redcareditor.mate;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+
+import com.redcareditor.onig.Range;
+
+public class RangeSet implements Iterable<Range> {
+	List<Range> ranges = new ArrayList<Range>();
+
+	public void add(int a, int b) {
+		int insertAt = 0;
+		Range range = new Range(a, b);
+
+		while (insertAt < length() && ranges.get(insertAt).start < range.start) {
+			insertAt++;
+		}
+
+		merge(insertAt, range);
+	}
+
+	public Range get(int i) {
+		return ranges.get(i);
+	}
+
+	public int length() {
+		return size();
+	}
+	
+	public int size() {
+		return ranges.size();
+	}
+
+	public int rangeSize() {
+		int sizec = 0;
+		for (int i = 0; i < length(); i++) {
+			sizec += ranges.get(i).end - ranges.get(i).start + 1;
+		}
+		return sizec;
+	}
+
+	public String present() {
+		return toString();
+	}
+
+	public String toString() {
+		StringBuilder sb = new StringBuilder("");
+		for (int i = 0; i < length(); i++) {
+			sb.append(get(i).toString());
+			if (i != length() - 1) {
+				sb.append(", ");
+			}
+		}
+		return sb.toString();
+	}
+
+	public boolean isEmpty() {
+		return ranges.isEmpty();
+	}
+
+	public Iterator<Range> iterator() {
+		return ranges.iterator();
+	}
+
+	private void merge(int mergeAt, Range range) {
+		ranges.add(mergeAt, range);
+
+		if (mergeAt > 0) {
+			Range beforeMerge = ranges.get(mergeAt - 1);
+			if (range.isTouching(beforeMerge)) {
+				ranges.remove(mergeAt);
+				beforeMerge.end = Math.max(beforeMerge.end, range.end);
+				mergeAt--;
+				range = ranges.get(mergeAt);
+			}
+		}
+
+		if (mergeAt + 1 < length()) {
+			Range afterMerge = ranges.get(mergeAt + 1);
+			while (mergeAt < length() - 1 && range.isTouching(afterMerge)) {
+				range.start = Math.min(range.start, afterMerge.start);
+				range.end = Math.max(range.end, afterMerge.end);
+				ranges.remove(mergeAt + 1);
+				if (mergeAt + 1 < length())
+					afterMerge = ranges.get(mergeAt + 1);
+			}
+		}
+	}
+
+}