--- /dev/null
+package org.simantics.scl.compiler.markdown.inlines;
+
+import gnu.trove.map.hash.THashMap;
+
+import org.simantics.scl.compiler.markdown.internal.Scanner;
+import org.simantics.scl.compiler.markdown.nodes.AutolinkNode;
+import org.simantics.scl.compiler.markdown.nodes.CodeNode;
+import org.simantics.scl.compiler.markdown.nodes.EmphNode;
+import org.simantics.scl.compiler.markdown.nodes.HardLineBreakNode;
+import org.simantics.scl.compiler.markdown.nodes.HtmlTagNode;
+import org.simantics.scl.compiler.markdown.nodes.ImageNode;
+import org.simantics.scl.compiler.markdown.nodes.LinkNode;
+import org.simantics.scl.compiler.markdown.nodes.Node;
+import org.simantics.scl.compiler.markdown.nodes.Reference;
+import org.simantics.scl.compiler.markdown.nodes.TextNode;
+
+public class Subject {
+ THashMap<String, Reference> referenceMap;
+ StringBuilder input;
+ int pos;
+ Delimiter lastDelim;
+
+ public Subject(THashMap<String, Reference> referenceMap, StringBuilder input) {
+ this.referenceMap = referenceMap;
+ this.input = input;
+ this.pos = 0;
+ }
+
+ public static void parseInlines(THashMap<String, Reference> referenceMap, Node parent) {
+ Subject subject = new Subject(referenceMap, parent.stringContent);
+ while(!subject.isEof() && subject.parseInline(parent));
+ subject.processEmphasis(null);
+ parent.stringContent = null;
+ }
+
+ private void processEmphasis(Delimiter begin) {
+ if(lastDelim == begin)
+ return;
+
+ // Find first delimiter
+ Delimiter closer = lastDelim;
+ while(closer.previous != begin)
+ closer = closer.previous;
+
+ // Loop all delimeters
+ closer = closer.next;
+ while(closer != null) {
+ if(closer.canClose) {
+ // Find opener
+ for(Delimiter opener = closer.previous; opener != begin; opener = opener.previous) {
+ if(opener.canOpen && opener.delimChar == closer.delimChar) {
+ closer = insertEmph(opener, closer);
+ break;
+ }
+ }
+ }
+ closer = closer.next;
+ }
+ }
+
+ private Delimiter insertEmph(Delimiter opener, Delimiter closer) {
+ // Remove all delimiters between opener and closer
+ opener.next = closer;
+ closer.previous = opener;
+
+ // Length
+ int openerLength = opener.inlText.stringContent.length();
+ int closerLength = closer.inlText.stringContent.length();
+ int commonLength = Math.min(openerLength, closerLength);
+ if(commonLength > 2)
+ commonLength = 2 - (closerLength % 2);
+
+ // Add emph
+ EmphNode emph = new EmphNode(commonLength==2);
+ emph.firstChild = opener.inlText.next;
+ emph.lastChild = closer.inlText.prev;
+ emph.firstChild.prev = null;
+ emph.lastChild.next = null;
+ opener.inlText.next = emph;
+ closer.inlText.prev = emph;
+ emph.next = closer.inlText;
+ emph.prev = opener.inlText;
+ emph.parent = opener.inlText.parent;
+ for(Node node = emph.firstChild;node != null;node = node.next)
+ node.parent = emph;
+
+ // Remove
+ if(openerLength == commonLength) {
+ removeDelim(opener);
+ opener.inlText.remove();
+ }
+ else
+ opener.inlText.stringContent.delete(openerLength-commonLength, openerLength);
+ if(closerLength == commonLength) {
+ removeDelim(closer);
+ closer.inlText.remove();
+ return closer;
+ }
+ else {
+ closer.inlText.stringContent.delete(closerLength-commonLength, closerLength);
+ if(closer.previous != null)
+ return closer.previous;
+ else
+ return closer;
+ }
+ }
+
+ private boolean parseInline(Node parent) {
+ Node newInl = null;
+ char c = peekChar();
+ if(c == 0)
+ return false;
+ switch(c) {
+ case '\\':
+ newInl = handleBackslash();
+ break;
+
+ case '`':
+ newInl = handleBackticks();
+ break;
+
+ case '<':
+ newInl = handlePointyBrace();
+ break;
+
+ case '\n':
+ newInl = handleNewline();
+ break;
+
+ case '[':
+ newInl = new TextNode(new StringBuilder("["));
+ lastDelim = new Delimiter(lastDelim, newInl, pos, '[', false, false);
+ ++pos;
+ break;
+
+ case '!':
+ ++pos;
+ if(peekChar() == '[') {
+ newInl = new TextNode(new StringBuilder("!["));
+ lastDelim = new Delimiter(lastDelim, newInl, pos-1, '!', false, false);
+ ++pos;
+ }
+ else
+ newInl = new TextNode(new StringBuilder("!"));
+ break;
+
+ case ']':
+ newInl = handleCloseBracket();
+ if(newInl == null)
+ newInl = new TextNode(new StringBuilder("]"));
+ break;
+
+ case '&':
+ newInl = handleEntity();
+ if(newInl == null)
+ newInl = new TextNode(new StringBuilder("&"));
+ break;
+
+ case '*':
+ case '_':
+ case '\'':
+ case '"':
+ newInl = handleDelim(c);
+ break;
+ default: {
+ int startPos = pos;
+ ++pos;
+ while(pos < input.length() && !isSpecialChar(input.charAt(pos)))
+ ++pos;
+ char nc = peekChar();
+ int tEnd = pos;
+ if(nc == '\n' || nc == 0) {
+ while(tEnd > startPos && input.charAt(tEnd-1) == ' ')
+ --tEnd;
+ }
+ newInl = new TextNode(new StringBuilder(input.subSequence(startPos, tEnd)));
+ }
+ }
+ if(newInl != null)
+ addChild(parent, newInl);
+ return true;
+ }
+
+ private Node handleEntity() {
+ ++pos;
+ if(peekChar() == '#') {
+ int p = pos+1;
+ if(p == input.length())
+ return null;
+ char c = input.charAt(p);
+ if(c == 'x' || c == 'X') {
+ int code = 0;
+ for(int i=0;i<8;++i) {
+ ++p;
+ c = input.charAt(p);
+ if(c == ';') {
+ if(p == pos+2)
+ return null;
+ pos = p+1;
+ if(!Character.isValidCodePoint(code))
+ code = 0xFFFD;
+ return new TextNode(new StringBuilder(new String(new int[] {code}, 0, 1)));
+ }
+ else if(c >= '0' && c <= '9') {
+ code *= 16;
+ code += (int)(c - '0');
+ }
+ else if(c >= 'a' && c <= 'f') {
+ code *= 16;
+ code += (int)(c - 'a') + 10;
+ }
+ else if(c >= 'A' && c <= 'F') {
+ code *= 16;
+ code += (int)(c - 'A') + 10;
+ }
+ }
+ return null;
+ }
+ else if(c >= '0' && c <= '9'){
+ int code = (int)(c - '0');
+ for(int i=0;i<8;++i) {
+ ++p;
+ c = input.charAt(p);
+ if(c == ';') {
+ if(p == pos+1)
+ return null;
+ pos = p+1;
+ if(!Character.isValidCodePoint(code))
+ code = 0xFFFD;
+ return new TextNode(new StringBuilder(new String(new int[] {code}, 0, 1)));
+ }
+ else if(c >= '0' && c <= '9') {
+ code *= 10;
+ code += (int)(c - '0');
+ }
+ }
+ return null;
+ }
+ else
+ return null;
+ }
+ else {
+ int maxPos = Math.min(input.length(), pos+Entities.MAX_ENTITY_LENGTH+1);
+ int p = pos;
+ while(p < maxPos) {
+ char c = input.charAt(p++);
+ if(c == ';') {
+ String entity = input.substring(pos, p-1);
+ String character = Entities.ENTITY_MAP.get(entity);
+ if(character == null)
+ return null;
+ else {
+ pos = p;
+ return new TextNode(new StringBuilder(character));
+ }
+ }
+ }
+ return null;
+ }
+ }
+
+ private Node handleCloseBracket() {
+ ++pos;
+ Delimiter opener = lastDelim;
+ while(opener != null) {
+ if(opener.delimChar == '[' || opener.delimChar == '!')
+ break;
+ opener = opener.previous;
+ }
+ if(opener == null)
+ return null;
+ remove(opener);
+ if(!opener.active)
+ return null;
+
+ String label = input.substring(opener.position+(opener.delimChar == '[' ? 1 : 2), pos-1);
+
+ String url, title;
+
+ int urlStart, urlEnd;
+ if(pos < input.length() && input.charAt(pos) == '('
+ && (urlStart = Scanner.scanWhitespace(input, pos+1)) >= 0
+ && (urlEnd = Scanner.scanLinkUrl(input, urlStart)) >= 0) {
+ int titleStart = Scanner.scanWhitespace(input, urlEnd);
+ if(titleStart == -1)
+ return null;
+ int titleEnd = titleStart == urlEnd ? titleStart : Scanner.scanLinkTitle(input, titleStart);
+ if(titleEnd == -1)
+ return null;
+ int endAll = Scanner.scanWhitespace(input, titleEnd);
+ if(endAll == -1 || input.charAt(endAll) != ')')
+ return null;
+ pos = endAll + 1;
+
+ if(input.charAt(urlStart) == '<')
+ url = input.substring(urlStart+1, urlEnd-1);
+ else
+ url = input.substring(urlStart, urlEnd);
+ url = Reference.cleanUrl(url);
+ title = titleStart==titleEnd ? "" : Reference.cleanTitle(input.substring(titleStart+1, titleEnd-1));
+ }
+ else {
+ int originalPos = pos;
+ String normalizedLabel = null;
+ tryLink: {
+ int linkStart = Scanner.scanWhitespace(input, pos);
+ if(linkStart == -1 || input.charAt(linkStart) != '[')
+ break tryLink;
+ int linkEnd = Scanner.scanLinkLabel(input, linkStart);
+ if(linkEnd == -1)
+ break tryLink;
+ if(linkStart+2 < linkEnd)
+ normalizedLabel = Reference.normalizeLabel(input.substring(linkStart+1, linkEnd-1));
+ pos = linkEnd;
+ }
+
+ if(normalizedLabel == null)
+ normalizedLabel = Reference.normalizeLabel(label);
+ Reference reference = referenceMap.get(normalizedLabel);
+ if(reference == null) {
+ pos = originalPos;
+ return null;
+ }
+ url = reference.url;
+ title = reference.title;
+ }
+
+ Node newLast = opener.inlText.prev;
+ Node parent = opener.inlText.parent;
+ Node newNode;
+ processEmphasis(opener.previous);
+ if(opener.delimChar == '[') {
+ newNode = new LinkNode(label, url, title);
+ }
+ else {
+ newNode = new ImageNode(label, url, title);
+ }
+ opener.inlText.prev = null;
+ newNode.firstChild = opener.inlText;
+ newNode.lastChild = parent.lastChild;
+ for(Node node = newNode.firstChild;node != null;node = node.next)
+ node.parent = newNode;
+ opener.inlText.remove();
+
+ parent.lastChild = newLast;
+ if(newLast != null)
+ newLast.next = null;
+ else
+ parent.firstChild = null;
+
+ lastDelim = opener.previous;
+ if(lastDelim != null)
+ lastDelim.next = null;
+
+ if(opener.delimChar == '[')
+ for(Delimiter cur = lastDelim;cur != null && cur.active; cur = cur.previous)
+ if(cur.delimChar == '[')
+ cur.active = false;
+
+ return newNode;
+ }
+
+ private void remove(Delimiter delimiter) {
+ if(delimiter.previous != null)
+ delimiter.previous.next = delimiter.next;
+ if(delimiter.next != null)
+ delimiter.next.previous = delimiter.previous;
+ else
+ lastDelim = delimiter.previous;
+ }
+
+ private Node handleNewline() {
+ int nlPos = pos;
+ ++pos;
+ while(peekChar() == ' ')
+ ++pos;
+ if(nlPos > 1 && input.charAt(nlPos-1) == ' ' && input.charAt(nlPos-2) == ' ')
+ return new HardLineBreakNode();
+ else
+ return new TextNode(new StringBuilder("\n"));
+ }
+
+ private Node handlePointyBrace() {
+ ++pos;
+
+ // URL
+ int p = Scanner.scanUri(input, pos);
+ if(p >= 0) {
+ Node result = new AutolinkNode(new StringBuilder(input.substring(pos, p-1)), false);
+ pos = p;
+ return result;
+ }
+
+ p = Scanner.scanEmail(input, pos);
+ if(p >= 0) {
+ Node result = new AutolinkNode(new StringBuilder(input.substring(pos, p-1)), true);
+ pos = p;
+ return result;
+ }
+
+ // HTML tag
+ p = Scanner.scanHtmlTag(input, pos);
+ if(p >= 0) {
+ Node result = new HtmlTagNode(new StringBuilder(input.substring(pos-1, p)));
+ pos = p;
+ return result;
+ }
+ return new TextNode(new StringBuilder("<"));
+ }
+
+ private Node handleBackslash() {
+ ++pos;
+ char c = peekChar();
+ ++pos;
+ if(c == 0) {
+ StringBuilder b = new StringBuilder(2);
+ b.append('\\');
+ return new TextNode(b);
+ }
+ if(getCharType(c)==2) {
+ StringBuilder b = new StringBuilder(1);
+ b.append(c);
+ return new TextNode(b);
+ }
+ else if(c == '\n')
+ return new HardLineBreakNode();
+ else {
+ StringBuilder b = new StringBuilder(2);
+ b.append('\\');
+ b.append(c);
+ return new TextNode(b);
+ }
+ }
+
+ private Node handleBackticks() {
+ int startPos = pos;
+ while(peekChar() == '`')
+ ++pos;
+ int tickCount = pos-startPos;
+ char c;
+ int endTickCount;
+ do {
+ while((c = peekChar()) != '`' && c != 0)
+ ++pos;
+ if(c == 0) {
+ pos = startPos+tickCount;
+ StringBuilder b = new StringBuilder(tickCount);
+ for(int i=0;i<tickCount;++i)
+ b.append('`');
+ return new TextNode(b);
+ }
+ endTickCount = 0;
+ while(peekChar() == '`') {
+ ++pos;
+ ++endTickCount;
+ }
+ } while(endTickCount != tickCount);
+ return new CodeNode(normalizeWhitespace(startPos+tickCount, pos-tickCount));
+ }
+
+ private StringBuilder normalizeWhitespace(int begin, int end) {
+ while(begin < end && isWhitespace(input.charAt(begin)))
+ ++begin;
+ while(begin < end && isWhitespace(input.charAt(end-1)))
+ --end;
+ StringBuilder b = new StringBuilder(end-begin);
+ boolean lastCharWasWhitespace = false;
+ while(begin < end) {
+ char c = input.charAt(begin++);
+ if(isWhitespace(c)) {
+ if(!lastCharWasWhitespace) {
+ lastCharWasWhitespace = true;
+ b.append(' ');
+ }
+ }
+ else {
+ lastCharWasWhitespace = false;
+ b.append(c);
+ }
+ }
+ return b;
+ }
+
+ private static boolean isWhitespace(char c) {
+ return c == ' ' || c == '\n';
+ }
+
+ private Node handleDelim(char c) {
+ char beforeChar;
+ char afterChar;
+ int startPos = pos;
+
+ if(pos == 0)
+ beforeChar = '\n';
+ else
+ beforeChar = input.charAt(pos-1);
+
+ ++pos;
+ while(pos < input.length() && input.charAt(pos) == c)
+ ++pos;
+
+ if(pos == input.length())
+ afterChar = '\n';
+ else
+ afterChar = input.charAt(pos);
+
+ int beforeCharType = getCharType(beforeChar);
+ int afterCharType = getCharType(afterChar);
+ boolean leftFlanking = afterCharType != CHAR_TYPE_WHITESPACE &&
+ (afterCharType != CHAR_TYPE_PUNCTUATION || beforeCharType != CHAR_TYPE_OTHER);
+ boolean rightFlanking = beforeCharType != CHAR_TYPE_WHITESPACE &&
+ (beforeCharType != CHAR_TYPE_PUNCTUATION || afterCharType != CHAR_TYPE_OTHER);
+
+ boolean canOpen;
+ boolean canClose;
+ if(c == '_') {
+ canOpen = leftFlanking && (rightFlanking ? beforeCharType == CHAR_TYPE_PUNCTUATION : true);
+ canClose = rightFlanking && (leftFlanking ? afterCharType == CHAR_TYPE_PUNCTUATION : true);
+ }
+ else {
+ canOpen = leftFlanking;
+ canClose = rightFlanking;
+ }
+
+ Node inlText = new TextNode(new StringBuilder(input.subSequence(startPos, pos)));
+ lastDelim = new Delimiter(lastDelim, inlText, pos, c, canOpen, canClose);
+ return inlText;
+ }
+
+ public static final int CHAR_TYPE_WHITESPACE = 1;
+ public static final int CHAR_TYPE_PUNCTUATION = 2;
+ public static final int CHAR_TYPE_OTHER = 0;
+
+ public static int getCharType(char c) {
+ switch(c) {
+ case ' ':
+ case '\n':
+ return CHAR_TYPE_WHITESPACE;
+ case '!':
+ case '"':
+ case '#':
+ case '$':
+ case '%':
+ case '&':
+ case '\'':
+ case '(':
+ case ')':
+ case '*':
+ case '+':
+ case ',':
+ case '-':
+ case '.':
+ case '/':
+ case ':':
+ case ';':
+ case '<':
+ case '=':
+ case '>':
+ case '?':
+ case '@':
+ case '[':
+ case '\\':
+ case ']':
+ case '^':
+ case '_':
+ case '`':
+ case '{':
+ case '|':
+ case '}':
+ case '~':
+ return CHAR_TYPE_PUNCTUATION;
+ default:
+ return CHAR_TYPE_OTHER;
+ }
+ }
+
+ private char peekChar() {
+ if(pos < input.length())
+ return input.charAt(pos);
+ else
+ return 0;
+ }
+
+ private boolean isEof() {
+ return pos >= input.length();
+ }
+
+ static final boolean[] SPECIAL_CHARS = new boolean[128];
+ static final String SPECIALS_STRING = "\n\\`&_*[]<!";
+ static {
+ for(int i=0;i<SPECIALS_STRING.length();++i)
+ SPECIAL_CHARS[(int)SPECIALS_STRING.charAt(i)] = true;
+ }
+
+ static private boolean isSpecialChar(char c) {
+ return c >= 0 && c < 128 && SPECIAL_CHARS[(int)c];
+ }
+
+ private void addChild(Node parent, Node child) {
+ child.parent = parent;
+ if(parent.lastChild == null)
+ parent.firstChild = child;
+ else {
+ Node oldLast = parent.lastChild;
+ oldLast.next = child;
+ child.prev = oldLast;
+ }
+ parent.lastChild = child;
+ }
+
+ private void removeDelim(Delimiter delim) {
+ Delimiter previous = delim.previous;
+ Delimiter next = delim.next;
+ if(delim == lastDelim)
+ lastDelim = previous;
+ else
+ next.previous = previous;
+ if(previous != null)
+ previous.next = next;
+ }
+}
Code Review / simantics / platform.git / blobdiff