public void testMetamodel() throws Exception {
   AbstractRule rule =
       GrammarUtil.findRuleForName(getGrammarAccess().getGrammar(), "OverridableParserRule2");
   assertNotNull("rule", rule);
   TypeRef ref = rule.getType();
   assertNotNull("ref", ref);
   final EClass clazz = (EClass) ref.getClassifier();
   assertNotNull("class", clazz);
   assertEquals("AType2", clazz.getName());
   assertEquals(2, clazz.getESuperTypes().size());
   Set<String> expectedNames =
       new HashSet<String>(Arrays.asList(new String[] {"AType", "RootRule"}));
   Iterator<String> iter =
       Iterables.transform(
               clazz.getESuperTypes(),
               new Function<EClass, String>() {
                 public String apply(EClass param) {
                   return param.getName();
                 }
               })
           .iterator();
   while (iter.hasNext()) {
     String name = iter.next();
     assertTrue("name = '" + name + "'", expectedNames.remove(name));
   }
   assertTrue(expectedNames.toString(), expectedNames.isEmpty());
 }
 public String defaultValue(final AbstractElement ele, final Set<AbstractElement> visited) {
   String _switchResult = null;
   boolean _matched = false;
   if (!_matched) {
     boolean _add = visited.add(ele);
     boolean _not = (!_add);
     if (_not) {
       _matched = true;
       _switchResult = "";
     }
   }
   if (!_matched) {
     boolean _isOptionalCardinality = GrammarUtil.isOptionalCardinality(ele);
     if (_isOptionalCardinality) {
       _matched = true;
       _switchResult = "";
     }
   }
   if (!_matched) {
     if (ele instanceof Alternatives) {
       _matched = true;
       EList<AbstractElement> _elements = ((Alternatives) ele).getElements();
       AbstractElement _head = IterableExtensions.<AbstractElement>head(_elements);
       _switchResult = this.defaultValue(_head, visited);
     }
   }
   if (!_matched) {
     if (ele instanceof Group) {
       _matched = true;
       EList<AbstractElement> _elements = ((Group) ele).getElements();
       final Function1<AbstractElement, String> _function =
           new Function1<AbstractElement, String>() {
             @Override
             public String apply(final AbstractElement e) {
               return AbstractSyntacticSequencer.this.defaultValue(e, visited);
             }
           };
       List<String> _map = ListExtensions.<AbstractElement, String>map(_elements, _function);
       _switchResult = IterableExtensions.join(_map);
     }
   }
   if (!_matched) {
     if (ele instanceof Keyword) {
       _matched = true;
       _switchResult = ((Keyword) ele).getValue();
     }
   }
   if (!_matched) {
     if (ele instanceof RuleCall) {
       _matched = true;
       AbstractRule _rule = ((RuleCall) ele).getRule();
       AbstractElement _alternatives = _rule.getAlternatives();
       _switchResult = this.defaultValue(_alternatives, visited);
     }
   }
   if (!_matched) {
     _switchResult = "";
   }
   return _switchResult;
 }
 protected boolean hasIdRule(final CrossReference crossRef) {
   AbstractElement _terminal = crossRef.getTerminal();
   if ((_terminal instanceof RuleCall)) {
     AbstractElement _terminal_1 = crossRef.getTerminal();
     AbstractRule _rule = ((RuleCall) _terminal_1).getRule();
     final String ruleName = _rule.getName();
     boolean _or = false;
     boolean _or_1 = false;
     boolean _equals = Objects.equal(ruleName, "IdOrSuper");
     if (_equals) {
       _or_1 = true;
     } else {
       boolean _equals_1 = Objects.equal(ruleName, "ValidID");
       _or_1 = _equals_1;
     }
     if (_or_1) {
       _or = true;
     } else {
       boolean _equals_2 = Objects.equal(ruleName, "FeatureCallID");
       _or = _equals_2;
     }
     return _or;
   }
   return false;
 }
Ejemplo n.º 4
0
 @Inject
 public void computeDirectiveRules() {
   List<AbstractRule> allRules = GrammarUtil.allRules(jstGrammarAccess.getGrammar());
   for (AbstractRule rule : allRules) {
     if (rule instanceof TerminalRule && rule.getName().startsWith("DIRECTIVE")) {
       directiveRules.add((TerminalRule) rule);
     }
   }
 }
