sigmasternchen/xtext-core
1
0
Fork 0
mirror of https://github.com/sigmasternchen/xtext-core synced 2025-03-15 08:18:55 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Remove need for AbstractInternalAntlrParser.lastConsumedNode

Browse source
This commit is contained in:
Sebastian Zarnekow 2020-05-03 12:03:42 +02:00
parent 5bb5adefe4
commit 2768fbf662
4 changed files with 156 additions and 107 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

25
org.eclipse.xtext.xtext.generator/src/org/eclipse/xtext/xtext/generator/parser/antlr/AntlrGrammarGenerator.xtend
View file

@ -132,16 +132,27 @@ class AntlrGrammarGenerator extends AbstractAntlrGrammarWithActionsGenerator {
override protected compileInit(AbstractRule it, AntlrOptions options) '''
«IF it instanceof ParserRule»«getParameterList(!isPassCurrentIntoFragment, currentType)»«ENDIF» returns «compileReturns(options)»
@init {
enterRule();
«compileInitHiddenTokens(options)»
«compileInitUnorderedGroups(options)»
}
@after {
«IF requiresInit(options)»
@init {
«IF options.generateEnterAndLeaveRule»
enterRule();
«ENDIF»
«compileInitHiddenTokens(options)»
«compileInitUnorderedGroups(options)»
}
«ENDIF»
«IF options.generateEnterAndLeaveRule»@after {
leaveRule();
}'''
}
«ENDIF»'''
protected def dispatch requiresInit(AbstractRule it, AntlrOptions options) {
options.isGenerateEnterAndLeaveRule
}
protected def dispatch requiresInit(ParserRule it, AntlrOptions options) {
options.isGenerateEnterAndLeaveRule || definesHiddenTokens || definesUnorderedGroups(options)
}
protected def compileReturns(AbstractRule it, AntlrOptions options) {
switch it {

14
org.eclipse.xtext.xtext.generator/src/org/eclipse/xtext/xtext/generator/parser/antlr/AntlrOptions.java
View file

@ -8,6 +8,7 @@
*/
package org.eclipse.xtext.xtext.generator.parser.antlr;
import org.eclipse.xtext.parser.antlr.AbstractInternalAntlrParser;
import org.eclipse.xtext.xtext.generator.parser.antlr.splitting.AntlrParserSplitter;
import org.eclipse.xtext.xtext.generator.parser.antlr.splitting.PartialClassExtractor;
import org.eclipse.xtext.xtext.generator.parser.antlr.splitting.internal.LexerSpecialStateTransitionSplitter;
@ -36,6 +37,8 @@ public class AntlrOptions {
private boolean optimizeCodeQuality = true;
private boolean stripAllComments = false;
private boolean generateEnterAndLeaveRule = false;
private String keptBitSetsPattern;
@ -132,6 +135,17 @@ public class AntlrOptions {
public void setOptimizeCodeQuality(boolean optimizeCodeQuality) {
this.optimizeCodeQuality = optimizeCodeQuality;
}
public boolean isGenerateEnterAndLeaveRule() {
return generateEnterAndLeaveRule;
}
/**
* Generate a invocation of {@link AbstractInternalAntlrParser#enterRule()} and {@link AbstractInternalAntlrParser#leaveRule()}.
*/
public void setGenerateEnterAndLeaveRule(boolean generateEnterAndLeaveRule) {
this.generateEnterAndLeaveRule = generateEnterAndLeaveRule;
}
public boolean isStripAllComments() {
return stripAllComments;

77
org.eclipse.xtext.xtext.generator/xtend-gen/org/eclipse/xtext/xtext/generator/parser/antlr/AntlrGrammarGenerator.java
View file

@ -326,30 +326,54 @@ public class AntlrGrammarGenerator extends AbstractAntlrGrammarWithActionsGenera
CharSequence _compileReturns = this.compileReturns(it, options);
_builder.append(_compileReturns);
_builder.newLineIfNotEmpty();
_builder.append("@init {");
_builder.newLine();
_builder.append("\t");
_builder.append("enterRule();");
_builder.newLine();
_builder.append("\t");
CharSequence _compileInitHiddenTokens = this.compileInitHiddenTokens(it, options);
_builder.append(_compileInitHiddenTokens, "\t");
_builder.newLineIfNotEmpty();
_builder.append("\t");
CharSequence _compileInitUnorderedGroups = this.compileInitUnorderedGroups(it, options);
_builder.append(_compileInitUnorderedGroups, "\t");
_builder.newLineIfNotEmpty();
_builder.append("}");
_builder.newLine();
_builder.append("@after {");
_builder.newLine();
_builder.append("\t");
_builder.append("leaveRule();");
_builder.newLine();
_builder.append("}");
{
boolean _requiresInit = this.requiresInit(it, options);
if (_requiresInit) {
_builder.append("@init {");
_builder.newLine();
{
boolean _isGenerateEnterAndLeaveRule = options.isGenerateEnterAndLeaveRule();
if (_isGenerateEnterAndLeaveRule) {
_builder.append("\t");
_builder.append("enterRule();");
_builder.newLine();
}
}
_builder.append("\t");
CharSequence _compileInitHiddenTokens = this.compileInitHiddenTokens(it, options);
_builder.append(_compileInitHiddenTokens, "\t");
_builder.newLineIfNotEmpty();
_builder.append("\t");
CharSequence _compileInitUnorderedGroups = this.compileInitUnorderedGroups(it, options);
_builder.append(_compileInitUnorderedGroups, "\t");
_builder.newLineIfNotEmpty();
_builder.append("}");
_builder.newLine();
}
}
{
boolean _isGenerateEnterAndLeaveRule_1 = options.isGenerateEnterAndLeaveRule();
if (_isGenerateEnterAndLeaveRule_1) {
_builder.append("@after {");
_builder.newLineIfNotEmpty();
_builder.append("\t");
_builder.append("leaveRule();");
_builder.newLine();
_builder.append("}");
_builder.newLine();
}
}
return _builder.toString();
}
protected boolean _requiresInit(final AbstractRule it, final AntlrOptions options) {
return options.isGenerateEnterAndLeaveRule();
}
protected boolean _requiresInit(final ParserRule it, final AntlrOptions options) {
return ((options.isGenerateEnterAndLeaveRule() || it.isDefinesHiddenTokens()) || this._grammarAccessExtensions.definesUnorderedGroups(it, options));
}
protected CharSequence compileReturns(final AbstractRule it, final AntlrOptions options) {
CharSequence _switchResult = null;
boolean _matched = false;
@ -1238,4 +1262,15 @@ public class AntlrGrammarGenerator extends AbstractAntlrGrammarWithActionsGenera
Arrays.<Object>asList(it, grammar, options).toString());
}
}
protected boolean requiresInit(final AbstractRule it, final AntlrOptions options) {
if (it instanceof ParserRule) {
return _requiresInit((ParserRule)it, options);
} else if (it != null) {
return _requiresInit(it, options);
} else {
throw new IllegalArgumentException("Unhandled parameter types: " +
Arrays.<Object>asList(it, options).toString());
}
}
}

147
org.eclipse.xtext/src/org/eclipse/xtext/parser/antlr/AbstractInternalAntlrParser.java
View file

@ -205,8 +205,6 @@ public abstract class AbstractInternalAntlrParser extends Parser {
private ICompositeNode currentNode;
private INode _lastConsumedNode;
private boolean hadErrors;
private IAstFactory semanticModelBuilder;
@ -357,19 +355,13 @@ public abstract class AbstractInternalAntlrParser extends Parser {
protected void setWithLastConsumed(EObject _this, String feature, Object value, String lexerRule) {
if (value != null) {
if (_lastConsumedNode != currentNode.getLastChild()) {
throw new AssertionError();
}
set(_this, feature, value, lexerRule, _lastConsumedNode);
set(_this, feature, value, lexerRule, currentNode.getLastChild());
}
}
protected void setWithLastConsumed(EObject _this, String feature, boolean value, String lexerRule) {
if (value) {
if (_lastConsumedNode != currentNode.getLastChild()) {
throw new AssertionError();
}
set(_this, feature, value, lexerRule, _lastConsumedNode);
set(_this, feature, value, lexerRule, currentNode.getLastChild());
}
}
@ -395,19 +387,13 @@ public abstract class AbstractInternalAntlrParser extends Parser {
protected void addWithLastConsumed(EObject _this, String feature, Object value, String lexerRule) {
if (value != null) {
if (_lastConsumedNode != currentNode.getLastChild()) {
throw new AssertionError();
}
add(_this, feature, value, lexerRule, _lastConsumedNode);
add(_this, feature, value, lexerRule, currentNode.getLastChild());
}
}
protected void addWithLastConsumed(EObject _this, String feature, boolean value, String lexerRule) {
if (value) {
if (_lastConsumedNode != currentNode.getLastChild()) {
throw new AssertionError();
}
add(_this, feature, value, lexerRule, _lastConsumedNode);
add(_this, feature, value, lexerRule, currentNode.getLastChild());
}
}
@ -677,78 +663,81 @@ public abstract class AbstractInternalAntlrParser extends Parser {
// externalized usage patterns from generated sources
// currentNode = currentNode.getParent();
protected void afterParserOrEnumRuleCall() {
ICompositeNode newCurrent = nodeBuilder.compressAndReturnParent(currentNode);
if(currentNode == _lastConsumedNode){
_lastConsumedNode = newCurrent;
}
currentNode = newCurrent;
}
protected void afterParserOrEnumRuleCall() {
currentNode = nodeBuilder.compressAndReturnParent(currentNode);
}
// if (current==null) {
//========
// current = factory.create(grammarAccess.getModelRule().getType().getClassifier());
// associateNodeWithAstElement(currentNode.getParent(), current);
//========
// if (current==null) {
//========
// current = factory.create(grammarAccess.getModelRule().getType().getClassifier());
// associateNodeWithAstElement(currentNode.getParent(), current);
//========
//}
protected EObject createModelElementForParent(AbstractRule rule) {
return createModelElement(rule.getType().getClassifier(), currentNode.getParent());
}
protected EObject createModelElementForParent(AbstractRule rule) {
return createModelElement(rule.getType().getClassifier(), currentNode.getParent());
}
protected EObject createModelElement(AbstractRule rule) {
return createModelElement(rule.getType().getClassifier(), currentNode);
}
protected EObject createModelElementForParent(EClassifier classifier) {
return createModelElement(classifier, currentNode.getParent());
}
protected EObject createModelElement(AbstractRule rule) {
return createModelElement(rule.getType().getClassifier(), currentNode);
}
protected EObject createModelElementForParent(EClassifier classifier) {
return createModelElement(classifier, currentNode.getParent());
}
protected EObject createModelElement(EClassifier classifier) {
return createModelElement(classifier, currentNode);
}
protected EObject createModelElement(EClassifier classifier, ICompositeNode compositeNode) {
EObject result = semanticModelBuilder.create(classifier);
associateNodeWithAstElement(compositeNode, result);
return result;
}
// Assigned action code
protected EObject forceCreateModelElementAndSet(Action action, EObject value) {
EObject result = semanticModelBuilder.create(action.getType().getClassifier());
semanticModelBuilder.set(result, action.getFeature(), value, null /* ParserRule */, currentNode);
insertCompositeNode(action);
associateNodeWithAstElement(currentNode, result);
return result;
}
protected EObject forceCreateModelElementAndAdd(Action action, EObject value) {
EObject result = semanticModelBuilder.create(action.getType().getClassifier());
semanticModelBuilder.add(result, action.getFeature(), value, null /* ParserRule */, currentNode);
insertCompositeNode(action);
associateNodeWithAstElement(currentNode, result);
return result;
}
protected EObject forceCreateModelElement(Action action, EObject value) {
EObject result = semanticModelBuilder.create(action.getType().getClassifier());
insertCompositeNode(action);
associateNodeWithAstElement(currentNode, result);
return result;
}
protected EObject createModelElement(EClassifier classifier) {
return createModelElement(classifier, currentNode);
}
protected EObject createModelElement(EClassifier classifier, ICompositeNode compositeNode) {
EObject result = semanticModelBuilder.create(classifier);
associateNodeWithAstElement(compositeNode, result);
return result;
}
// Assigned action code
protected EObject forceCreateModelElementAndSet(Action action, EObject value) {
EObject result = semanticModelBuilder.create(action.getType().getClassifier());
semanticModelBuilder.set(result, action.getFeature(), value, null /* ParserRule */, currentNode);
insertCompositeNode(action);
associateNodeWithAstElement(currentNode, result);
return result;
}
protected EObject forceCreateModelElementAndAdd(Action action, EObject value) {
EObject result = semanticModelBuilder.create(action.getType().getClassifier());
semanticModelBuilder.add(result, action.getFeature(), value, null /* ParserRule */, currentNode);
insertCompositeNode(action);
associateNodeWithAstElement(currentNode, result);
return result;
}
protected EObject forceCreateModelElement(Action action, EObject value) {
EObject result = semanticModelBuilder.create(action.getType().getClassifier());
insertCompositeNode(action);
associateNodeWithAstElement(currentNode, result);
return result;
}
protected void insertCompositeNode(Action action) {
ICompositeNode newCurrentNode = nodeBuilder.newCompositeNodeAsParentOf(action, currentNode.getLookAhead(), currentNode);
currentNode = newCurrentNode;
ICompositeNode newCurrentNode = nodeBuilder.newCompositeNodeAsParentOf(action, currentNode.getLookAhead(), currentNode);
currentNode = newCurrentNode;
}
/**
* @deprecated this is no longer called by default. If desired, enabled it via an option in the workflow and regenerate your parser.
*/
@Deprecated
protected void enterRule() {
}
/**
* @deprecated this is no longer called by default. If desired, enabled it via an option in the workflow and regenerate your parser.
*/
@Deprecated
protected void leaveRule() {
_lastConsumedNode = currentNode;
}
// currentNode = createCompositeNode()
protected void newCompositeNode(EObject grammarElement) {
XtextTokenStream input = (XtextTokenStream) this.input;
@ -767,7 +756,7 @@ public abstract class AbstractInternalAntlrParser extends Parser {
createLeafNode(hidden, null);
}
lastConsumedIndex = tokenIndex;
_lastConsumedNode = createLeafNode(token, grammarElement);
createLeafNode(token, grammarElement);
}
}