/*
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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 org.apache.flex.compiler.internal.tree.mxml;
import java.io.File;
import java.util.ArrayList;
import java.util.Collection;
import java.util.EnumSet;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import org.apache.commons.io.FilenameUtils;
import org.apache.flex.compiler.common.ISourceLocation;
import org.apache.flex.compiler.common.SourceLocation;
import org.apache.flex.compiler.internal.mxml.MXMLDialect;
import org.apache.flex.compiler.internal.parsing.ISourceFragment;
import org.apache.flex.compiler.internal.parsing.SourceFragment;
import org.apache.flex.compiler.internal.parsing.as.ASParser;
import org.apache.flex.compiler.internal.parsing.as.ASToken;
import org.apache.flex.compiler.internal.parsing.as.IncludeHandler;
import org.apache.flex.compiler.internal.parsing.as.OffsetLookup;
import org.apache.flex.compiler.internal.parsing.as.StreamingASTokenizer;
import org.apache.flex.compiler.internal.parsing.mxml.MXMLScopeBuilder;
import org.apache.flex.compiler.internal.parsing.mxml.MXMLTokenizer;
import org.apache.flex.compiler.internal.projects.FlexProject;
import org.apache.flex.compiler.internal.scopes.ASScope;
import org.apache.flex.compiler.internal.scopes.MXMLFileScope;
import org.apache.flex.compiler.internal.semantics.PostProcessStep;
import org.apache.flex.compiler.internal.tree.as.NodeBase;
import org.apache.flex.compiler.internal.tree.as.ScopedBlockNode;
import org.apache.flex.compiler.internal.workspaces.Workspace;
import org.apache.flex.compiler.mxml.IMXMLData;
import org.apache.flex.compiler.mxml.IMXMLTagAttributeData;
import org.apache.flex.compiler.mxml.IMXMLNamespaceAttributeData;
import org.apache.flex.compiler.mxml.IMXMLTagData;
import org.apache.flex.compiler.mxml.IMXMLTextData;
import org.apache.flex.compiler.mxml.IMXMLTextData.TextType;
import org.apache.flex.compiler.mxml.IMXMLUnitData;
import org.apache.flex.compiler.parsing.IASToken;
import org.apache.flex.compiler.parsing.IMXMLToken;
import org.apache.flex.compiler.parsing.MXMLTokenTypes;
import org.apache.flex.compiler.problems.ICompilerProblem;
import org.apache.flex.compiler.problems.MXMLAttributeVersionProblem;
import org.apache.flex.compiler.problems.MXMLEmptyAttributeProblem;
import org.apache.flex.compiler.problems.MXMLOtherLanguageNamespaceProblem;
import org.apache.flex.compiler.problems.MXMLPrivateAttributeProblem;
import org.apache.flex.compiler.problems.MXMLUnexpectedAttributeProblem;
import org.apache.flex.compiler.problems.MXMLUnexpectedTagProblem;
import org.apache.flex.compiler.problems.MXMLUnexpectedTextProblem;
import org.apache.flex.compiler.problems.MXMLUnknownNamespaceProblem;
import org.apache.flex.compiler.tree.as.IASNode;
import org.apache.flex.compiler.tree.mxml.IMXMLClassDefinitionNode;
import org.apache.flex.compiler.tree.mxml.IMXMLDocumentNode;
import org.apache.flex.compiler.tree.mxml.IMXMLFileNode;
import org.apache.flex.compiler.tree.mxml.IMXMLNode;
import org.apache.flex.compiler.tree.mxml.IMXMLSpecifierNode;
import org.apache.flex.utils.FilenameNormalization;
/**
* {@code MXMLNodeBase} is the abstract base class for all MXML nodes in an AST.
* <p>
* Although the MXML node interfaces (i.e., {@code IMXMLNode} and its
* subinterfaces) support only read-only operations on the MXML AST, the MXML
* node class contain the logic for building the tree node-by-node from the MXML
* DOM.
* <p>
* For example, the processing of the <Script> tag is handled by the
* {@code MXMLScriptNode} class, which encapsulates the logic that a
* <Script> tag can only have namespace attributes and a
* <code>source</code> attribute, and that it cannot have any child tags.
* <p>
* This base class handles some analysis that must be done on every kind of MXML
* tag:
* <ul>
* <li>Walking the tag's attributes and its child units.</li>
* <li>Noticing whether a namespace attribute defines an illegal language
* namespace.</li>
* <li>Noticing whether any tag or attribute uses an illegal language namespace.
* </li>
* <li>Noticing any private attributes. We will report a problem for these,
* since developers who don't use them may prefer to catch them as warnings.</li>
* </ul>
* <p>
* Problems at the level of incorrect XML are noticed before tree construction,
* during MXML parsing. Such problems include:
* <ul>
* <li>Using an undefined prefix on a tag or attribute.
* <li>Using an unrecognized entity.
* </ul>
* <p>
* The default behavior implemented in this base class reports a problem for
* every attribute (except for namespace and private ones) and every
* non-whitespace text unit. In other words, by default it implements
* "you can't put that here". It is the responsibility then of subclasses to
* allow particular attributes and content units rather than disallow them.
*/
public abstract class MXMLNodeBase extends NodeBase implements IMXMLNode
{
// TODO Make this class package internal rather than public.
/**
* This tokenizer is used to implement
* {@link #isValidActionScriptIdentifier()}. {@link StreamingASTokenizer} is
* <b>not</b> thread-safe, so we need to make a thread-local copy for each
* thread.
*/
private static final ThreadLocal<StreamingASTokenizer> asTokenizer =
new ThreadLocal<StreamingASTokenizer>()
{
protected StreamingASTokenizer initialValue()
{
return new StreamingASTokenizer();
};
};
/**
* This tokenizer is used to implement {@link #isValidXMLTagName()}.
* {@link MXMLTokenizer} is <b>not</b> thread-safe, so we need to make a
* thread-local copy for each thread.
*/
private static final ThreadLocal<MXMLTokenizer> mxmlTokenizer =
new ThreadLocal<MXMLTokenizer>()
{
protected MXMLTokenizer initialValue()
{
return new MXMLTokenizer();
};
};
/**
* Resolves the path specified in an MXML tag's <code>source</code>
* attribute.
*
* @param builder The {@code MXMLTreeBuilder} object which is building this
* MXML tree.
* @param attribute The <code>source</code> attribute.
* @return A resolved and normalized path to the external file.
*/
public static String resolveSourceAttributePath(MXMLTreeBuilder builder,
IMXMLTagAttributeData attribute,
MXMLNodeInfo info)
{
if (info != null)
info.hasSourceAttribute = true;
String sourcePath = attribute.getMXMLDialect().trim(attribute.getRawValue());
if (sourcePath.isEmpty() && builder != null)
{
ICompilerProblem problem = new MXMLEmptyAttributeProblem(attribute);
builder.addProblem(problem);
return null;
}
String resolvedPath;
if ((new File(sourcePath)).isAbsolute())
{
// If the source attribute specifies an absolute path,
// it doesn't need to be resolved.
resolvedPath = sourcePath;
}
else
{
// Otherwise, resolve it relative to the MXML file.
String mxmlPath = attribute.getParent().getParent().getPath();
resolvedPath = FilenameUtils.getPrefix(mxmlPath) + FilenameUtils.getPath(mxmlPath);
resolvedPath = FilenameUtils.concat(resolvedPath, sourcePath);
}
String normalizedPath = FilenameNormalization.normalize(resolvedPath);
// Make the compilation unit dependent on the external file.
if (builder != null)
builder.getFileScope().addSourceDependency(normalizedPath);
return normalizedPath;
}
/**
* Determines whether the specified String is a single valid ActionScript
* identifier, by tokenizing it.
*
* @param identifier A String to be tokenized.
* @return <code>true</code> if the String tokenizes to a single identifier
* token.
*/
protected static boolean isValidASIdentifier(String identifier)
{
IASToken[] tokens = asTokenizer.get().getTokens(identifier);
return tokens != null && tokens.length == 1 && tokens[0].getType() == ASToken.TOKEN_IDENTIFIER;
}
/**
* Determines whether the specified String is a valid XML tag name
* by appending it to "<" and tokenizing it.
*
* @param tagName A String proposed as a tag name.
* @return <code>true</code> if the String is a valid tag name.
*/
protected static boolean isValidXMLTagName(String tagName)
{
String s = "<" + tagName;
IMXMLToken[] tokens = mxmlTokenizer.get().getTokens(s + "/>");
return tokens != null && tokens.length == 2 &&
tokens[0].getType() == MXMLTokenTypes.TOKEN_OPEN_TAG_START &&
tokens[0].getText().equals(s) &&
tokens[1].getType() == MXMLTokenTypes.TOKEN_EMPTY_TAG_END;
}
/**
* Constructor.
*
* @param parent The parent node of this node, or <code>null</code> if there
* is no parent.
*/
MXMLNodeBase(NodeBase parent)
{
this.parent = parent;
}
private boolean validForCodeGen = true;
@Override
public boolean isValidForCodeGen()
{
return validForCodeGen;
}
void markInvalidForCodeGen()
{
validForCodeGen = false;
}
/**
* Initializes this MXML node from an MXML tag by processing the attribute
* and content units of the tag. This processing sets the properties of this
* node and creates the children of this node. The child nodes will
* themselves be initialized from attributes or child tags; in this way, the
* MXML AST will get constructed from the MXML DOM.
*
* @param builder The {@code MXMLTreeBuilder} object which is building this
* MXML tree.
* @param tag The MXML tag from which this MXML node is being created.
*/
protected void initializeFromTag(MXMLTreeBuilder builder, IMXMLTagData tag)
{
setLocation(tag);
MXMLNodeInfo info = createNodeInfo(builder);
// Process each attribute.
for (IMXMLTagAttributeData attribute : tag.getAttributeDatas())
{
processAttribute(builder, tag, attribute, info);
}
// Process each content unit.
for (IMXMLUnitData unit = tag.getFirstChildUnit(); unit != null; unit = unit.getNextSiblingUnit())
{
processContentUnit(builder, tag, unit, info);
}
// Do any final processing.
initializationComplete(builder, tag, info);
}
protected MXMLNodeInfo createNodeInfo(MXMLTreeBuilder builder)
{
return null;
}
/**
* This method gives subclasses a chance to do final processing after
* considering each attribute and content unit.
* <p>
* The base class version calls <code>adjustOffset</code> to translate the
* node start and end offset from local to absolute offsets.
*/
protected void initializationComplete(MXMLTreeBuilder builder,
IMXMLTagData tag,
MXMLNodeInfo info)
{
adjustOffsets(builder);
}
/**
* Translates the node's start and end offset from local to absolute
* offsets.
*/
public void adjustOffsets(MXMLTreeBuilder builder)
{
final MXMLFileScope fileScope = builder.getFileScope();
assert fileScope != null : "Expected MXMLFileScope.";
final OffsetLookup offsetLookup = fileScope.getOffsetLookup();
assert offsetLookup != null : "Expected OffsetLookup on file scope.";
final String path = getFileSpecification().getPath(); // TODO Get from builder?
final int absoluteStart = offsetLookup.getAbsoluteOffset(path, getAbsoluteStart())[0];
final int absoluteEnd = offsetLookup.getAbsoluteOffset(path, getAbsoluteEnd())[0];
setStart(absoluteStart);
setEnd(absoluteEnd);
}
@Override
public IASNode getChild(int i)
{
// By default, MXML nodes have no children.
// This base class does not provide child storage.
return null;
}
@Override
public int getChildCount()
{
// By default, MXML nodes have no children.
// This base class does not provide child storage.
return 0;
}
@Override
public IMXMLClassDefinitionNode getClassDefinitionNode()
{
return (IMXMLClassDefinitionNode)getAncestorOfType(IMXMLClassDefinitionNode.class);
}
@Override
public IMXMLDocumentNode getDocumentNode()
{
return (IMXMLDocumentNode)getAncestorOfType(IMXMLDocumentNode.class);
}
@Override
public IMXMLFileNode getFileNode()
{
return (IMXMLFileNode)getAncestorOfType(IMXMLFileNode.class);
}
/**
* Processes a single attribute during the initialization of this node.
* <p>
* The default behavior implemented in this base class is to simply call
* <code>processNamespaceAttribute()</code> on namespace attributes,
* <code>processPrivateAttribute()</code> on private attributes, and
* <code>processTagSpecificAttribute()</code> on other attributes.
* <p>
* Subclass should not need to override this method, so it is private.
*
* @param builder The {@code MXMLTreeBuilder} object which is building this
* MXML tree.
* @param tag An {@code IMXMLTagData} object representing the tag.
* @param attribute An {@code MXMLTagAttributeData} object representing the
* attribute.
*/
private void processAttribute(MXMLTreeBuilder builder, IMXMLTagData tag,
IMXMLTagAttributeData attribute,
MXMLNodeInfo info)
{
if (attribute instanceof IMXMLNamespaceAttributeData)
processNamespaceAttribute(builder, tag, (IMXMLNamespaceAttributeData)attribute);
else if (isPrivateAttribute(attribute))
processPrivateAttribute(builder, tag, attribute);
else
processTagSpecificAttribute(builder, tag, attribute, info);
}
/**
* Processes a single namespace attribute such as xmlns:foo="..." or
* xmlns="...".
* <p>
* The default behavior implemented in this base class is to check whether
* the namespace URI is a language URI that is different from that of the
* overall MXML document. (E.g., the document is in MXML 2009 but then you
* use MXML 2006 somewhere inside.)
* <p>
* Subclasses do not need to override this method, so it is private.
*
* @param attribute An {@code MXMLNamespaceAttributeData} object
* representing the attribute.
*/
private void processNamespaceAttribute(MXMLTreeBuilder builder, IMXMLTagData tag,
IMXMLNamespaceAttributeData attribute)
{
String attributeURI = attribute.getNamespace();
IMXMLData mxmlData = attribute.getParent().getParent();
String languageURI = mxmlData.getMXMLDialect().getLanguageNamespace();
if (MXMLDialect.isLanguageNamespace(attributeURI) &&
!attributeURI.equals(languageURI))
{
ICompilerProblem problem = new MXMLOtherLanguageNamespaceProblem(attribute);
builder.addProblem(problem);
}
}
/**
* Determines whether the specified attribute is a private attribute.
* <p>
* MXML 2006 does not have the concept of private attributes. In MXML 2009,
* a private attribute is one whose URI is neither the document's language
* URI nor the URI of the attribute's tag.
* <p>
*
* @param attribute An {@code MXMLNamespaceAttributeData} object
* representing the attribute.
* @return <code>true</code> if the attribute is a private attribute and
* <code>false</code> otherwise.
*/
private static boolean isPrivateAttribute(IMXMLTagAttributeData attribute)
{
String attributeURI = attribute.getURI();
if (attributeURI == null)
return false;
String tagURI = attribute.getParent().getURI();
IMXMLData mxmlData = attribute.getParent().getParent();
MXMLDialect mxmlDialect = mxmlData.getMXMLDialect();
String languageURI = mxmlDialect.getLanguageNamespace();
boolean isPrivate = false;
if (mxmlDialect.isEqualToOrAfter(MXMLDialect.MXML_2009))
{
isPrivate = !attributeURI.equals(languageURI) &&
!attributeURI.equals(tagURI);
}
return isPrivate;
}
/**
* Processes a single private attribute such as p="...".
* <p>
* The default behavior implemented in this base class is to report each
* private attribute as a "problem". They're allowed by some versions of
* MXML, but even in those versions developers may not want to use them and
* would prefer to catch typographical mistakes that produce private
* attributes.
* <p>
* Subclasses do not need to override this method so it is private.
*
* @param attribute An {@code MXMLAttributeData} object representing the
* attribute.
*/
private void processPrivateAttribute(MXMLTreeBuilder builder, IMXMLTagData tag,
IMXMLTagAttributeData attribute)
{
ICompilerProblem problem = new MXMLPrivateAttributeProblem(attribute);
builder.addProblem(problem);
}
/**
* Processes a single tag-specific attribute (i.e., one that isn't allowed
* on every tag, unlike a namespace attribute or a private attribute).
* <p>
* The attribute might be specifying a property, event, or style; or it
* might be a special compile-time attribute such as 'id', 'includeIn',
* 'excludeFrom', 'source', etc. A property/event/style attribute will cause
* a child node to be added to this node; a compile-time attribute typically
* will simply set a property of the node.
* <p>
* The default behavior implemented in this base class is to report each
* tag-specific attribute as a problem.
* <p>
* Subclasses must override this method in order to allow tag-specific
* attributes.
*
* @param attribute An {@code MXMLTagAttributeData} object representing the
* attribute.
*/
protected void processTagSpecificAttribute(MXMLTreeBuilder builder, IMXMLTagData tag,
IMXMLTagAttributeData attribute,
MXMLNodeInfo info)
{
ICompilerProblem problem = new MXMLUnexpectedAttributeProblem(attribute);
builder.addProblem(problem);
}
/**
* Processes a single content unit. A content unit can be a child tag, text
* (including CDATA or an entity), a comment, or a processing instruction.
* <p>
* The default behavior implemented in this base class is simply to call
* <code>processChildTag()</code> on each child tag,
* <code>processChildTextUnit()</code> on each child text unit (including
* whitespace, entities, comments, and processing instructions), and
* <code>processChildDatabindingUnit()</code> on each child databinding
* unit.
* <p>
* Subclasses do not need to override this method so it is private.
*
* @param unit An {@code MXMLUnitData} object representing the content unit.
*/
private void processContentUnit(MXMLTreeBuilder builder, IMXMLTagData tag,
IMXMLUnitData unit,
MXMLNodeInfo info)
{
if (unit instanceof IMXMLTagData)
processChildTag(builder, tag, (IMXMLTagData)unit, info);
else if (unit instanceof IMXMLTextData)
processChildTextUnit(builder, tag, (IMXMLTextData)unit, info);
}
/**
* Processes a single child tag.
*
* @param tag An {@code MXMLTagData} object representing the child tag.
* <p>
* The default behavior implemented in this base class is to report each
* child tag as a problem.
* <p>
* Subclasses must override this method in order to allow the child tags
* that they recognize.
*/
protected void processChildTag(MXMLTreeBuilder builder, IMXMLTagData tag,
IMXMLTagData childTag,
MXMLNodeInfo info)
{
if (childTag.getURI() == null)
builder.addProblem(new MXMLUnknownNamespaceProblem(childTag, childTag.getPrefix()));
else
builder.addProblem(new MXMLUnexpectedTagProblem(childTag));
}
/**
* Processes a single child text unit.
*
* @param text An {@code MXMLTextData} object representing the child text
* unit.
* <p>
* The default behavior implemented in this base class is to ignore comments
* and to call <code>processChildWhitespaceUnit()</code> if the text (which
* might be an entity or a CDATA block) is all whitespace and
* <code>processChildNonWhitespaceUnit()</code> otherwise.
* <p>
* Subclasses do not need to override this method so it is private.
*/
private void processChildTextUnit(MXMLTreeBuilder builder, IMXMLTagData tag,
IMXMLTextData text,
MXMLNodeInfo info)
{
switch (text.getTextType())
{
case TEXT:
case WHITESPACE:
case CDATA:
{
if (tag.getMXMLDialect().isWhitespace(text.getCompilableText()))
processChildWhitespaceUnit(builder, tag, text, info);
else
processChildNonWhitespaceUnit(builder, tag, text, info);
break;
}
case COMMENT:
case ASDOC:
{
// ignore these
break;
}
}
}
/**
* Processes a single child text unit which is all whitespace.
* <p>
* The default behavior implemented in this base class is to ignore
* whitespace.
* <p>
* Subclasses must override this method in order to disallow whitespace text
* units.
*
* @param text An {@code MXMLTextData} object representing the child text
* unit.
*/
protected void processChildWhitespaceUnit(MXMLTreeBuilder builder, IMXMLTagData tag,
IMXMLTextData text,
MXMLNodeInfo info)
{
}
/**
* Processes a single child text unit which is not all whitespace.
* <p>
* The default behavior implemented in this base class is to report each
* unit of non-whitespace as a problem.
* <p>
* Subclasses must override this method in order to allow the non-whitespace
* text unit.
*
* @param text An {@code MXMLTextData} object representing the child text
* unit.
*/
protected void processChildNonWhitespaceUnit(MXMLTreeBuilder builder, IMXMLTagData tag,
IMXMLTextData text,
MXMLNodeInfo info)
{
ICompilerProblem problem = new MXMLUnexpectedTextProblem(text);
builder.addProblem(problem);
}
/**
* Processes all the children of the given {@link IMXMLTagData} unit that are
* {@link IMXMLTextData} nodes. Each node will be processes separately, in
* the order in which the appear in the document.
* <p>
* This method is only used by MXML AST building. To parse an ActionScript
* block for scope building, see {@link MXMLScopeBuilder#processScriptTag}.
*
* @param tag the {@link IMXMLTagData} to process
* @return a {@link List} of {@link ScopedBlockNode}s for each
* {@link IMXMLTextData} we encountered.
*/
public static List<ScopedBlockNode> processUnitAsAS(
MXMLTreeBuilder builder,
IMXMLTagData tag,
String sourcePath,
ASScope containingScope,
PostProcessStep buildOrReconnect,
IMXMLFileNode ancestorFileNode)
{
assert buildOrReconnect == PostProcessStep.POPULATE_SCOPE || buildOrReconnect == PostProcessStep.RECONNECT_DEFINITIONS;
List<ScopedBlockNode> nodes = new ArrayList<ScopedBlockNode>(2);
for (IMXMLUnitData unit = tag.getFirstChildUnit(); unit != null; unit = unit.getNextSiblingUnit())
{
if (unit instanceof IMXMLTextData)
{
final IMXMLTextData mxmlTextData = (IMXMLTextData)unit;
if (mxmlTextData.getTextType() != TextType.WHITESPACE)
{
final Workspace workspace = builder.getWorkspace();
final FlexProject project = builder.getProject();
final Collection<ICompilerProblem> problems = builder.getProblems();
final IncludeHandler includeHandler = new IncludeHandler(builder.getFileSpecificationGetter());
includeHandler.setProjectAndCompilationUnit(project, builder.getCompilationUnit());
final ScopedBlockNode node = ASParser.parseFragment2(
mxmlTextData.getCompilableText(),
sourcePath,
mxmlTextData.getCompilableTextStart(),
mxmlTextData.getCompilableTextLine() - 1,
mxmlTextData.getCompilableTextColumn() - 1,
problems,
workspace,
builder.getFileNode(),
containingScope,
project.getProjectConfigVariables(),
EnumSet.of(PostProcessStep.CALCULATE_OFFSETS, buildOrReconnect),
true, //follow includes
includeHandler
);
((MXMLFileNode)ancestorFileNode).updateIncludeTreeLastModified(includeHandler.getLastModified());
nodes.add(node);
}
}
}
return nodes;
}
/**
* Sets the start/end/line/column location information for this node.
*
* @param start The starting offset of this node.
* @param end The ending offset of this node.
* @param line The number of the line on which this node starts.
* @param column This number of the column at which this node starts.
*/
public void setLocation(String sourcePath, int start, int end, int line, int column)
{
setSourcePath(sourcePath);
setStart(start);
setEnd(end);
setLine(line);
setColumn(column);
}
/**
* Sets the start/end/line/column location information for this node.
*
* @param location A {@link SourceLocation} object.
*/
public void setLocation(ISourceLocation location)
{
String sourcePath = location.getSourcePath();
int start = location.getStart();
int end = location.getEnd();
int line = location.getLine();
int column = location.getColumn();
setLocation(sourcePath, start, end, line, column);
}
/**
* Sets the start/end/line/column location information for this node.
*
* @param unit The MXML unit from which this node was created.
*/
protected void setLocation(IMXMLUnitData unit)
{
String sourcePath = unit.getSourcePath();
int start = unit.getAbsoluteStart();
int end;
if (unit instanceof IMXMLTagData)
{
IMXMLTagData startTag = (IMXMLTagData)unit;
IMXMLTagData endTag = startTag.findMatchingEndTag();
end = endTag != null ? endTag.getAbsoluteEnd() : startTag.getAbsoluteEnd();
}
else
{
end = unit.getAbsoluteEnd();
}
int line = unit.getLine();
int column = unit.getColumn();
setLocation(sourcePath, start, end, line, column);
}
/**
* Sets the start/end/line/column location information for this node.
*
* @param attribute The MXML attribute from which this node was created.
*/
protected void setLocation(IMXMLTagAttributeData attribute)
{
String sourcePath = attribute.getSourcePath();
int start = attribute.getAbsoluteStart();
int end = attribute.getAbsoluteEnd();
int line = attribute.getLine();
int column = attribute.getColumn();
setLocation(sourcePath, start, end, line, column);
}
/**
* Sets the start/end/line/column location information for this node so that
* it spans a list of MXML content units.
*
* @param units A list of MXML content units.
*/
protected void setLocation(MXMLTreeBuilder builder, List<IMXMLUnitData> units)
{
int n = units.size();
IMXMLUnitData firstUnit = units.get(0);
IMXMLUnitData lastUnit = units.get(n - 1);
// we only store the open tags in the units
// and the end offset should be the end of the last close tag
// check this here and fetch the end tag if the last tag is an open and non-empty tag
if (lastUnit instanceof IMXMLTagData && lastUnit.isOpenAndNotEmptyTag())
{
IMXMLUnitData endTag = (IMXMLUnitData)((IMXMLTagData)lastUnit).findMatchingEndTag();
if (endTag != null)
lastUnit = endTag;
}
String sourcePath = firstUnit.getSourcePath();
int start = firstUnit.getStart();
int end = lastUnit.getEnd();
int line = firstUnit.getLine();
int column = firstUnit.getColumn();
setLocation(sourcePath, start, end, line, column);
adjustOffsets(builder);
}
/**
* Accumulates source fragments that are produced by a text unit for later
* processing.
*/
protected void accumulateTextFragments(MXMLTreeBuilder builder,
IMXMLTextData text,
MXMLNodeInfo info)
{
Collection<ICompilerProblem> problems = builder.getProblems();
ISourceFragment[] fragments = text.getFragments(problems);
info.addSourceFragments(text.getSourcePath(), fragments);
}
/**
* Processes an <code>includeIn="..."</code> or
* <code>excludeFrom"..."</code> attribute on an instance tag or a
* <code><Reparent></code> tag.
*/
protected String[] processIncludeInOrExcludeFromAttribute(
MXMLTreeBuilder builder, IMXMLTagAttributeData attribute)
{
MXMLDialect mxmlDialect = builder.getMXMLDialect();
if (mxmlDialect == MXMLDialect.MXML_2006)
{
ICompilerProblem problem = new MXMLAttributeVersionProblem(attribute, attribute.getName(), "2009");
builder.addProblem(problem);
return null;
}
MXMLClassDefinitionNode classNode =
(MXMLClassDefinitionNode)getClassDefinitionNode();
classNode.addStateDependentNode(builder, this);
return mxmlDialect.splitAndTrim(attribute.getRawValue());
}
/**
* MXML node classes can choose to create this object in
* <code>createNodeInfo()</code>. It then gets passed to the various methods
* involved in initializing one node, so that state can be conveyed between
* these methods, rather than having this state stored in fields of the node
* which would take up space after the node is completely initialized.
* <p>
* It is currently used accumulate child nodes and source fragments.
*/
protected static class MXMLNodeInfo
{
public MXMLNodeInfo(MXMLTreeBuilder builder)
{
this.builder = builder;
}
private MXMLTreeBuilder builder;
private List<IMXMLNode> childNodeList = new ArrayList<IMXMLNode>();
private String sourcePath;
private List<ISourceFragment> sourceFragmentList = new ArrayList<ISourceFragment>();
/**
* A flag that keeps track of whether the tag had a <code>source</code>
* attribute.
*/
public boolean hasSourceAttribute = false;
/**
* A flag that keeps track of whether the tag had content that would
* conflict with the <code>source</code> attribute. For a Script, Style,
* or String tag, this is non-whitespace text content. For an XML or
* Model tag, this is a child tag.
*/
public boolean hasDualContent = false;
/**
* Set of specifiers
*/
protected Set<String> specifierSet = new HashSet<String>(0);
public void addChildNode(IMXMLNode childNode)
{
childNodeList.add(childNode);
if (childNode instanceof IMXMLSpecifierNode)
{
IMXMLSpecifierNode specifierNode = (IMXMLSpecifierNode)childNode;
String suffix = specifierNode.getSuffix() != null ? specifierNode.getSuffix() : "";
specifierSet.add(specifierNode.getName() + '.' + suffix);
}
}
public List<IMXMLNode> getChildNodeList()
{
return childNodeList;
}
public void addSourceFragments(String sourcePath, ISourceFragment[] sourceFragments)
{
this.sourcePath = sourcePath;
for (ISourceFragment sourceFragment : sourceFragments)
{
sourceFragmentList.add(sourceFragment);
}
}
public void clearFragments()
{
sourceFragmentList.clear();
}
public String getSourcePath()
{
return sourcePath;
}
public ISourceFragment[] getSourceFragments()
{
final MXMLFileScope fileScope = builder.getFileScope();
final OffsetLookup offsetLookup = fileScope.getOffsetLookup();
assert offsetLookup != null : "Expected OffsetLookup on FileScope.";
for (ISourceFragment fragment : sourceFragmentList)
{
int physicalStart = fragment.getPhysicalStart();
final int[] absoluteOffsets = offsetLookup.getAbsoluteOffset(sourcePath, physicalStart);
((SourceFragment)fragment).setPhysicalStart(absoluteOffsets[0]);
}
return sourceFragmentList.toArray(new ISourceFragment[0]);
}
public SourceLocation getSourceLocation()
{
int n = sourceFragmentList.size();
if (n == 0)
return null;
ISourceFragment firstFragment = sourceFragmentList.get(0);
ISourceFragment lastFragment = sourceFragmentList.get(n - 1);
int start = firstFragment.getPhysicalStart();
int end = lastFragment.getPhysicalStart() + lastFragment.getPhysicalText().length();
int line = firstFragment.getPhysicalLine();
int column = firstFragment.getPhysicalColumn();
return new SourceLocation(sourcePath, start, end, line, column);
}
/**
* Check whether a specifier (attribute or child tag) with the same name and state already exist
* @param name name of the specifier (attribute or child tag)
* @param stateName name of the state
* @return true, if the child already exist, false otherwise
*/
public boolean hasSpecifierWithName(String name, String stateName)
{
return specifierSet.contains(name + '.' + stateName);
}
}
}