Ejemplo n.º 5
0
 private String getDefaultAntlrRuleName(AbstractRule rule) {
   if (rule instanceof ParserRule || rule instanceof EnumRule) {
     return "rule" + rule.getName();
   }
   if (rule instanceof TerminalRule) {
     return "RULE_" + rule.getName().toUpperCase();
   }
   throw new IllegalArgumentException(rule.eClass().getName());
 }
Ejemplo n.º 6
0
 protected String _localVar(final RuleCall it) {
   AbstractRule _rule = it.getRule();
   String _name = _rule.getName();
   String _plus = ("this_" + _name);
   String _plus_1 = (_plus + "_");
   ParserRule _containingParserRule = GrammarUtil.containingParserRule(it);
   List<AbstractElement> _contentsAsList = this.contentsAsList(_containingParserRule);
   int _indexOf = _contentsAsList.indexOf(it);
   return (_plus_1 + Integer.valueOf(_indexOf));
 }
Ejemplo n.º 7
0
 private String getInheritedUniqueName(AbstractRule rule, Set<String> usedNames) {
   String grammarName = GrammarUtil.getSimpleName(GrammarUtil.getGrammar(rule));
   String candidate = grammarName + rule.getName();
   int i = 1;
   while (usedNames.contains(candidate)) {
     candidate = grammarName + i + rule.getName();
     i++;
   }
   return candidate;
 }
 @Override
 protected Collection<FollowElement> getFollowElements(
     AbstractInternalContentAssistParser parser) {
   if (rule == null || rule.eIsProxy()) return Collections.emptyList();
   String methodName = "entryRule" + rule.getName();
   PolymorphicDispatcher<Collection<FollowElement>> dispatcher =
       new PolymorphicDispatcher<Collection<FollowElement>>(
           methodName, 0, 0, Collections.singletonList(parser));
   dispatcher.invoke();
   return parser.getFollowElements();
 }
Ejemplo n.º 9
0
 protected String _toXtext(final RuleCall rc) {
   AbstractRule _rule = rc.getRule();
   String _name = _rule.getName();
   String _elvis = null;
   String _cardinality = rc.getCardinality();
   if (_cardinality != null) {
     _elvis = _cardinality;
   } else {
     _elvis = "";
   }
   return (_name + _elvis);
 }
Ejemplo n.º 10
0
 public void assertPredicate(final String expectation, final String grammar) {
   try {
     EObject _model = this.getModel(grammar);
     final Grammar parsed = ((Grammar) _model);
     EList<AbstractRule> _rules = parsed.getRules();
     AbstractRule _head = IterableExtensions.<AbstractRule>head(_rules);
     final AbstractElement body = _head.getAlternatives();
     final AbstractElement predicate = AntlrGrammarGenUtil.getPredicatedElement(body);
     String _xtext = this.toXtext(predicate);
     Assert.assertEquals(expectation, _xtext);
   } catch (Throwable _e) {
     throw Exceptions.sneakyThrow(_e);
   }
 }
Ejemplo n.º 11
0
 protected AbstractElement _predicatedElement(final RuleCall it) {
   AbstractElement _xifexpression = null;
   boolean _isPredicated = it.isPredicated();
   if (_isPredicated) {
     _xifexpression = it;
   } else {
     AbstractRule _rule = it.getRule();
     AbstractElement _alternatives = _rule.getAlternatives();
     EList<AbstractElement> _elements = ((Group) _alternatives).getElements();
     AbstractElement _head = IterableExtensions.<AbstractElement>head(_elements);
     _xifexpression = this.predicatedElement(_head);
   }
   return _xifexpression;
 }
