/**
* Answers {@code true} if the given terminal rule is synthetic. That is, the tokens for this rule
* will not be produced by the generated Antlr lexer but manually in a custom token source.
*/
public boolean isSyntheticTerminalRule(final TerminalRule rule) {
AbstractElement _alternatives = rule.getAlternatives();
if ((_alternatives instanceof Keyword)) {
AbstractElement _alternatives_1 = rule.getAlternatives();
String value = ((Keyword) _alternatives_1).getValue();
TerminalRule _originalElement = AntlrGrammarGenUtil.<TerminalRule>getOriginalElement(rule);
String _name = _originalElement.getName();
String _plus = ("synthetic:" + _name);
return Objects.equal(_plus, value);
}
return false;
}
public LookAheadTerminal createLookAheadTerminal(Token token) {
Grammar grammar = getGrammar();
String tokenName = getTokenNames()[token.getType()];
tokenName = getValueForTokenName(tokenName);
if (tokenName.charAt(0) == '\'') {
LookaheadKeyword result = new LookaheadKeyword();
result.setKeyword(tokenName.substring(1, tokenName.length() - 1));
result.setToken(token);
return result;
}
LookAheadTerminalRuleCall result = new LookAheadTerminalRuleCall();
result.setToken(token);
String ruleName = TokenTool.getLexerRuleName(tokenName);
if (terminalRules == null) terminalRules = GrammarUtil.allTerminalRules(grammar);
for (TerminalRule rule : terminalRules) {
if (rule.getName().equalsIgnoreCase(ruleName)) {
result.setRule(rule);
return result;
}
}
throw new IllegalArgumentException("tokenType " + token.getType() + " seems to be invalid.");
}
private ArrayList<AbstractRule> copyRuleStubs(
final RuleNames names,
final Map<RuleWithParameterValues, AbstractRule> origToCopy,
final List<AbstractRule> rulesToCopy,
final boolean discardTypeRef) {
final ArrayList<AbstractRule> result = CollectionLiterals.<AbstractRule>newArrayList();
for (final AbstractRule rule : rulesToCopy) {
{
String ruleName = names.getAntlrRuleName(rule);
boolean _matched = false;
if (rule instanceof ParserRule) {
_matched = true;
List<Parameter> params = ((ParserRule) rule).getParameters();
boolean _isEmpty = params.isEmpty();
if (_isEmpty) {
ParserRule copy = this.<ParserRule>copy(((ParserRule) rule));
copy.setName(ruleName);
boolean _isFragment = ((ParserRule) rule).isFragment();
copy.setFragment(_isFragment);
boolean _isWildcard = ((ParserRule) rule).isWildcard();
copy.setWildcard(_isWildcard);
if ((!discardTypeRef)) {
TypeRef _type = ((ParserRule) rule).getType();
TypeRef _copyTypeRef = this.copyTypeRef(_type);
copy.setType(_copyTypeRef);
}
this.attachTo(copy, rule, origToCopy);
result.add(copy);
} else {
ImmutableSet<Parameter> _copyOf = ImmutableSet.<Parameter>copyOf(params);
Set<Set<Parameter>> _powerSet = Sets.<Parameter>powerSet(_copyOf);
final Procedure2<Set<Parameter>, Integer> _function =
(Set<Parameter> parameterConfig, Integer i) -> {
RuleWithParameterValues parameterValues =
new RuleWithParameterValues(rule, parameterConfig);
ParserRule copy_1 = this.<ParserRule>copy(((ParserRule) rule));
String _antlrRuleName = names.getAntlrRuleName(rule, (i).intValue());
copy_1.setName(_antlrRuleName);
boolean _isFragment_1 = ((ParserRule) rule).isFragment();
copy_1.setFragment(_isFragment_1);
boolean _isWildcard_1 = ((ParserRule) rule).isWildcard();
copy_1.setWildcard(_isWildcard_1);
if ((!discardTypeRef)) {
TypeRef _type_1 = ((ParserRule) rule).getType();
TypeRef _copyTypeRef_1 = this.copyTypeRef(_type_1);
copy_1.setType(_copyTypeRef_1);
}
origToCopy.put(parameterValues, copy_1);
parameterValues.attachToEmfObject(copy_1);
result.add(copy_1);
};
IterableExtensions.<Set<Parameter>>forEach(_powerSet, _function);
}
}
if (!_matched) {
if (rule instanceof TerminalRule) {
_matched = true;
TerminalRule orig = ((TerminalRule) rule);
TerminalRule copy = this.<TerminalRule>copy(orig);
copy.setName(ruleName);
boolean _isFragment = orig.isFragment();
copy.setFragment(_isFragment);
this.attachTo(copy, orig, origToCopy);
result.add(copy);
}
}
if (!_matched) {
if (rule instanceof EnumRule) {
_matched = true;
EnumRule copy = this.<EnumRule>copy(((EnumRule) rule));
copy.setName(ruleName);
this.attachTo(copy, rule, origToCopy);
result.add(copy);
}
}
}
}
return result;
}
protected String _ruleName(final TerminalRule it) {
String _name = it.getName();
String _upperCase = _name.toUpperCase();
return ("RULE_" + _upperCase);
}