use of org.eclipse.xtext.parser.ParseResult in project xtext-core by eclipse.
the class AbstractInternalAntlrParser method parse.
public final IParseResult parse(String entryRuleName) throws RecognitionException {
long time = System.currentTimeMillis();
IParseResult result = null;
EObject current = null;
String completeContent = input.toString();
if (// who had the crazy idea to return null from toString() ...
completeContent == null)
completeContent = "";
currentNode = nodeBuilder.newRootNode(completeContent);
String antlrEntryRuleName = normalizeEntryRuleName(entryRuleName);
try {
Method method = this.getClass().getMethod(antlrEntryRuleName);
method.setAccessible(true);
Object parseResult = method.invoke(this);
if (parseResult instanceof EObject)
current = (EObject) parseResult;
appendSkippedTokens();
appendTrailingHiddenTokens();
try {
appendAllTokens();
} finally {
ICompositeNode root = nodeBuilder.compressAndReturnParent(currentNode);
result = new ParseResult(current, root, hadErrors);
}
} catch (InvocationTargetException ite) {
Throwable targetException = ite.getTargetException();
if (targetException instanceof RecognitionException) {
try {
appendAllTokens();
} finally {
ICompositeNode root = nodeBuilder.compressAndReturnParent(currentNode);
result = new ParseResult(current, root, hadErrors);
}
throw (RecognitionException) targetException;
}
if (targetException instanceof Exception) {
throw new WrappedException((Exception) targetException);
}
throw new RuntimeException(targetException);
} catch (Exception e) {
throw new WrappedException(e);
} finally {
if (logger.isDebugEnabled()) {
logger.debug("Parsing took: " + (System.currentTimeMillis() - time) + " ms");
}
}
return result;
}
use of org.eclipse.xtext.parser.ParseResult in project xtext-core by eclipse.
the class PartialParsingHelper method reparse.
@Override
@SuppressWarnings({ "unchecked", "rawtypes" })
public IParseResult reparse(IParser parser, IParseResult previousParseResult, ReplaceRegion changedRegion) {
if (parser == null)
throw new NullPointerException("parser may not be null");
if (previousParseResult == null) {
throw new NullPointerException("previousParseResult and previousParseResult.rootNode may not be null");
}
ICompositeNode oldRootNode = previousParseResult.getRootNode();
if (changedRegion.getEndOffset() > oldRootNode.getTotalLength()) {
log.error("Invalid " + changedRegion + " originalLength=" + oldRootNode.getTotalLength());
return fullyReparse(parser, previousParseResult, changedRegion);
}
if (changedRegion.getOffset() >= oldRootNode.getTotalLength() && changedRegion.getText().trim().length() == 0) {
return fullyReparse(parser, previousParseResult, changedRegion);
}
ReplaceRegion replaceRegion;
if (tokenRegionProvider != null) {
replaceRegion = tokenRegionProvider.getTokenReplaceRegion(insertChangeIntoReplaceRegion(oldRootNode, changedRegion), changedRegion);
} else {
replaceRegion = changedRegion;
}
if (isNullEdit(oldRootNode, replaceRegion)) {
return previousParseResult;
}
PartialParsingPointers parsingPointers = calculatePartialParsingPointers(previousParseResult, replaceRegion.getOffset(), replaceRegion.getLength());
List<ICompositeNode> validReplaceRootNodes = parsingPointers.getValidReplaceRootNodes();
ICompositeNode oldCompositeNode = null;
String reparseRegion = "";
for (int i = validReplaceRootNodes.size() - 1; i >= 0; --i) {
oldCompositeNode = validReplaceRootNodes.get(i);
if (!(oldCompositeNode instanceof SyntheticCompositeNode) && !isRangePartOfExceedingLookAhead((CompositeNode) oldCompositeNode, replaceRegion)) {
boolean replaceAtEnd = oldCompositeNode.getTotalEndOffset() == replaceRegion.getEndOffset();
reparseRegion = insertChangeIntoReplaceRegion(oldCompositeNode, replaceRegion);
if (!"".equals(reparseRegion)) {
if (!replaceAtEnd || !Character.isWhitespace(reparseRegion.charAt(reparseRegion.length() - 1))) {
if (log.isDebugEnabled()) {
log.debug("replace region: [" + oldCompositeNode.getTotalOffset() + " / length: " + oldCompositeNode.getTotalLength() + " of [" + oldRootNode.getTotalOffset() + " / lenght: " + oldRootNode.getTotalLength() + "]");
}
break;
}
}
}
}
if (oldCompositeNode == null || reparseRegion.equals("") || oldCompositeNode == oldRootNode) {
return fullyReparse(parser, previousParseResult, replaceRegion);
}
EObject entryRuleOrRuleCall = parsingPointers.findEntryRuleOrRuleCall(oldCompositeNode);
IParseResult newParseResult = null;
try {
if (entryRuleOrRuleCall instanceof RuleCall)
newParseResult = parser.parse((RuleCall) entryRuleOrRuleCall, new StringReader(reparseRegion), oldCompositeNode.getLookAhead());
else
newParseResult = parser.parse((ParserRule) entryRuleOrRuleCall, new StringReader(reparseRegion));
} catch (ParseException exc) {
}
if (newParseResult == null || newParseResult.hasSyntaxErrors()) {
// on error fully reparse
return fullyReparse(parser, previousParseResult, replaceRegion);
}
if (oldRootNode.equals(oldCompositeNode)) {
unloadSemanticObject(previousParseResult.getRootASTElement());
return newParseResult;
}
EObject oldSemanticParentElement = oldCompositeNode.getParent().getSemanticElement();
EObject oldSemanticElement = null;
if (oldCompositeNode.hasDirectSemanticElement()) {
oldSemanticElement = oldCompositeNode.getSemanticElement();
} else {
List<ICompositeNode> nodesEnclosingRegion = parsingPointers.getNodesEnclosingRegion();
for (int i = nodesEnclosingRegion.size() - 1; i >= 0; --i) {
ICompositeNode enclosingNode = nodesEnclosingRegion.get(i);
if (enclosingNode == oldCompositeNode) {
break;
}
if (enclosingNode.hasDirectSemanticElement())
oldSemanticElement = enclosingNode.getSemanticElement();
}
if (oldSemanticElement == null)
return fullyReparse(parser, previousParseResult, replaceRegion);
}
if (oldSemanticElement == oldSemanticParentElement) {
throw new IllegalStateException("oldParent == oldElement");
}
if (oldSemanticParentElement != null) {
EStructuralFeature feature = oldSemanticElement.eContainingFeature();
if (feature == null)
return fullyReparse(parser, previousParseResult, replaceRegion);
oldSemanticParentElement = oldSemanticElement.eContainer();
if (feature.isMany()) {
List featureValueList = (List) oldSemanticParentElement.eGet(feature);
int index = featureValueList.indexOf(oldSemanticElement);
unloadSemanticObject(oldSemanticElement);
EObject newSemanticObject = newParseResult.getRootASTElement();
if (newSemanticObject != null) {
featureValueList.set(index, newParseResult.getRootASTElement());
} else {
featureValueList.remove(index);
}
} else {
unloadSemanticObject(oldSemanticElement);
oldSemanticParentElement.eSet(feature, newParseResult.getRootASTElement());
}
((ParseResult) newParseResult).setRootASTElement(previousParseResult.getRootASTElement());
} else {
unloadSemanticObject(oldSemanticElement);
}
if (oldCompositeNode != oldRootNode) {
nodeModelBuilder.replaceAndTransferLookAhead(oldCompositeNode, newParseResult.getRootNode());
((ParseResult) newParseResult).setRootNode(oldRootNode);
StringBuilder builder = new StringBuilder(oldRootNode.getText());
replaceRegion.applyTo(builder);
nodeModelBuilder.setCompleteContent(oldRootNode, builder.toString());
}
return newParseResult;
}
use of org.eclipse.xtext.parser.ParseResult in project xtext-core by eclipse.
the class ResourceStorageLoadable method readNodeModel.
protected void readNodeModel(final StorageAwareResource resource, final InputStream inputStream) throws IOException {
final SerializableNodeModel serializableNodeModel = new SerializableNodeModel(resource);
boolean _exists = resource.getResourceSet().getURIConverter().exists(resource.getURI(), resource.getResourceSet().getLoadOptions());
boolean _not = (!_exists);
if (_not) {
URI _uRI = resource.getURI();
String _plus = ("Skipping loading node model for synthetic resource " + _uRI);
ResourceStorageLoadable.LOG.info(_plus);
return;
}
final InputStream stream = resource.getResourceSet().getURIConverter().createInputStream(resource.getURI());
String _encoding = resource.getEncoding();
final InputStreamReader in = new InputStreamReader(stream, _encoding);
final String completeContent = CharStreams.toString(in);
final DeserializationConversionContext deserializationContext = new DeserializationConversionContext(resource, completeContent);
final DataInputStream dataIn = new DataInputStream(inputStream);
serializableNodeModel.readObjectData(dataIn, deserializationContext);
EObject _head = IterableExtensions.<EObject>head(resource.getContents());
boolean _hasErrors = deserializationContext.hasErrors();
ParseResult _parseResult = new ParseResult(_head, serializableNodeModel.root, _hasErrors);
resource.setParseResult(_parseResult);
}
Aggregations