Ejemplo n.º 12
0
  public RuleNames(Grammar grammar, boolean installAdapter) {
    this.contextGrammar = grammar;
    Adapter adapter = new Adapter(this);
    if (installAdapter) {
      installAdapterIfMissing(adapter, grammar);
    }
    List<AbstractRule> allRules = GrammarUtil.allRules(grammar);
    ImmutableListMultimap.Builder<String, AbstractRule> simpleNameToRulesBuilder =
        ImmutableListMultimap.builder();
    ImmutableMap.Builder<String, AbstractRule> qualifiedNameToRuleBuilder = ImmutableMap.builder();
    ImmutableBiMap.Builder<String, AbstractRule> uniqueNameToRuleBuilder = ImmutableBiMap.builder();
    ImmutableBiMap.Builder<String, AbstractRule> antlrNameToRuleBuilder = ImmutableBiMap.builder();

    Map<String, AbstractRule> names = Maps.newHashMap();
    Set<String> usedAntlrNames = Sets.newHashSet();
    Set<String> usedUniqueNames = Sets.newHashSet();
    for (AbstractRule rule : allRules) {
      String name = rule.getName();
      simpleNameToRulesBuilder.put(name, rule);
      String qualifiedName = getQualifiedName(rule);
      qualifiedNameToRuleBuilder.put(qualifiedName, rule);
      String uniqueName = name;
      String antlrRuleName;
      if (names.containsKey(name)) {
        name = qualifiedName;
        uniqueName = getInheritedUniqueName(rule, usedUniqueNames);
        antlrRuleName = getInheritedAntlrRuleName(rule, usedAntlrNames);
      } else {
        antlrRuleName = getDefaultAntlrRuleName(rule);
      }
      names.put(name, rule);
      if (!usedUniqueNames.add(uniqueName)) {
        throw new IllegalStateException(uniqueName);
      }
      uniqueNameToRuleBuilder.put(uniqueName, rule);
      if (!usedAntlrNames.add(antlrRuleName)) {
        throw new IllegalStateException(antlrRuleName);
      }
      antlrNameToRuleBuilder.put(antlrRuleName, rule);
      if (installAdapter) {
        installAdapterIfMissing(adapter, rule);
      }
    }
    simpleNameToRules = simpleNameToRulesBuilder.build();
    qualifiedNameToRule = qualifiedNameToRuleBuilder.build();
    nameToRule = ImmutableBiMap.copyOf(names);
    uniqueNameToRule = uniqueNameToRuleBuilder.build();
    antlrNameToRule = antlrNameToRuleBuilder.build();
    this.allRules = ImmutableList.copyOf(allRules);
  }
Ejemplo n.º 13
0
 public static RuleNames tryGetRuleNames(AbstractRule rule) {
   Adapter adapter = (Adapter) EcoreUtil.getAdapter(rule.eAdapters(), RuleNames.class);
   if (adapter == null) {
     return null;
   }
   return adapter.getRuleNames();
 }
Ejemplo n.º 14
0
 public static RuleNames getRuleNames(AbstractRule rule) {
   Adapter adapter = (Adapter) EcoreUtil.getAdapter(rule.eAdapters(), RuleNames.class);
   if (adapter == null) {
     throw new IllegalStateException("Cannot find adapter");
   }
   return adapter.getRuleNames();
 }
Ejemplo n.º 15
0
 public CharSequence unassignedCalledTokenRuleName(final AbstractRule rule) {
   StringConcatenation _builder = new StringConcatenation();
   _builder.append("get");
   String _name = rule.getName();
   _builder.append(_name, "");
   _builder.append("Token");
   return _builder;
 }
Ejemplo n.º 16
0
  public static AbstractElement getPredicatedElement(AbstractElement element) {
    if (element.isPredicated()) {
      return element;
    }
    if (element instanceof Assignment) {
      return getPredicatedElement(((Assignment) element).getTerminal());
    }
    if (element instanceof RuleCall) {
      final RuleCall ruleCall = (RuleCall) element;
      final AbstractRule calledRule = ruleCall.getRule();
      Group group = (Group) calledRule.getAlternatives();
      AbstractElement first = group.getElements().get(0);
      AbstractElement result = getPredicatedElement(first);
      if (ruleCall.getArguments().isEmpty()) {
        return result;
      }
      EcoreUtil.Copier copier =
          new EcoreUtil.Copier() {
            private static final long serialVersionUID = 1L;

            @Override
            public EObject copy(EObject eObject) {
              if (eObject instanceof ParameterReference) {
                ParameterReference paramRef = (ParameterReference) eObject;
                Parameter parameter = paramRef.getParameter();
                if (calledRule == GrammarUtil.containingRule(parameter)) {
                  for (NamedArgument givenArgument : ruleCall.getArguments()) {
                    if (givenArgument.getParameter() == parameter) {
                      EObject result = copy(givenArgument.getValue());
                      return result;
                    }
                  }
                  throw new IllegalStateException();
                }
              }
              return super.copy(eObject);
            }
          };
      AbstractElement clone = (AbstractElement) copier.copy(result);
      copier.copyReferences();
      return clone;
    }
    return element;
  }
 private static void getAllKeywords(Set<String> kws, AbstractRule parserRule) {
   for (TreeIterator<EObject> tit = parserRule.eAllContents(); tit.hasNext(); ) {
     Object ele = tit.next();
     if (ele instanceof Keyword) {
       kws.add(((Keyword) ele).getValue());
     } else if (ele instanceof RuleCall) {
       getAllKeywords(kws, ((RuleCall) ele).getRule());
     }
   }
 }
