]> gerrit.simantics Code Review - simantics/platform.git/blobdiff - bundles/winterwell.markdown/src/winterwell/markdown/editors/EmphasisRule.java
Fixed all line endings of the repository
[simantics/platform.git] / bundles / winterwell.markdown / src / winterwell / markdown / editors / EmphasisRule.java
index 06f14201de759402e22ab01e17f018bc8b8e49ed..7ae7a97c91eda5654f47938f0af02a10705ceb98 100644 (file)
-/**\r
- * Copyright winterwell Mathematics Ltd.\r
- * @author Daniel Winterstein\r
- * 11 Jan 2007\r
- */\r
-package winterwell.markdown.editors;\r
-\r
-import org.eclipse.core.runtime.Assert;\r
-import org.eclipse.jface.text.rules.ICharacterScanner;\r
-import org.eclipse.jface.text.rules.IRule;\r
-import org.eclipse.jface.text.rules.IToken;\r
-import org.eclipse.jface.text.rules.MultiLineRule;\r
-import org.eclipse.jface.text.rules.Token;\r
-\r
-/**\r
- * \r
- *\r
- * @author Daniel Winterstein\r
- */\r
-public class EmphasisRule implements IRule {\r
-       private static char[][] fDelimiters = null;\r
-       private char[] fSequence;\r
-       protected IToken fToken;\r
-\r
-\r
-       public EmphasisRule(String marker, IToken token) {\r
-               assert marker.equals("*") || marker.equals("_") || marker.equals("**")\r
-                               || marker.equals("***") || marker.equals("`") || marker.equals("``");\r
-               Assert.isNotNull(token);\r
-               fSequence = marker.toCharArray();\r
-               fToken = token;\r
-       }\r
-       \r
-       // Copied from org.eclipse.jface.text.rules.PatternRule\r
-       protected boolean sequenceDetected(ICharacterScanner scanner, char[] sequence, boolean eofAllowed) {\r
-               for (int i = 1; i < sequence.length; i++) {\r
-                       int c = scanner.read();\r
-                       if (c == ICharacterScanner.EOF && eofAllowed) {\r
-                               return true;\r
-                       } else if (c != sequence[i]) {\r
-                               // Non-matching character detected, rewind the scanner back to\r
-                               // the start.\r
-                               // Do not unread the first character.\r
-                               for (int j = i; j > 0; j--)\r
-                                       scanner.unread();\r
-                               return false;\r
-                       }\r
-               }\r
-               return true;\r
-       }\r
-\r
-       /*\r
-        * @see IRule#evaluate(ICharacterScanner)\r
-        * \r
-        * @since 2.0\r
-        */\r
-       public IToken evaluate(ICharacterScanner scanner) {\r
-               // Should be connected only on the right side\r
-               scanner.unread();\r
-               boolean sawSpaceBefore = Character.isWhitespace(scanner.read());\r
-               if (!sawSpaceBefore && scanner.getColumn() != 0) {\r
-                       return Token.UNDEFINED;\r
-               }\r
-\r
-               int c = scanner.read();\r
-               // Should be connected only on right side\r
-               if (c != fSequence[0] || !sequenceDetected(scanner, fSequence, false)) {\r
-                       scanner.unread();\r
-                       return Token.UNDEFINED;\r
-               }\r
-               int readCount = fSequence.length;\r
-               if (fDelimiters == null) {\r
-                       fDelimiters = scanner.getLegalLineDelimiters();\r
-               }\r
-               // Start sequence detected\r
-               int delimiterFound = 0;\r
-               // Is it a list item marker, or just a floating *?\r
-               if (sawSpaceBefore) {\r
-                       boolean after = Character.isWhitespace(scanner.read());\r
-                       scanner.unread();\r
-                       if (after)\r
-                               delimiterFound = 2;\r
-               }\r
-\r
-               while (delimiterFound < 2\r
-                               && (c = scanner.read()) != ICharacterScanner.EOF) {\r
-                       readCount++;\r
-\r
-                       if (!sawSpaceBefore && c == fSequence[0]\r
-                                       && sequenceDetected(scanner, fSequence, false)) {\r
-                               return fToken;\r
-                       }\r
-\r
-                       int i;\r
-                       for (i = 0; i < fDelimiters.length; i++) {\r
-                               if (c == fDelimiters[i][0]\r
-                                               && sequenceDetected(scanner, fDelimiters[i], true)) {\r
-                                       delimiterFound++;\r
-                                       break;\r
-                               }\r
-                       }\r
-                       if (i == fDelimiters.length)\r
-                               delimiterFound = 0;\r
-                       sawSpaceBefore = Character.isWhitespace(c);\r
-               }\r
-               // Reached ICharacterScanner.EOF\r
-               for (; readCount > 0; readCount--)\r
-                       scanner.unread();\r
-               return Token.UNDEFINED;\r
-       }\r
-       \r
-}\r
+/**
+ * Copyright winterwell Mathematics Ltd.
+ * @author Daniel Winterstein
+ * 11 Jan 2007
+ */
+package winterwell.markdown.editors;
+
+import org.eclipse.core.runtime.Assert;
+import org.eclipse.jface.text.rules.ICharacterScanner;
+import org.eclipse.jface.text.rules.IRule;
+import org.eclipse.jface.text.rules.IToken;
+import org.eclipse.jface.text.rules.MultiLineRule;
+import org.eclipse.jface.text.rules.Token;
+
+/**
+ * 
+ *
+ * @author Daniel Winterstein
+ */
+public class EmphasisRule implements IRule {
+       private static char[][] fDelimiters = null;
+       private char[] fSequence;
+       protected IToken fToken;
+
+
+       public EmphasisRule(String marker, IToken token) {
+               assert marker.equals("*") || marker.equals("_") || marker.equals("**")
+                               || marker.equals("***") || marker.equals("`") || marker.equals("``");
+               Assert.isNotNull(token);
+               fSequence = marker.toCharArray();
+               fToken = token;
+       }
+       
+       // Copied from org.eclipse.jface.text.rules.PatternRule
+       protected boolean sequenceDetected(ICharacterScanner scanner, char[] sequence, boolean eofAllowed) {
+               for (int i = 1; i < sequence.length; i++) {
+                       int c = scanner.read();
+                       if (c == ICharacterScanner.EOF && eofAllowed) {
+                               return true;
+                       } else if (c != sequence[i]) {
+                               // Non-matching character detected, rewind the scanner back to
+                               // the start.
+                               // Do not unread the first character.
+                               for (int j = i; j > 0; j--)
+                                       scanner.unread();
+                               return false;
+                       }
+               }
+               return true;
+       }
+
+       /*
+        * @see IRule#evaluate(ICharacterScanner)
+        * 
+        * @since 2.0
+        */
+       public IToken evaluate(ICharacterScanner scanner) {
+               // Should be connected only on the right side
+               scanner.unread();
+               boolean sawSpaceBefore = Character.isWhitespace(scanner.read());
+               if (!sawSpaceBefore && scanner.getColumn() != 0) {
+                       return Token.UNDEFINED;
+               }
+
+               int c = scanner.read();
+               // Should be connected only on right side
+               if (c != fSequence[0] || !sequenceDetected(scanner, fSequence, false)) {
+                       scanner.unread();
+                       return Token.UNDEFINED;
+               }
+               int readCount = fSequence.length;
+               if (fDelimiters == null) {
+                       fDelimiters = scanner.getLegalLineDelimiters();
+               }
+               // Start sequence detected
+               int delimiterFound = 0;
+               // Is it a list item marker, or just a floating *?
+               if (sawSpaceBefore) {
+                       boolean after = Character.isWhitespace(scanner.read());
+                       scanner.unread();
+                       if (after)
+                               delimiterFound = 2;
+               }
+
+               while (delimiterFound < 2
+                               && (c = scanner.read()) != ICharacterScanner.EOF) {
+                       readCount++;
+
+                       if (!sawSpaceBefore && c == fSequence[0]
+                                       && sequenceDetected(scanner, fSequence, false)) {
+                               return fToken;
+                       }
+
+                       int i;
+                       for (i = 0; i < fDelimiters.length; i++) {
+                               if (c == fDelimiters[i][0]
+                                               && sequenceDetected(scanner, fDelimiters[i], true)) {
+                                       delimiterFound++;
+                                       break;
+                               }
+                       }
+                       if (i == fDelimiters.length)
+                               delimiterFound = 0;
+                       sawSpaceBefore = Character.isWhitespace(c);
+               }
+               // Reached ICharacterScanner.EOF
+               for (; readCount > 0; readCount--)
+                       scanner.unread();
+               return Token.UNDEFINED;
+       }
+       
+}