From 94c898ca475e0f9837f521987de0be4a2f6aa473 Mon Sep 17 00:00:00 2001 From: "Maxim.Mossienko" Date: Thu, 19 Apr 2012 15:11:46 +0400 Subject: [PATCH] localized old xml parsing --- .../src/com/intellij/lexer/_XmlLexer.flex | 2 +- .../src/com/intellij/lexer/__XmlLexer.java | 6 +- .../{OldXmlParsing.java => OldXmlParser.java} | 225 +++++++++++------- .../source/parsing/xml/XmlParsingContext.java | 45 ---- .../impl/source/xml/XmlEntityDeclImpl.java | 140 ++--------- .../com/intellij/psi/xml/XmlElementType.java | 23 +- .../src/com/intellij/xml/util/XmlUtil.java | 20 +- .../com/intellij/psi/xml/XmlEntityDecl.java | 13 +- 8 files changed, 194 insertions(+), 280 deletions(-) rename xml/impl/src/com/intellij/psi/impl/source/parsing/xml/{OldXmlParsing.java => OldXmlParser.java} (83%) delete mode 100644 xml/impl/src/com/intellij/psi/impl/source/parsing/xml/XmlParsingContext.java diff --git a/xml/impl/src/com/intellij/lexer/_XmlLexer.flex b/xml/impl/src/com/intellij/lexer/_XmlLexer.flex index 5e4d5d2d7b6e..7715b9675800 100644 --- a/xml/impl/src/com/intellij/lexer/_XmlLexer.flex +++ b/xml/impl/src/com/intellij/lexer/_XmlLexer.flex @@ -122,7 +122,7 @@ CONDITIONAL_COMMENT_CONDITION=({ALPHA})({ALPHA}|{S}|{DIGIT}|"."|"("|")"|"|"|"!"| {NAME} { return XmlTokenType.XML_NAME; } "\""[^\"]*"\"" { return XmlTokenType.XML_ATTRIBUTE_VALUE_TOKEN;} "'"[^']*"'" { return XmlTokenType.XML_ATTRIBUTE_VALUE_TOKEN;} - "["(([^\]\"]*)|(\"[^\"]*\"))*"]" { return XmlElementType.XML_MARKUP;} + "["(([^\]\"]*)|(\"[^\"]*\"))*"]" { return XmlElementType.XML_MARKUP_DECL;} ">" { yybegin(YYINITIAL); return XmlTokenType.XML_DOCTYPE_END; } " myNames; + private final XmlEntityDecl.EntityContextType myContextType; + private PsiElement myContext; + public static final XmlEntityDecl.EntityContextType TYPE_FOR_MARKUP_DECL = XmlEntityDecl.EntityContextType.ELEMENT_CONTENT_SPEC; - public OldXmlParsing(XmlParsingContext context) { + public OldXmlParser(CharSequence chars, + IElementType type, + XmlEntityDecl.EntityContextType contextType, + CharTable charTable, + @Nullable PsiManager manager) { + this(chars, type, contextType, charTable, manager, null, null); + } + + public OldXmlParser(CharSequence chars, + IElementType type, + XmlEntityDecl.EntityContextType contextType, + CharTable charTable, + @Nullable PsiManager manager, + @Nullable Set names, + @Nullable PsiElement context) { + myCharTable = charTable; + myRootType = type; + myManager = manager; + myContextType = contextType; + myNames = names; + myBuffer = chars; myContext = context; } + public ASTNode parse() { + final FileElement holderElement = myManager != null ? DummyHolderFactory.createHolder(myManager, myContext).getTreeElement():null; - public TreeElement parse(Lexer originalLexer, CharSequence buffer, int startOffset, int endOffset, PsiManager manager) { - final Lexer lexer = new FilterLexer(originalLexer, new FilterLexer.SetFilter(XML_WHITE_SPACE_OR_COMMENT_BIT_SET)); - lexer.start(buffer, startOffset, endOffset); + Lexer lexer = getLexer(myContextType, myBuffer); + int state = lexer.getState(); + final CompositeElement root = ASTFactory.composite(myRootType); + if (holderElement != null) holderElement.rawAddChildren(root); - final FileElement dummyRoot = DummyHolderFactory.createHolder(manager, null, myContext.getCharTable()).getTreeElement(); + XmlEntityDecl.EntityContextType contextType = myContextType; - CompositeElement root = ASTFactory.composite(XML_DOCUMENT); - dummyRoot.rawAddChildren(root); - root.rawAddChildren(parseProlog(lexer)); - parseGenericXml(lexer, root, new HashSet()); + if (myRootType == XML_DOCUMENT) { + root.rawAddChildren(parseProlog(lexer)); + } else if (myRootType == XML_MARKUP_DECL) { + parseMarkupDecl(lexer, root); + contextType = null; + } - insertMissingTokens(root, - originalLexer, - startOffset, - endOffset, - -1, WhiteSpaceAndCommentsProcessor.INSTANCE, myContext); + if (contextType != null) { + switch (contextType) { + case GENERIC_XML: + parseGenericXml(lexer, root, myNames != null ? myNames : new THashSet()); + break; + case ELEMENT_CONTENT_SPEC: + parseElementContentSpec(root, lexer); + break; + case ATTLIST_SPEC: + parseAttlistContent(root, lexer); + break; + case ATTR_VALUE: + parseAttrValue(root, lexer); + case ATTRIBUTE_SPEC: + parseAttributeContentSpec(root, lexer); + break; + case ENTITY_DECL_CONTENT: + parseEntityDeclContent(root, lexer); + break; + case ENUMERATED_TYPE: + parseEnumeratedTypeContent(root, lexer); + break; + } + } + + if (myContext == null && contextType != XmlEntityDecl.EntityContextType.ELEMENT_CONTENT_SPEC) { // TODO: FIXME code for tests compatibility + insertMissingTokens(root, ((FilterLexer)lexer).getOriginal(), 0, myBuffer.length(), state, new WhiteSpaceAndCommentsProcessor()); + } return root; } - public void parseGenericXml(Lexer lexer, CompositeElement root, Set names) { - boolean rootTagChecked = false; + private Lexer getLexer(XmlEntityDecl.EntityContextType context, CharSequence buffer) { + Lexer lexer = new XmlPsiLexer(); + FilterLexer filterLexer = new FilterLexer(lexer, new FilterLexer.SetFilter(OldXmlParser.XML_WHITE_SPACE_OR_COMMENT_BIT_SET)); + short state = 0; + + switch (context) { + case ELEMENT_CONTENT_SPEC: + case ATTRIBUTE_SPEC: + case ATTLIST_SPEC: + case ENUMERATED_TYPE: + case ENTITY_DECL_CONTENT: + { + state = _OldXmlLexer.DOCTYPE_MARKUP; + break; + } + + case ATTR_VALUE: + case GENERIC_XML: { + break; + } + + + default: LOG.error("context: " + context); + } + + if (myRootType == XML_MARKUP_DECL && context == TYPE_FOR_MARKUP_DECL) { + state = _OldXmlLexer.DOCTYPE; + } + + filterLexer.start(buffer, 0, buffer.length(), state); + return filterLexer; + } + + + private void parseGenericXml(Lexer lexer, CompositeElement root, Set names) { IElementType tokenType; while ((tokenType = lexer.getTokenType()) != null) { @@ -101,27 +195,12 @@ public class OldXmlParsing implements XmlElementType { else if (parseConditionalSection(root, lexer)) { } else if (tokenType != null) { - if (!rootTagChecked) { - //checkRootTag(root); - rootTagChecked = true; - } - addToken(root, lexer); } } - - if (!rootTagChecked) { - //checkRootTag(root); - rootTagChecked = true; - } - - insertMissingTokens(root, ((FilterLexer)lexer).getOriginal(), - 0, - lexer.getBufferEnd(), - -1, WhiteSpaceAndCommentsProcessor.INSTANCE, myContext); } - public TreeElement parseNotationDecl(Lexer lexer) { + private TreeElement parseNotationDecl(Lexer lexer) { CompositeElement decl = ASTFactory.composite(XML_NOTATION_DECL); if (lexer.getTokenType() != XML_NOTATION_DECL_START) { @@ -179,7 +258,7 @@ public class OldXmlParsing implements XmlElementType { return false; } - public void parseEntityDeclContent(CompositeElement decl, Lexer lexer) { + private void parseEntityDeclContent(CompositeElement decl, Lexer lexer) { IElementType tokenType = lexer.getTokenType(); if (tokenType != XML_ATTRIBUTE_VALUE_START_DELIMITER && tokenType != XML_DOCTYPE_PUBLIC && @@ -325,7 +404,7 @@ public class OldXmlParsing implements XmlElementType { return false; } - TreeElement endTagStart = createTokenElement(lexer, myContext.getCharTable()); + TreeElement endTagStart = createTokenElement(lexer, myCharTable); lexer.advance(); if (lexer.getTokenType() != XML_TAG_NAME) { @@ -368,7 +447,7 @@ public class OldXmlParsing implements XmlElementType { return true; } - public static TreeElement createTokenElement(Lexer lexer, CharTable table) { + private static TreeElement createTokenElement(Lexer lexer, CharTable table) { IElementType tokenType = lexer.getTokenType(); if (tokenType == null) return null; return ASTFactory.leaf(tokenType, LexerUtil.internToken(lexer, table)); @@ -533,7 +612,7 @@ public class OldXmlParsing implements XmlElementType { return false; } - public ASTNode parseElementContentSpec(CompositeElement parent, Lexer lexer) { + private ASTNode parseElementContentSpec(CompositeElement parent, Lexer lexer) { return doParseContentSpec(parent, lexer, true); } @@ -668,7 +747,7 @@ public class OldXmlParsing implements XmlElementType { return decl; } - public void parseAttlistContent(CompositeElement parent, Lexer lexer) { + private void parseAttlistContent(CompositeElement parent, Lexer lexer) { while (true) { if (lexer.getTokenType() == XML_ENTITY_REF_TOKEN) { parent.rawAddChildren(parseEntityRef(lexer)); @@ -694,7 +773,7 @@ public class OldXmlParsing implements XmlElementType { return parseAttributeContentSpec(decl, lexer); } - public boolean parseAttributeContentSpec(CompositeElement parent, Lexer lexer) { + private boolean parseAttributeContentSpec(CompositeElement parent, Lexer lexer) { if (parseName(parent, lexer)) { } else if (lexer.getTokenType() == XML_LEFT_PAREN) { @@ -737,7 +816,7 @@ public class OldXmlParsing implements XmlElementType { return enumeratedType; } - public void parseEnumeratedTypeContent(CompositeElement enumeratedType, Lexer lexer) { + private void parseEnumeratedTypeContent(CompositeElement enumeratedType, Lexer lexer) { while (true) { if (lexer.getTokenType() == XML_ENTITY_REF_TOKEN) { enumeratedType.rawAddChildren(parseEntityRef(lexer)); @@ -749,7 +828,7 @@ public class OldXmlParsing implements XmlElementType { } } - TreeElement parseDecl(Lexer lexer) { + private TreeElement parseDecl(Lexer lexer) { CompositeElement decl = ASTFactory.composite(XML_DECL); if (lexer.getTokenType() != XML_DECL_START) { @@ -877,7 +956,7 @@ public class OldXmlParsing implements XmlElementType { } private TreeElement addToken(CompositeElement decl, Lexer lexer) { - final TreeElement element = createTokenElement(lexer, myContext.getCharTable()); + final TreeElement element = createTokenElement(lexer, myCharTable); if (element != null) { decl.rawAddChildren(element); myLastTokenEnd = lexer.getTokenEnd(); @@ -886,13 +965,7 @@ public class OldXmlParsing implements XmlElementType { return element; } - public TreeElement parseMarkupDecl(CharSequence text) { - CompositeElement root = ASTFactory.composite(XML_MARKUP_DECL); - - OldXmlLexer originalLexer = new OldXmlLexer(); - final Lexer lexer = new FilterLexer(originalLexer, new FilterLexer.SetFilter(XML_WHITE_SPACE_OR_COMMENT_BIT_SET)); - lexer.start(text, 0, text.length(), _OldXmlLexer.DOCTYPE); - + private TreeElement parseMarkupDecl(Lexer lexer, CompositeElement root) { parseMarkupContent(lexer, root); while (lexer.getTokenType() != null) { final TreeElement children; @@ -904,21 +977,17 @@ public class OldXmlParsing implements XmlElementType { children = parseEntityDecl(lexer); } else { - children = createTokenElement(lexer, myContext.getCharTable()); + children = createTokenElement(lexer, myCharTable); lexer.advance(); } root.rawAddChildren(children); } - originalLexer.start(text, 0, text.length(), _OldXmlLexer.DOCTYPE); - insertMissingTokens(root, originalLexer, 0, text.length(), _OldXmlLexer.DOCTYPE, WhiteSpaceAndCommentsProcessor.INSTANCE, myContext); - return root; - } - public void parseAttrValue(CompositeElement element, Lexer lexer) { + private void parseAttrValue(CompositeElement element, Lexer lexer) { while(lexer.getTokenType() != null) { if (lexer.getTokenType() == XML_ENTITY_REF_TOKEN) { final TreeElement children = parseEntityRef(lexer); @@ -929,13 +998,9 @@ public class OldXmlParsing implements XmlElementType { } } - public static class WhiteSpaceAndCommentsProcessor { - public static final WhiteSpaceAndCommentsProcessor INSTANCE = new WhiteSpaceAndCommentsProcessor(); + private class WhiteSpaceAndCommentsProcessor { - private WhiteSpaceAndCommentsProcessor() { - } - - public TreeElement process(Lexer lexer, XmlParsingContext context) { + private TreeElement process(Lexer lexer) { TreeElement first = null; TreeElement last = null; while (isTokenValid(lexer.getTokenType())) { @@ -948,10 +1013,10 @@ public class OldXmlParsing implements XmlElementType { } if (lexer.getTokenType() == XML_COMMENT_START) { - tokenElement = parseComment(lexer, context); + tokenElement = parseComment(lexer); } else { - tokenElement = createTokenElement(lexer, context.getCharTable()); + tokenElement = createTokenElement(lexer, myCharTable); lexer.advance(); } @@ -966,15 +1031,15 @@ public class OldXmlParsing implements XmlElementType { return first; } - public boolean isTokenValid(IElementType tokenType) { + private boolean isTokenValid(IElementType tokenType) { return tokenType != null && XML_WHITE_SPACE_OR_COMMENT_BIT_SET.contains(tokenType); } - private TreeElement parseComment(Lexer lexer, XmlParsingContext context) { + private TreeElement parseComment(Lexer lexer) { final CompositeElement comment = ASTFactory.composite(XML_COMMENT); while (lexer.getTokenType() != null && XML_COMMENT_BIT_SET.contains(lexer.getTokenType())) { - final TreeElement tokenElement = createTokenElement(lexer, context.getCharTable()); + final TreeElement tokenElement = createTokenElement(lexer, myCharTable); lexer.advance(); comment.rawAddChildren(tokenElement); } @@ -983,13 +1048,12 @@ public class OldXmlParsing implements XmlElementType { } } - public static void insertMissingTokens(CompositeElement root, + private void insertMissingTokens(CompositeElement root, Lexer lexer, int startOffset, int endOffset, int state, - WhiteSpaceAndCommentsProcessor processor, - XmlParsingContext context) { + WhiteSpaceAndCommentsProcessor processor) { if (state < 0) { lexer.start(lexer.getBufferSequence(), startOffset, endOffset); } @@ -999,7 +1063,7 @@ public class OldXmlParsing implements XmlElementType { LeafElement leaf = TreeUtil.findFirstLeaf(root); if (leaf == null) { - final TreeElement firstMissing = processor.process(lexer, context); + final TreeElement firstMissing = processor.process(lexer); if (firstMissing != null) { root.rawAddChildren(firstMissing); } @@ -1009,7 +1073,7 @@ public class OldXmlParsing implements XmlElementType { // Missing in the begining final IElementType tokenType = lexer.getTokenType(); if (tokenType != leaf.getElementType() && processor.isTokenValid(tokenType)) { - final TreeElement firstMissing = processor.process(lexer, context); + final TreeElement firstMissing = processor.process(lexer); if (firstMissing != null) { root.getFirstChildNode().rawInsertBeforeMe(firstMissing); } @@ -1017,10 +1081,10 @@ public class OldXmlParsing implements XmlElementType { passTokenOrChameleon(leaf, lexer); } // Missing in tree body - insertMissingTokensInTreeBody(leaf, lexer, processor, context, null); + insertMissingTokensInTreeBody(leaf, lexer, processor, null); if (lexer.getTokenType() != null) { // whitespaces at the end of the file - final TreeElement firstMissing = processor.process(lexer, context); + final TreeElement firstMissing = processor.process(lexer); if (firstMissing != null) { ASTNode current = root; while (current instanceof CompositeElement) { @@ -1039,7 +1103,6 @@ public class OldXmlParsing implements XmlElementType { private static void insertMissingTokensInTreeBody(TreeElement leaf, Lexer lexer, WhiteSpaceAndCommentsProcessor processor, - XmlParsingContext context, ASTNode endToken) { final TreeUtil.CommonParentState commonParents = new TreeUtil.CommonParentState(); while (leaf != null) { @@ -1049,7 +1112,7 @@ public class OldXmlParsing implements XmlElementType { if (next == null || tokenType == null || next == endToken) break; if (tokenType != next.getElementType() && processor.isTokenValid(tokenType)) { - final TreeElement firstMissing = processor.process(lexer, context); + final TreeElement firstMissing = processor.process(lexer); final CompositeElement unclosedElement = commonParents.strongWhiteSpaceHolder; if (unclosedElement != null) { if (commonParents.isStrongElementOnRisingSlope || unclosedElement.getFirstChildNode() == null) { @@ -1093,6 +1156,4 @@ public class OldXmlParsing implements XmlElementType { } lexer.advance(); } - - } diff --git a/xml/impl/src/com/intellij/psi/impl/source/parsing/xml/XmlParsingContext.java b/xml/impl/src/com/intellij/psi/impl/source/parsing/xml/XmlParsingContext.java deleted file mode 100644 index 77c23ef635ae..000000000000 --- a/xml/impl/src/com/intellij/psi/impl/source/parsing/xml/XmlParsingContext.java +++ /dev/null @@ -1,45 +0,0 @@ -/* - * Copyright 2000-2009 JetBrains s.r.o. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package com.intellij.psi.impl.source.parsing.xml; - -import com.intellij.lexer.Lexer; -import com.intellij.lexer.LexerUtil; -import com.intellij.util.CharTable; - -/** - * @author ven - */ -public class XmlParsingContext { - private final OldXmlParsing myXmlParsing; - private final CharTable myTable; - - public XmlParsingContext(final CharTable table) { - myTable = table; - myXmlParsing = new OldXmlParsing(this); - } - - public CharTable getCharTable() { - return myTable; - } - - public CharSequence tokenText(Lexer lexer) { - return LexerUtil.internToken(lexer, myTable); - } - - public OldXmlParsing getXmlParsing() { - return myXmlParsing; - } -} diff --git a/xml/impl/src/com/intellij/psi/impl/source/xml/XmlEntityDeclImpl.java b/xml/impl/src/com/intellij/psi/impl/source/xml/XmlEntityDeclImpl.java index a87b5905ddf5..be9dc8b88b49 100644 --- a/xml/impl/src/com/intellij/psi/impl/source/xml/XmlEntityDeclImpl.java +++ b/xml/impl/src/com/intellij/psi/impl/source/xml/XmlEntityDeclImpl.java @@ -15,26 +15,17 @@ */ package com.intellij.psi.impl.source.xml; -import com.intellij.lang.ASTFactory; import com.intellij.lang.ASTNode; -import com.intellij.lexer.FilterLexer; -import com.intellij.lexer.Lexer; -import com.intellij.lexer._OldXmlLexer; -import com.intellij.openapi.diagnostic.Logger; import com.intellij.openapi.util.TextRange; import com.intellij.pom.Navigatable; import com.intellij.psi.ElementManipulators; import com.intellij.psi.PsiElement; import com.intellij.psi.PsiFile; import com.intellij.psi.PsiNamedElement; -import com.intellij.psi.impl.source.DummyHolderFactory; import com.intellij.psi.impl.source.SourceTreeToPsiMap; -import com.intellij.psi.impl.source.parsing.xml.OldXmlParsing; -import com.intellij.psi.impl.source.parsing.xml.XmlParsingContext; -import com.intellij.psi.impl.source.parsing.xml.XmlPsiLexer; +import com.intellij.psi.impl.source.parsing.xml.OldXmlParser; import com.intellij.psi.impl.source.resolve.reference.impl.providers.URIReferenceProvider; -import com.intellij.psi.impl.source.tree.CompositeElement; -import com.intellij.psi.impl.source.tree.FileElement; +import com.intellij.psi.impl.source.tree.SharedImplUtil; import com.intellij.psi.tree.xml.IXmlLeafElementType; import com.intellij.psi.xml.*; import com.intellij.util.IncorrectOperationException; @@ -49,8 +40,6 @@ import java.util.Set; * @author mike */ public class XmlEntityDeclImpl extends XmlElementImpl implements XmlEntityDecl, XmlElementType { - private static final Logger LOG = Logger.getInstance("#com.intellij.psi.impl.source.xml.XmlEntityDeclImpl"); - public XmlEntityDeclImpl() { super(XML_ENTITY_DECL); } @@ -104,7 +93,7 @@ public class XmlEntityDeclImpl extends XmlElementImpl implements XmlEntityDecl, return null; } - public PsiElement parse(PsiFile baseFile, int context, final XmlEntityRef originalElement) { + public PsiElement parse(PsiFile baseFile, EntityContextType context, final XmlEntityRef originalElement) { PsiElement dep = XmlElement.DEPENDING_ELEMENT.get(getParent()); PsiElement dependsOnElement = getValueElement(dep instanceof PsiFile ? (PsiFile)dep : baseFile); String value = null; @@ -118,86 +107,30 @@ public class XmlEntityDeclImpl extends XmlElementImpl implements XmlEntityDecl, } if (value == null) return null; - final FileElement holderElement = DummyHolderFactory.createHolder(originalElement.getManager(), originalElement).getTreeElement(); - Lexer lexer = getLexer(context, value); - final XmlParsingContext parsingContext = new XmlParsingContext(holderElement.getCharTable()); - final CompositeElement element = ASTFactory.composite(XML_ELEMENT_DECL); - holderElement.rawAddChildren(element); - switch (context) { - default : - LOG.error("Entity: " + getName() + " context: " + context); - return null; + Set names = null; - case CONTEXT_ELEMENT_CONTENT_SPEC: - { - parsingContext.getXmlParsing().parseElementContentSpec(element, lexer); - final PsiElement generated = SourceTreeToPsiMap.treeElementToPsi(element).getFirstChild().getFirstChild(); - setDependsOnElement(generated, dependsOnElement); - return setOriginalElement(generated, originalElement); - } - - case CONTEXT_ATTRIBUTE_SPEC: - { - parsingContext.getXmlParsing().parseAttributeContentSpec(element, lexer); - final PsiElement generated = SourceTreeToPsiMap.treeElementToPsi(element).getFirstChild(); - setDependsOnElement(generated, dependsOnElement); - return setOriginalElement(generated, originalElement); - } - - case CONTEXT_ATTLIST_SPEC: - { - parsingContext.getXmlParsing().parseAttlistContent(element, lexer); - final PsiElement generated = SourceTreeToPsiMap.treeElementToPsi(element).getFirstChild(); - setDependsOnElement(generated, dependsOnElement); - return setOriginalElement(generated, originalElement); - } - - case CONTEXT_ATTR_VALUE: - { - parsingContext.getXmlParsing().parseAttrValue(element, lexer); - final PsiElement generated = SourceTreeToPsiMap.treeElementToPsi(element).getFirstChild(); - setDependsOnElement(generated, dependsOnElement); - return setOriginalElement(generated, originalElement); - } - - case CONTEXT_ENTITY_DECL_CONTENT: - { - parsingContext.getXmlParsing().parseEntityDeclContent(element, lexer); - final PsiElement generated = SourceTreeToPsiMap.treeElementToPsi(element).getFirstChild(); - setDependsOnElement(generated, dependsOnElement); - return setOriginalElement(generated, originalElement); - } - - case CONTEXT_GENERIC_XML: - { - - Set names = new HashSet(); - { - // calculating parent names - PsiElement parent = originalElement; - while(parent != null){ - if(parent instanceof XmlTag){ - names.add(((XmlTag)parent).getName()); - } - parent = parent.getParent(); - } - } - parsingContext.getXmlParsing().parseGenericXml(lexer, element, names); - final PsiElement generated = SourceTreeToPsiMap.treeElementToPsi(element).getFirstChild(); - setDependsOnElement(generated, dependsOnElement); - return setOriginalElement(generated, originalElement); - } - - case CONTEXT_ENUMERATED_TYPE: - { - parsingContext.getXmlParsing().parseEnumeratedTypeContent(element, lexer); - final PsiElement generated = SourceTreeToPsiMap.treeElementToPsi(element).getFirstChild(); - setDependsOnElement(generated, dependsOnElement); - return setOriginalElement(generated, originalElement); + if (context == EntityContextType.GENERIC_XML) { + names = new HashSet(); + // calculating parent names + PsiElement parent = originalElement; + while(parent != null){ + if(parent instanceof XmlTag){ + names.add(((XmlTag)parent).getName()); } + parent = parent.getParent(); + } } + + OldXmlParser oldXmlParser = new OldXmlParser(value, XML_ELEMENT_DECL, context, SharedImplUtil.findCharTableByTree(this), getManager(), names, + originalElement); + PsiElement generated = oldXmlParser.parse().getPsi().getFirstChild(); + if (context == EntityContextType.ELEMENT_CONTENT_SPEC) { + generated = generated.getFirstChild(); + } + setDependsOnElement(generated, dependsOnElement); + return setOriginalElement(generated, originalElement); } private PsiElement setDependsOnElement(PsiElement generated, PsiElement dependsOnElement) { @@ -218,35 +151,6 @@ public class XmlEntityDeclImpl extends XmlElementImpl implements XmlEntityDecl, return element; } - public static Lexer getLexer(int context, CharSequence buffer) { - Lexer lexer = new XmlPsiLexer(); - FilterLexer filterLexer = new FilterLexer(lexer, new FilterLexer.SetFilter(OldXmlParsing.XML_WHITE_SPACE_OR_COMMENT_BIT_SET)); - short state = 0; - - switch (context) { - case CONTEXT_ELEMENT_CONTENT_SPEC: - case CONTEXT_ATTRIBUTE_SPEC: - case CONTEXT_ATTLIST_SPEC: - case CONTEXT_ENUMERATED_TYPE: - case CONTEXT_ENTITY_DECL_CONTENT: - { - state = _OldXmlLexer.DOCTYPE_MARKUP; - break; - } - - case CONTEXT_ATTR_VALUE: - case CONTEXT_GENERIC_XML: { - break; - } - - - default: LOG.error("context: " + context); - } - - filterLexer.start(buffer, 0, buffer.length(), state); - return filterLexer; - } - @Nullable private PsiElement getValueElement(PsiFile baseFile) { final XmlAttributeValue attributeValue = getValueElement(); diff --git a/xml/impl/src/com/intellij/psi/xml/XmlElementType.java b/xml/impl/src/com/intellij/psi/xml/XmlElementType.java index 24e2316c169e..0db40f5eada0 100644 --- a/xml/impl/src/com/intellij/psi/xml/XmlElementType.java +++ b/xml/impl/src/com/intellij/psi/xml/XmlElementType.java @@ -21,9 +21,8 @@ import com.intellij.lang.dtd.DTDLanguage; import com.intellij.lang.html.HTMLLanguage; import com.intellij.lang.xhtml.XHTMLLanguage; import com.intellij.lang.xml.XMLLanguage; -import com.intellij.lexer.OldXmlLexer; import com.intellij.openapi.project.Project; -import com.intellij.psi.impl.source.parsing.xml.XmlParsingContext; +import com.intellij.psi.impl.source.parsing.xml.OldXmlParser; import com.intellij.psi.impl.source.tree.SharedImplUtil; import com.intellij.psi.tree.CustomParsingType; import com.intellij.psi.tree.IElementType; @@ -55,8 +54,6 @@ public interface XmlElementType extends XmlTokenType { IElementType XML_ENUMERATED_TYPE = new IXmlElementType("XML_ENUMERATED_TYPE"); IElementType XML_PROCESSING_INSTRUCTION = new IXmlElementType("XML_PROCESSING_INSTRUCTION"); IElementType XML_CDATA = new IXmlElementType("XML_CDATA"); - IElementType XML_DTD_DECL = new IXmlElementType("XML_DTD_DECL"); - IElementType XML_WHITE_SPACE_HOLDER = new IXmlElementType("XML_WHITE_SPACE_HOLDER"); //todo: move to html IElementType HTML_DOCUMENT = new IXmlElementType("HTML_DOCUMENT"); @@ -71,20 +68,20 @@ public interface XmlElementType extends XmlTokenType { IElementType DTD_FILE = new IReparseableElementType("DTD_FILE", DTDLanguage.INSTANCE){ public ASTNode parseContents(ASTNode chameleon) { - final CharSequence chars = chameleon.getChars(); - final CharTable table = SharedImplUtil.findCharTableByTree(chameleon); - final XmlParsingContext parsingContext = new XmlParsingContext(table); - return parsingContext.getXmlParsing().parse(new OldXmlLexer(), chars, 0, chars.length(), SharedImplUtil.getManagerByTree(chameleon)); + return new OldXmlParser(chameleon.getChars(), + XML_DOCUMENT, + XmlEntityDecl.EntityContextType.GENERIC_XML, + SharedImplUtil.findCharTableByTree(chameleon), + SharedImplUtil.getManagerByTree(chameleon) + ).parse(); } public boolean isParsable(CharSequence buffer, Language fileLanguage, final Project project) {return true;} }; - IElementType XML_MARKUP = new CustomParsingType("XML_MARKUP_DECL", XMLLanguage.INSTANCE){ + IElementType XML_MARKUP_DECL = new CustomParsingType("XML_MARKUP_DECL", XMLLanguage.INSTANCE){ public ASTNode parse(CharSequence text, CharTable table) { - final XmlParsingContext parsingContext = new XmlParsingContext(table); - return parsingContext.getXmlParsing().parseMarkupDecl(text); + // TODO + return new OldXmlParser(text, XML_MARKUP_DECL, OldXmlParser.TYPE_FOR_MARKUP_DECL, table, null).parse(); } }; - - IElementType XML_MARKUP_DECL = XmlElementType.XML_MARKUP; } diff --git a/xml/impl/src/com/intellij/xml/util/XmlUtil.java b/xml/impl/src/com/intellij/xml/util/XmlUtil.java index ff45a36b38c3..32753e79b514 100644 --- a/xml/impl/src/com/intellij/xml/util/XmlUtil.java +++ b/xml/impl/src/com/intellij/xml/util/XmlUtil.java @@ -706,7 +706,7 @@ public class XmlUtil { } private static PsiElement parseEntityRef(PsiFile targetFile, XmlEntityRef ref, boolean cacheValue) { - int type = getContextType(ref); + XmlEntityDecl.EntityContextType type = getContextType(ref); { final XmlEntityDecl entityDecl = ref.resolve(targetFile); @@ -744,27 +744,27 @@ public class XmlUtil { return null; } - private static int getContextType(XmlEntityRef ref) { - int type = XmlEntityDecl.CONTEXT_GENERIC_XML; + private static XmlEntityDecl.EntityContextType getContextType(XmlEntityRef ref) { + XmlEntityDecl.EntityContextType type = XmlEntityDecl.EntityContextType.GENERIC_XML; PsiElement temp = ref; while (temp != null) { if (temp instanceof XmlAttributeDecl) { - type = XmlEntityDecl.CONTEXT_ATTRIBUTE_SPEC; + type = XmlEntityDecl.EntityContextType.ATTRIBUTE_SPEC; } else if (temp instanceof XmlElementDecl) { - type = XmlEntityDecl.CONTEXT_ELEMENT_CONTENT_SPEC; + type = XmlEntityDecl.EntityContextType.ELEMENT_CONTENT_SPEC; } else if (temp instanceof XmlAttlistDecl) { - type = XmlEntityDecl.CONTEXT_ATTLIST_SPEC; + type = XmlEntityDecl.EntityContextType.ATTLIST_SPEC; } else if (temp instanceof XmlEntityDecl) { - type = XmlEntityDecl.CONTEXT_ENTITY_DECL_CONTENT; + type = XmlEntityDecl.EntityContextType.ENTITY_DECL_CONTENT; } else if (temp instanceof XmlEnumeratedType) { - type = XmlEntityDecl.CONTEXT_ENUMERATED_TYPE; + type = XmlEntityDecl.EntityContextType.ENUMERATED_TYPE; } else if (temp instanceof XmlAttributeValue) { - type = XmlEntityDecl.CONTEXT_ATTR_VALUE; + type = XmlEntityDecl.EntityContextType.ATTR_VALUE; } else { temp = temp.getContext(); @@ -779,7 +779,7 @@ public class XmlUtil { private static PsiElement parseEntityDecl(final XmlEntityDecl entityDecl, final PsiFile targetFile, - final int type, + final XmlEntityDecl.EntityContextType type, boolean cacheValue, final XmlEntityRef entityRef) { if (!cacheValue) return entityDecl.parse(targetFile, type, entityRef); diff --git a/xml/openapi/src/com/intellij/psi/xml/XmlEntityDecl.java b/xml/openapi/src/com/intellij/psi/xml/XmlEntityDecl.java index 4beb52760929..268b41c8b6b3 100644 --- a/xml/openapi/src/com/intellij/psi/xml/XmlEntityDecl.java +++ b/xml/openapi/src/com/intellij/psi/xml/XmlEntityDecl.java @@ -23,17 +23,14 @@ import com.intellij.psi.PsiNamedElement; * @author mike */ public interface XmlEntityDecl extends XmlElement, PsiNamedElement { - int CONTEXT_ELEMENT_CONTENT_SPEC = 1; - int CONTEXT_ATTRIBUTE_SPEC = 2; - int CONTEXT_ATTLIST_SPEC = 3; - int CONTEXT_ENTITY_DECL_CONTENT = 4; - int CONTEXT_GENERIC_XML = 5; - int CONTEXT_ENUMERATED_TYPE = 6; - int CONTEXT_ATTR_VALUE = 7; + enum EntityContextType { + ELEMENT_CONTENT_SPEC, ATTRIBUTE_SPEC, ATTLIST_SPEC, ENTITY_DECL_CONTENT, GENERIC_XML, + ENUMERATED_TYPE, ATTR_VALUE + } String getName(); PsiElement getNameElement(); XmlAttributeValue getValueElement(); - PsiElement parse(PsiFile baseFile, int context, XmlEntityRef originalElement); + PsiElement parse(PsiFile baseFile, EntityContextType context, XmlEntityRef originalElement); boolean isInternalReference(); }