Ejemplo n.º 18
0
 private String getInheritedAntlrRuleName(AbstractRule rule, Set<String> usedNames) {
   if (rule instanceof ParserRule || rule instanceof EnumRule) {
     String candidate = "super" + rule.getName();
     int i = 1;
     while (usedNames.contains(candidate)) {
       candidate = "super" + i + rule.getName();
       i++;
     }
     return candidate;
   }
   if (rule instanceof TerminalRule) {
     String candidate = "SUPER_" + rule.getName();
     int i = 1;
     while (usedNames.contains(candidate)) {
       candidate = "SUPER_" + i + "_" + rule.getName();
       i++;
     }
     return candidate;
   }
   throw new IllegalArgumentException(rule.eClass().getName());
 }
Ejemplo n.º 19
0
 protected boolean _predicated(final RuleCall it) {
   boolean _or = false;
   boolean _isPredicated = it.isPredicated();
   if (_isPredicated) {
     _or = true;
   } else {
     boolean _xblockexpression = false;
     {
       AbstractRule _rule = it.getRule();
       final AbstractElement group = _rule.getAlternatives();
       boolean _xifexpression = false;
       if ((group instanceof Group)) {
         EList<AbstractElement> _elements = ((Group) group).getElements();
         AbstractElement _head = IterableExtensions.<AbstractElement>head(_elements);
         _xifexpression = this.predicated(_head);
       } else {
         _xifexpression = false;
       }
       _xblockexpression = _xifexpression;
     }
     _or = _xblockexpression;
   }
   return _or;
 }
Ejemplo n.º 20
0
 public CharSequence toStringLiteral(final AbstractElement it) {
   CharSequence _switchResult = null;
   boolean _matched = false;
   if (!_matched) {
     if (it instanceof RuleCall) {
       AbstractRule _rule = ((RuleCall) it).getRule();
       boolean _notEquals = (!Objects.equal(_rule, null));
       if (_notEquals) {
         _matched = true;
         StringConcatenation _builder = new StringConcatenation();
         _builder.append("\"");
         AbstractRule _rule_1 = ((RuleCall) it).getRule();
         String _name = _rule_1.getName();
         _builder.append(_name, "");
         _builder.append("\"");
         _switchResult = _builder;
       }
     }
   }
   if (!_matched) {
     if (it instanceof Keyword) {
       _matched = true;
       StringConcatenation _builder = new StringConcatenation();
       _builder.append("\"");
       String _value = ((Keyword) it).getValue();
       String _stringInAntlrAction = AntlrGrammarGenUtil.toStringInAntlrAction(_value);
       _builder.append(_stringInAntlrAction, "");
       _builder.append("\"");
       _switchResult = _builder;
     }
   }
   if (!_matched) {
     _switchResult = "null";
   }
   return _switchResult;
 }
