Search in sources :

Example 6 with IUnorderedGroupHelper

use of org.eclipse.xtext.parser.antlr.IUnorderedGroupHelper in project n4js by eclipse.

the class CustomN4JSParser method doGetFollowElements.

/**
 * Initialize the parser properly with the given tokens and process it.
 */
private Collection<FollowElement> doGetFollowElements(AbstractInternalContentAssistParser parser, ObservableXtextTokenStream tokens) {
    tokens.setInitialHiddenTokens(getInitialHiddenTokens());
    parser.setTokenStream(tokens);
    IUnorderedGroupHelper helper = getUnorderedGroupHelper().get();
    parser.setUnorderedGroupHelper(helper);
    helper.initializeWith(parser);
    tokens.setListener(parser);
    Collection<FollowElement> followElements = getFollowElements(parser);
    return followElements;
}
Also used : IUnorderedGroupHelper(org.eclipse.xtext.parser.antlr.IUnorderedGroupHelper) FollowElement(org.eclipse.xtext.ide.editor.contentassist.antlr.FollowElement)

Example 7 with IUnorderedGroupHelper

use of org.eclipse.xtext.parser.antlr.IUnorderedGroupHelper in project n4js by eclipse.

the class CustomN4JSParser method getFollowElements.

@SuppressWarnings("hiding")
@Override
public Collection<FollowElement> getFollowElements(FollowElement element) {
    if (element.getLookAhead() <= 1)
        throw new IllegalArgumentException("lookahead may not be less than or equal to 1");
    Collection<FollowElement> result = new ArrayList<>();
    Collection<AbstractElement> elementsToParse = this.reflective("getElementsToParse", element);
    for (AbstractElement elementToParse : elementsToParse) {
        // fix is here
        elementToParse = unwrapSingleElementGroups(elementToParse);
        // done
        String ruleName = getRuleName(elementToParse);
        String[][] allRuleNames = reflective("getRequiredRuleNames", ruleName, element.getParamStack(), elementToParse);
        for (String[] ruleNames : allRuleNames) {
            for (int i = 0; i < ruleNames.length; i++) {
                AbstractInternalContentAssistParser parser = createParser();
                parser.setUnorderedGroupHelper(getUnorderedGroupHelper().get());
                parser.getUnorderedGroupHelper().initializeWith(parser);
                final Iterator<LookAheadTerminal> iter = element.getLookAheadTerminals().iterator();
                ObservableXtextTokenStream tokens = new ObservableXtextTokenStream(new TokenSource() {

                    @Override
                    public Token nextToken() {
                        if (iter.hasNext()) {
                            LookAheadTerminal lookAhead = iter.next();
                            return lookAhead.getToken();
                        }
                        return Token.EOF_TOKEN;
                    }

                    @Override
                    public String getSourceName() {
                        return "LookAheadTerminalTokenSource";
                    }
                }, parser);
                parser.setTokenStream(tokens);
                tokens.setListener(parser);
                parser.getGrammarElements().addAll(element.getTrace());
                parser.getGrammarElements().add(elementToParse);
                parser.getLocalTrace().addAll(element.getLocalTrace());
                parser.getLocalTrace().add(elementToParse);
                parser.getParamStack().addAll(element.getParamStack());
                if (elementToParse instanceof UnorderedGroup && element.getGrammarElement() == elementToParse) {
                    UnorderedGroup group = (UnorderedGroup) elementToParse;
                    final IUnorderedGroupHelper helper = parser.getUnorderedGroupHelper();
                    helper.enter(group);
                    for (AbstractElement consumed : element.getHandledUnorderedGroupElements()) {
                        parser.before(consumed);
                        helper.select(group, group.getElements().indexOf(consumed));
                        helper.returnFromSelection(group);
                        parser.after(consumed);
                    }
                    parser.setUnorderedGroupHelper(new IUnorderedGroupHelper() {

                        boolean first = true;

                        @Override
                        public void initializeWith(BaseRecognizer recognizer) {
                            helper.initializeWith(recognizer);
                        }

                        @Override
                        public void enter(UnorderedGroup group) {
                            if (!first)
                                helper.enter(group);
                            first = false;
                        }

                        @Override
                        public void leave(UnorderedGroup group) {
                            helper.leave(group);
                        }

                        @Override
                        public boolean canSelect(UnorderedGroup group, int index) {
                            return helper.canSelect(group, index);
                        }

                        @Override
                        public void select(UnorderedGroup group, int index) {
                            helper.select(group, index);
                        }

                        @Override
                        public void returnFromSelection(UnorderedGroup group) {
                            helper.returnFromSelection(group);
                        }

                        @Override
                        public boolean canLeave(UnorderedGroup group) {
                            return helper.canLeave(group);
                        }

                        @Override
                        public UnorderedGroupState snapShot(UnorderedGroup... groups) {
                            return helper.snapShot(groups);
                        }
                    });
                }
                Collection<FollowElement> elements = reflective("getFollowElements", parser, elementToParse, ruleNames, i);
                result.addAll(elements);
            }
        }
    }
    return result;
}
Also used : TokenSource(org.antlr.runtime.TokenSource) AbstractElement(org.eclipse.xtext.AbstractElement) ObservableXtextTokenStream(org.eclipse.xtext.ide.editor.contentassist.antlr.ObservableXtextTokenStream) ArrayList(java.util.ArrayList) Token(org.antlr.runtime.Token) CommonToken(org.antlr.runtime.CommonToken) AbstractInternalContentAssistParser(org.eclipse.xtext.ide.editor.contentassist.antlr.internal.AbstractInternalContentAssistParser) FollowElement(org.eclipse.xtext.ide.editor.contentassist.antlr.FollowElement) IUnorderedGroupHelper(org.eclipse.xtext.parser.antlr.IUnorderedGroupHelper) LookAheadTerminal(org.eclipse.xtext.ide.editor.contentassist.antlr.LookAheadTerminal) UnorderedGroup(org.eclipse.xtext.UnorderedGroup) BaseRecognizer(org.antlr.runtime.BaseRecognizer)

Aggregations

IUnorderedGroupHelper (org.eclipse.xtext.parser.antlr.IUnorderedGroupHelper)7 TokenSource (org.antlr.runtime.TokenSource)4 AbstractElement (org.eclipse.xtext.AbstractElement)3 ArrayList (java.util.ArrayList)2 Token (org.antlr.runtime.Token)2 UnorderedGroup (org.eclipse.xtext.UnorderedGroup)2 FollowElement (org.eclipse.xtext.ide.editor.contentassist.antlr.FollowElement)2 InfiniteRecursion (org.eclipse.xtext.ide.editor.contentassist.antlr.internal.InfiniteRecursion)2 Stopwatch (com.google.common.base.Stopwatch)1 IOException (java.io.IOException)1 BaseRecognizer (org.antlr.runtime.BaseRecognizer)1 CommonToken (org.antlr.runtime.CommonToken)1 WrappedException (org.eclipse.emf.common.util.WrappedException)1 LazyTokenStream (org.eclipse.n4js.parser.LazyTokenStream)1 LookAheadTerminal (org.eclipse.xtext.ide.editor.contentassist.antlr.LookAheadTerminal)1 ObservableXtextTokenStream (org.eclipse.xtext.ide.editor.contentassist.antlr.ObservableXtextTokenStream)1 AbstractInternalContentAssistParser (org.eclipse.xtext.ide.editor.contentassist.antlr.internal.AbstractInternalContentAssistParser)1 ICompositeNode (org.eclipse.xtext.nodemodel.ICompositeNode)1 ParseException (org.eclipse.xtext.parser.ParseException)1