开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > PlugIns编程 > 查看源码
XmlReconcilingStrategy.java
资源名称：xmlEditorPlugin.zip　[点击查看]
上传用户：fanxing
上传日期：2017-01-19
资源大小：36k
文件大小：16k
源码类别：

PlugIns编程

开发平台：

Java

XmlReconcilingStrategy.java：源码内容
  1. /*******************************************************************************
  2. * Copyright (c) 2005 Prashant Deva and Gerd Castan
  3. *
  4. * All rights reserved. This program and the accompanying materials
  5. * are made available under the terms of the Eclipse Public License - v 1.0
  6. * which is available at http://www.eclipse.org/legal/epl-v10.html
  7. *******************************************************************************/
  9. package projection_test.editors;
  11. import java.util.ArrayList;
  12. import org.eclipse.core.runtime.IProgressMonitor;
  13. import org.eclipse.jface.text.BadLocationException;
  14. import org.eclipse.jface.text.IDocument;
  15. import org.eclipse.jface.text.IRegion;
  16. import org.eclipse.jface.text.Position;
  17. import org.eclipse.jface.text.reconciler.DirtyRegion;
  18. import org.eclipse.jface.text.reconciler.IReconcilingStrategy;
  19. import org.eclipse.jface.text.reconciler.IReconcilingStrategyExtension;
  20. import org.eclipse.swt.widgets.Display;
  22. public class XmlReconcilingStrategy implements IReconcilingStrategy,
  23.                IReconcilingStrategyExtension {
  25.        private XMLEditor editor;
  27.        private IDocument fDocument;
  29.        /** holds the calculated positions */
  30.        protected final ArrayList fPositions = new ArrayList();
  32.        /** The offset of the next character to be read */
  33.        protected int fOffset;
  35.        /** The end offset of the range to be scanned */
  36.        protected int fRangeEnd;
  38.        /**
  39.         * @return Returns the editor.
  40.         */
  41.        public XMLEditor getEditor() {
  42.                return editor;
  43.        }
  45.        public void setEditor(XMLEditor editor) {
  46.                this.editor = editor;
  47.        }
  49.        /*
  50.         * (non-Javadoc)
  51.         *
  52.         * @see org.eclipse.jface.text.reconciler.IReconcilingStrategy#setDocument(org.eclipse.jface.text.IDocument)
  53.         */
  54.        public void setDocument(IDocument document) {
  55.                this.fDocument = document;
  57.        }
  59.        /*
  60.         * (non-Javadoc)
  61.         *
  62.         * @see org.eclipse.jface.text.reconciler.IReconcilingStrategy#reconcile(org.eclipse.jface.text.reconciler.DirtyRegion,
  63.         *      org.eclipse.jface.text.IRegion)
  64.         */
  65.        public void reconcile(DirtyRegion dirtyRegion, IRegion subRegion) {
  66.                initialReconcile();
  67.        }
  69.        /*
  70.         * (non-Javadoc)
  71.         *
  72.         * @see org.eclipse.jface.text.reconciler.IReconcilingStrategy#reconcile(org.eclipse.jface.text.IRegion)
  73.         */
  74.        public void reconcile(IRegion partition) {
  75.                initialReconcile();
  76.        }
  78.        /*
  79.         * (non-Javadoc)
  80.         *
  81.         * @see org.eclipse.jface.text.reconciler.IReconcilingStrategyExtension#setProgressMonitor(org.eclipse.core.runtime.IProgressMonitor)
  82.         */
  83.        public void setProgressMonitor(IProgressMonitor monitor) {
  84.                // TODO Auto-generated method stub
  86.        }
  88.        /*
  89.         * (non-Javadoc)
  90.         *
  91.         * @see org.eclipse.jface.text.reconciler.IReconcilingStrategyExtension#initialReconcile()
  92.         */
  93.        public void initialReconcile() {
  94.                fOffset = 0;
  95.                fRangeEnd = fDocument.getLength();
  96.                calculatePositions();
  98.        }
  100.        /**
  101.         * next character position - used locally and only valid while
  102.         * {@link #calculatePositions()} is in progress.
  103.         */
  104.        protected int cNextPos = 0;
  106.        /** number of newLines found by {@link #classifyTag()} */
  107.        protected int cNewLines = 0;
  109.        protected char cLastNLChar = ' ';
  111.        protected static final int START_TAG = 1;
  113.        protected static final int LEAF_TAG = 2;
  115.        protected static final int END_TAG = 3;
  117.        protected static final int EOR_TAG = 4;
  119.        protected static final int COMMENT_TAG = 5;
  121.        protected static final int PI_TAG = 6;
  123.        /**
  124.         * uses {@link #fDocument}, {@link #fOffset} and {@link #fRangeEnd} to
  125.         * calculate {@link #fPositions}. About syntax errors: this method is not a
  126.         * validator, it is useful.
  127.         */
  128.        protected void calculatePositions() {
  129.                fPositions.clear();
  130.                cNextPos = fOffset;
  132.                try {
  133.                        recursiveTokens(0);
  134.                } catch (BadLocationException e) {
  135.                        e.printStackTrace();
  136.                }
  137.                // Collections.sort(fPositions, new RangeTokenComparator());
  139.                Display.getDefault().asyncExec(new Runnable() {
  140.                        public void run() {
  141.                                editor.updateFoldingStructure(fPositions);
  142.                        }
  144.                });
  145.        }
  147.        /**
  148.         * emits tokens to {@link #fPositions}.
  149.         *
  150.         * @return number of newLines
  151.         * @throws BadLocationException
  152.         */
  153.        protected int recursiveTokens(int depth) throws BadLocationException {
  154.                int newLines = 0;
  155.                while (cNextPos < fRangeEnd) {
  156.                        while (cNextPos < fRangeEnd) {
  157.                                char ch = fDocument.getChar(cNextPos++);
  158.                                switch (ch) {
  159.                                case '<':
  160.                                        int startOffset = cNextPos - 1;
  161.                                        int startNewLines = newLines;
  162.                                        int classification = classifyTag();
  163.                                        String tagString = fDocument.get(startOffset, Math.min(cNextPos - startOffset, fRangeEnd - startOffset)); // this is to see where we are in the debugger
  164.                                        newLines += cNewLines; // cNewLines is written by
  165.                                                                                        // classifyTag()
  167.                                        switch (classification) {
  168.                                        case START_TAG:
  169.                                                newLines += recursiveTokens(depth + 1);
  170.                                                if (newLines > startNewLines+1) {
  171.                                                        emitPosition(startOffset, cNextPos - startOffset);
  172.                                                }
  173.                                                break;
  174.                                        case LEAF_TAG:
  175.                                                if (newLines > startNewLines+1) {
  176.                                                        emitPosition(startOffset, cNextPos - startOffset);
  177.                                                }
  178.                                                break;
  179.                                        case COMMENT_TAG:
  180.                                                if (newLines > startNewLines+1) {
  181.                                                        emitPosition(startOffset, cNextPos - startOffset);
  182.                                                }
  183.                                                break;
  184.                                        case PI_TAG:
  185.                                                break;
  186.                                        case END_TAG:
  187.                                        case EOR_TAG:
  188.                                                return newLines;
  189.                                        default:
  190.                                                break;
  191.                                        }
  192.                                        break;
  193.                                case 'n':
  194.                                case 'r':
  195.                                        if ((ch == cLastNLChar) || (' ' == cLastNLChar)) {
  196.                                                newLines++;
  197.                                                cLastNLChar = ch;
  198.                                        }
  199.                                        break;
  200.                                default:
  201.                                        break;
  202.                                }
  203.                        }
  205.                }
  206.                return newLines;
  207.        }
  209.        protected void emitPosition(int startOffset, int length) {
  210.                fPositions.add(new Position(startOffset, length));
  211.        }
  213.        /**
  214.         * classsifies a tag: <br />
  215.         * &lt;?...?&gt;: {@link #PI_TAG} <br />
  216.         * &lt;!...--&gt;: {@link #COMMENT_TAG} <br />
  217.         * &lt;...&gt;: {@link #START_TAG} <br />
  218.         * &lt;.../&gt;: {@link #LEAF_TAG} <br />
  219.         * &lt;/...&gt;: {@link #END_TAG} <br />
  220.         * &lt;...: {@link #EOR_TAG} (end of range reached before closing &gt; is
  221.         * found). <br />
  222.         * when this method is called, {@link #cNextPos} must point to the character
  223.         * after &lt;, when it returns, it points to the character after &gt; or
  224.         * after the range. About syntax errors: this method is not a validator, it
  225.         * is useful. Side effect: writes number of found newLines to
  226.         * {@link #cNewLines}.
  227.         *
  228.         * @return the tag classification
  229.         */
  230.        protected int classifyTag() {
  231.                try {
  232.                        char ch = fDocument.getChar(cNextPos++);
  233.                        cNewLines = 0;
  235.                        // processing instruction?
  236.                        if ('?' == ch) {
  237.                                boolean piFlag = false;
  238.                                while (cNextPos < fRangeEnd) {
  239.                                        ch = fDocument.getChar(cNextPos++);
  240.                                        if (('>' == ch) && piFlag)
  241.                                                return PI_TAG;
  242.                                        piFlag = ('?' == ch);
  243.                                }
  244.                                return EOR_TAG;
  245.                        }
  247.                        // comment?
  248.                        if ('!' == ch) {
  249.                                cNextPos++; // must be '-' but we don't care if not
  250.                                cNextPos++; // must be '-' but we don't care if not
  251.                                int commEnd = 0;
  252.                                while (cNextPos < fRangeEnd) {
  253.                                        ch = fDocument.getChar(cNextPos++);
  254.                                        if (('>' == ch) && (commEnd >= 2))
  255.                                                return COMMENT_TAG;
  256.                                    if (('n' == ch) || (       'r' == ch)) {
  257.                                                if ((ch == cLastNLChar) || (' ' == cLastNLChar)) {
  258.                                                        cNewLines++;
  259.                                                        cLastNLChar = ch;
  260.                                                }
  261.                                    }
  262.                                        if ('-' == ch) {
  263.                                                commEnd++;
  264.                                        } else {
  265.                                                commEnd = 0;
  266.                                        }
  267.                                }
  268.                                return EOR_TAG;
  269.                        }
  271.                        // consume whitespaces
  272.                        while ((' ' == ch) || ('t' == ch) || ('n' == ch) || ('r' == ch)) {
  273.                                ch = fDocument.getChar(cNextPos++);
  274.                                if (cNextPos > fRangeEnd)
  275.                                        return EOR_TAG;
  276.                        }
  278.                        // end tag?
  279.                        if ('/' == ch) {
  280.                                while (cNextPos < fRangeEnd) {
  281.                                        ch = fDocument.getChar(cNextPos++);
  282.                                        if ('>' == ch) {
  283.                                                cNewLines += eatToEndOfLine();
  284.                                                return END_TAG;
  285.                                        }
  286.                                        if ('"' == ch) {
  287.                                                ch = fDocument.getChar(cNextPos++);
  288.                                                while ((cNextPos < fRangeEnd) && ('"' != ch)) {
  289.                                                        ch = fDocument.getChar(cNextPos++);
  290.                                                }
  291.                                        } else if (''' == ch) {
  292.                                                ch = fDocument.getChar(cNextPos++);
  293.                                                while ((cNextPos < fRangeEnd) && (''' != ch)) {
  294.                                                        ch = fDocument.getChar(cNextPos++);
  295.                                                }
  296.                                        }
  297.                                }
  298.                                return EOR_TAG;
  299.                        }
  301.                        // start tag or leaf tag?
  302.                        while (cNextPos < fRangeEnd) {
  303.                                ch = fDocument.getChar(cNextPos++);
  304.                                // end tag?
  305.                                s: switch (ch) {
  306.                                case '/':
  307.                                        while (cNextPos < fRangeEnd) {
  308.                                                ch = fDocument.getChar(cNextPos++);
  309.                                                if ('>' == ch) {
  310.                                                        cNewLines += eatToEndOfLine();
  311.                                                        return LEAF_TAG;
  312.                                                }
  313.                                        }
  314.                                        return EOR_TAG;
  315.                                case '"':
  316.                                        while (cNextPos < fRangeEnd) {
  317.                                                ch = fDocument.getChar(cNextPos++);
  318.                                                if ('"' == ch)
  319.                                                        break s;
  320.                                        }
  321.                                        return EOR_TAG;
  322.                                case ''':
  323.                                        while (cNextPos < fRangeEnd) {
  324.                                                ch = fDocument.getChar(cNextPos++);
  325.                                                if (''' == ch)
  326.                                                        break s;
  327.                                        }
  328.                                        return EOR_TAG;
  329.                                case '>':
  330.                                        cNewLines += eatToEndOfLine();
  331.                                        return START_TAG;
  332.                                default:
  333.                                        break;
  334.                                }
  336.                        }
  337.                        return EOR_TAG;
  339.                } catch (BadLocationException e) {
  340.                        // should not happen, but we treat it as end of range
  341.                        return EOR_TAG;
  342.                }
  343.        }
  345.        protected int eatToEndOfLine() throws BadLocationException {
  346.                if (cNextPos >= fRangeEnd) {
  347.                        return 0;
  348.                }
  349.                char ch = fDocument.getChar(cNextPos++);
  350.                // 1. eat all spaces and tabs
  351.                while ((cNextPos < fRangeEnd) && ((' ' == ch) || ('t' == ch))) {
  352.                        ch = fDocument.getChar(cNextPos++);
  353.                }
  354.                if (cNextPos >= fRangeEnd) {
  355.                        cNextPos--;
  356.                        return 0;
  357.                }
  359.                // now ch is a new line or a non-whitespace
  360.                if ('n' == ch) {
  361.                        if (cNextPos < fRangeEnd) {
  362.                                ch = fDocument.getChar(cNextPos++);
  363.                                if ('r' != ch) {
  364.                                        cNextPos--;
  365.                                }
  366.                        } else {
  367.                                cNextPos--;
  368.                        }
  369.                        return 1;
  370.                }
  372.                if ('r' == ch) {
  373.                        if (cNextPos < fRangeEnd) {
  374.                                ch = fDocument.getChar(cNextPos++);
  375.                                if ('n' != ch) {
  376.                                        cNextPos--;
  377.                                }
  378.                        } else {
  379.                                cNextPos--;
  380.                        }
  381.                        return 1;
  382.                }
  384.                return 0;
  385.        }
  386. }