Ejemplo n.º 21
0
  private Multimap<TerminalRule, AbstractRule> copyRuleBodies(
      final List<AbstractRule> copies,
      final Map<RuleWithParameterValues, AbstractRule> origToCopy) {
    abstract class __FlattenedGrammarAccess_1 extends EcoreUtil.Copier {
      final __FlattenedGrammarAccess_1 _this__FlattenedGrammarAccess_1 = this;

      abstract Set<Parameter> getParameterConfig(
          final RuleCall origRuleCall, final RuleCall copyRuleCall);

      abstract void mergePredicates(final AbstractElement into, final AbstractElement from);

      abstract void mergeCardinalities(final AbstractElement into, final AbstractElement from);

      abstract boolean evaluate(final Condition condition);
    }

    final HashMultimap<TerminalRule, AbstractRule> calledFrom =
        HashMultimap.<TerminalRule, AbstractRule>create();
    for (final AbstractRule copy : copies) {
      {
        AbstractRule orig = RuleWithParameterValues.getOriginalRule(copy);
        final Set<Parameter> paramValues = RuleWithParameterValues.getParamValues(copy);
        EcoreUtil.Copier copier =
            new __FlattenedGrammarAccess_1() {
              @Override
              protected void copyReference(
                  final EReference eReference, final EObject eObject, final EObject copyEObject) {
                if ((eReference == XtextPackage.Literals.RULE_CALL__RULE)) {
                  RuleCall origRuleCall = ((RuleCall) eObject);
                  RuleCall copyRuleCall = ((RuleCall) copyEObject);
                  AbstractRule _rule = origRuleCall.getRule();
                  Set<Parameter> _parameterConfig =
                      this.getParameterConfig(origRuleCall, copyRuleCall);
                  RuleWithParameterValues _ruleWithParameterValues =
                      new RuleWithParameterValues(_rule, _parameterConfig);
                  AbstractRule calledCopy = origToCopy.get(_ruleWithParameterValues);
                  copyRuleCall.setRule(calledCopy);
                  if ((calledCopy instanceof TerminalRule)) {
                    calledFrom.put(((TerminalRule) calledCopy), copy);
                  }
                } else {
                  super.copyReference(eReference, eObject, copyEObject);
                }
              }

              Set<Parameter> getParameterConfig(
                  final RuleCall origRuleCall, final RuleCall copyRuleCall) {
                EList<NamedArgument> _arguments = origRuleCall.getArguments();
                boolean _isEmpty = _arguments.isEmpty();
                if (_isEmpty) {
                  return Collections.<Parameter>emptySet();
                }
                EList<NamedArgument> _arguments_1 = origRuleCall.getArguments();
                final Function1<NamedArgument, Boolean> _function =
                    (NamedArgument it) -> {
                      Condition _value = it.getValue();
                      return Boolean.valueOf(this.evaluate(_value));
                    };
                Iterable<NamedArgument> _filter =
                    IterableExtensions.<NamedArgument>filter(_arguments_1, _function);
                final Function1<NamedArgument, Parameter> _function_1 =
                    (NamedArgument it) -> {
                      return it.getParameter();
                    };
                Iterable<Parameter> _map =
                    IterableExtensions.<NamedArgument, Parameter>map(_filter, _function_1);
                Set<Parameter> result = IterableExtensions.<Parameter>toSet(_map);
                return result;
              }

              @Override
              protected void copyContainment(
                  final EReference eReference, final EObject eObject, final EObject copyEObject) {
                boolean _matched = false;
                if (Objects.equal(eReference, XtextPackage.Literals.RULE_CALL__ARGUMENTS)) {
                  _matched = true;
                }
                if (!_matched) {
                  if (Objects.equal(eReference, XtextPackage.Literals.GROUP__GUARD_CONDITION)) {
                    _matched = true;
                  }
                }
                if (_matched) {
                  return;
                }
                super.copyContainment(eReference, eObject, copyEObject);
              }

              @Override
              public EObject copy(final EObject eObject) {
                if ((eObject instanceof Group)) {
                  Group group = ((Group) eObject);
                  Condition _guardCondition = group.getGuardCondition();
                  boolean _tripleNotEquals = (_guardCondition != null);
                  if (_tripleNotEquals) {
                    Condition _guardCondition_1 = group.getGuardCondition();
                    boolean _evaluate = this.evaluate(_guardCondition_1);
                    boolean _not = (!_evaluate);
                    if (_not) {
                      return null;
                    }
                  }
                }
                EObject result = super.copy(eObject);
                if ((result instanceof CompoundElement)) {
                  List<AbstractElement> elements = ((CompoundElement) result).getElements();
                  int _size = elements.size();
                  boolean _tripleEquals = (_size == 1);
                  if (_tripleEquals) {
                    if (((!((CompoundElement) result).isFirstSetPredicated())
                        && (!((CompoundElement) result).isPredicated()))) {
                      AbstractElement element = elements.get(0);
                      this.mergeCardinalities(element, ((AbstractElement) result));
                      this.mergePredicates(element, ((AbstractElement) result));
                      return element;
                    } else {
                      AbstractElement element_1 = elements.get(0);
                      this.mergePredicates(((AbstractElement) result), element_1);
                      element_1.setFirstSetPredicated(false);
                      element_1.setPredicated(false);
                    }
                  }
                }
                if ((eObject instanceof AbstractElement)) {
                  OriginalElement original = new OriginalElement(((AbstractElement) eObject));
                  EClass _eClass = ((AbstractElement) eObject).eClass();
                  EClass _eClass_1 = result.eClass();
                  boolean _notEquals = (!Objects.equal(_eClass, _eClass_1));
                  if (_notEquals) {
                    EClass _eClass_2 = result.eClass();
                    String _name = _eClass_2.getName();
                    String _plus = ("copy is: \'" + _name);
                    String _plus_1 = (_plus + "\' but original was: \'");
                    EClass _eClass_3 = ((AbstractElement) eObject).eClass();
                    String _name_1 = _eClass_3.getName();
                    String _plus_2 = (_plus_1 + _name_1);
                    String _plus_3 = (_plus_2 + "\'");
                    throw new IllegalStateException(_plus_3);
                  }
                  original.attachToEmfObject(result);
                }
                return result;
              }

              void mergePredicates(final AbstractElement into, final AbstractElement from) {
                boolean _isPredicated = from.isPredicated();
                if (_isPredicated) {
                  into.setPredicated(true);
                  into.setFirstSetPredicated(false);
                } else {
                  if (((!into.isPredicated()) && from.isFirstSetPredicated())) {
                    into.setFirstSetPredicated(true);
                  }
                }
              }

              void mergeCardinalities(final AbstractElement into, final AbstractElement from) {
                String c1 = into.getCardinality();
                String c2 = from.getCardinality();
                String _switchResult = null;
                boolean _matched = false;
                if ((Objects.equal(c1, "*") || Objects.equal(c2, "*"))) {
                  _matched = true;
                }
                if (!_matched) {
                  if ((Objects.equal(c1, "+") && Objects.equal(c2, "?"))) {
                    _matched = true;
                  }
                }
                if (!_matched) {
                  if ((Objects.equal(c1, "?") && Objects.equal(c2, "+"))) {
                    _matched = true;
                  }
                }
                if (_matched) {
                  _switchResult = "*";
                }
                if (!_matched) {
                  if (Objects.equal(c1, null)) {
                    _matched = true;
                    _switchResult = c2;
                  }
                }
                if (!_matched) {
                  _switchResult = c1;
                }
                into.setCardinality(_switchResult);
              }

              boolean evaluate(final Condition condition) {
                ConditionEvaluator _conditionEvaluator = new ConditionEvaluator(paramValues);
                boolean result = _conditionEvaluator.evaluate(condition);
                return result;
              }
            };
        AbstractElement _alternatives = orig.getAlternatives();
        EObject _copy = copier.copy(_alternatives);
        AbstractElement copiedBody = ((AbstractElement) _copy);
        copier.copyReferences();
        copy.setAlternatives(copiedBody);
        if ((orig instanceof ParserRule)) {
          ParserRule castedCopy = ((ParserRule) copy);
          boolean _isDefinesHiddenTokens = ((ParserRule) orig).isDefinesHiddenTokens();
          if (_isDefinesHiddenTokens) {
            castedCopy.setDefinesHiddenTokens(true);
            EList<AbstractRule> _hiddenTokens = ((ParserRule) orig).getHiddenTokens();
            for (final AbstractRule rule : _hiddenTokens) {
              {
                RuleWithParameterValues _ruleWithParameterValues =
                    new RuleWithParameterValues(rule);
                final AbstractRule copiedTerminalRule = origToCopy.get(_ruleWithParameterValues);
                EList<AbstractRule> _hiddenTokens_1 = castedCopy.getHiddenTokens();
                _hiddenTokens_1.add(copiedTerminalRule);
                calledFrom.put(((TerminalRule) copiedTerminalRule), castedCopy);
              }
            }
          }
        }
      }
    }
    return calledFrom;
  }
Ejemplo n.º 22
0
 public String getQualifiedName(AbstractRule rule) {
   return GrammarUtil.getGrammar(rule).getName() + "." + rule.getName();
 }
Ejemplo n.º 23
0
 protected String toString(AbstractRule rule) {
   return rule == null ? "null" : rule.getName();
 }
Ejemplo n.º 24
0
 public String genGetUnassignedRuleCallToken(
     final JavaFile file, final AbstractRule rule, final boolean isAbstract) {
   if ((rule instanceof TerminalRule)) {
     boolean _and = false;
     if (!this.detectSyntheticTerminals) {
       _and = false;
     } else {
       boolean _isSyntheticTerminalRule =
           this.syntheticTerminalDetector.isSyntheticTerminalRule(((TerminalRule) rule));
       _and = _isSyntheticTerminalRule;
     }
     if (_and) {
       StringConcatenation _builder = new StringConcatenation();
       _builder.append("/**");
       _builder.newLine();
       _builder.append(" ");
       _builder.append(
           "* Synthetic terminal rule. The concrete syntax is to be specified by clients.");
       _builder.newLine();
       {
         if ((!isAbstract)) {
           _builder.append(" * Defaults to the empty string.");
         }
       }
       _builder.newLineIfNotEmpty();
       _builder.append(" ");
       _builder.append("*/");
       _builder.newLine();
       _builder.append("protected ");
       {
         if (isAbstract) {
           _builder.append("abstract ");
         }
       }
       _builder.append("String ");
       CharSequence _unassignedCalledTokenRuleName = this.unassignedCalledTokenRuleName(rule);
       _builder.append(_unassignedCalledTokenRuleName, "");
       _builder.append("(EObject semanticObject, RuleCall ruleCall, INode node)");
       {
         if (isAbstract) {
           _builder.append(";");
         } else {
           _builder.append(" { return \"\"; }");
         }
       }
       _builder.newLineIfNotEmpty();
       return _builder.toString();
     }
   }
   StringConcatenation _builder_1 = new StringConcatenation();
   _builder_1.append("/**");
   _builder_1.newLine();
   _builder_1.append(" ");
   _builder_1.append("* ");
   ICompositeNode _node = NodeModelUtils.getNode(rule);
   String _textWithoutComments = this.textWithoutComments(_node);
   String _trim = _textWithoutComments.trim();
   String _replace = _trim.replace("\n", "\n* ");
   _builder_1.append(_replace, " ");
   _builder_1.newLineIfNotEmpty();
   _builder_1.append(" ");
   _builder_1.append("*/");
   _builder_1.newLine();
   _builder_1.append("protected String ");
   CharSequence _unassignedCalledTokenRuleName_1 = this.unassignedCalledTokenRuleName(rule);
   _builder_1.append(_unassignedCalledTokenRuleName_1, "");
   _builder_1.append("(EObject semanticObject, RuleCall ruleCall, INode node) {");
   _builder_1.newLineIfNotEmpty();
   _builder_1.append("\t");
   _builder_1.append("if (node != null)");
   _builder_1.newLine();
   _builder_1.append("\t\t");
   _builder_1.append("return getTokenText(node);");
   _builder_1.newLine();
   _builder_1.append("\t");
   _builder_1.append("return \"");
   AbstractElement _alternatives = rule.getAlternatives();
   HashSet<AbstractElement> _newHashSet = CollectionLiterals.<AbstractElement>newHashSet();
   String _defaultValue = this.defaultValue(_alternatives, _newHashSet);
   String _convertToJavaString = Strings.convertToJavaString(_defaultValue);
   _builder_1.append(_convertToJavaString, "\t");
   _builder_1.append("\";");
   _builder_1.newLineIfNotEmpty();
   _builder_1.append("}");
   _builder_1.newLine();
   return _builder_1.toString();
 }