wurstscript / WurstScript / 265

Committed 29 Sep 2025 09:00AM UTC coverage: 62.244% (+0.02%) from 62.222%

Build # 265

Build Type

Pull #1096

circleci

Committed by

Frotty

Commit Message

restore determinism, fix tests

Pull Request Pull Request #1096: Perf improvements

Run Details

17480 of 28083 relevant lines covered (62.24%)

0.62 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

77.05

de.peeeq.wurstscript/src/main/java/de/peeeq/wurstscript/jass/ExtendedJassLexer.java

package de.peeeq.wurstscript.jass;

import de.peeeq.wurstscript.WLogger;
import de.peeeq.wurstscript.antlr.JassLexer;
import de.peeeq.wurstscript.antlr.JassParser;
import de.peeeq.wurstscript.utils.LineOffsets;
import org.antlr.v4.runtime.*;
import org.antlr.v4.runtime.misc.Pair;
import org.eclipse.jdt.annotation.Nullable;

import java.util.ArrayDeque;
import java.util.LinkedList;
import java.util.Queue;

public class ExtendedJassLexer implements TokenSource {

    private final JassLexer orig;
    private final Queue<Token> nextTokens = new ArrayDeque<>();
    private State state = State.INIT;
    private @Nullable Token eof = null;
    private @Nullable Token firstNewline;
    private final LineOffsets lineOffsets = new LineOffsets();
    private final boolean debug = false;
    private final Pair<TokenSource, CharStream> sourcePair;

    enum State {
        INIT, NEWLINES, BEGIN_LINE
    }

    public ExtendedJassLexer(CharStream input) {
        orig = new JassLexer(input);
        sourcePair = new Pair<>(orig, input);
    }

    @Override
    public int getCharPositionInLine() {
        return orig.getCharPositionInLine();
    }

    @Override
    public CharStream getInputStream() {
        return orig.getInputStream();
    }

    @Override
    public int getLine() {
        return orig.getLine();
    }

    @Override
    public String getSourceName() {
        return orig.getSourceName();
    }

    @Override
    public TokenFactory<?> getTokenFactory() {
        return orig.getTokenFactory();
    }

    @Override
    public Token nextToken() {
        Token t = nextTokenIntern();

        if (debug) WLogger.info("                new token: " + t);
        return t;
    }


    private Token nextTokenIntern() {
        if (!nextTokens.isEmpty()) {
            return nextTokens.poll();
        }

        Token eof_local = eof;
        if (eof_local != null) {
            return makeToken(JassParser.EOF, eof_local.getStartIndex(), eof_local.getStopIndex());
        }


        for (; ; ) {
            Token token = orig.nextToken();

            if (debug) WLogger.info("orig token = " + token);

            if (token == null) {
                continue;
            }

            if (token.getType() == JassParser.NL) {
                lineOffsets.set(token.getLine(), token.getStopIndex());
            }

            if (token.getType() == JassParser.EOF) {
                // at EOF close all blocks and return an extra newline
                eof = token;
                // add a single newline
                return makeToken(JassParser.NL, token.getStartIndex(), token.getStopIndex());
            }

            if (token.getType() == JassParser.ID
                    && token.getText().equals("debug")
                    && (state == State.NEWLINES)) {
                // ignore 'debug' at beginning of line
                continue;
            }


            switch (state) {
                case INIT:
                    if (token.getType() == JassParser.NL) {
                        firstNewline = token;
                        state(State.NEWLINES);
                        continue;
                    }
                    return token;
                case NEWLINES:
                    if (token.getType() == JassParser.NL) {
                        continue;
                    } else {
                        nextTokens.add(token);
                        state(State.INIT);
                        return firstNewline;
                    }
                case BEGIN_LINE:
                    if (token.getType() == JassParser.NL) {
                        state(State.NEWLINES);
                    } else {
                        state(State.INIT);
                        nextTokens.add(token);
                        return firstNewline;
                    }
            }
        }
    }


    private void state(State s) {
        if (debug) WLogger.info("state " + state + " -> " + s);
        state = s;
    }

    private Token makeToken(int type, int start, int stop) {
        Pair<TokenSource, CharStream> source = sourcePair;
        int channel = 0;
        return new CommonToken(source, type, channel, start, stop);
    }

    @Override
    public void setTokenFactory(@SuppressWarnings("null") TokenFactory<?> factory) {
        orig.setTokenFactory(factory);
    }


    public LineOffsets getLineOffsets() {
        return lineOffsets;
    }


    public void addErrorListener(ANTLRErrorListener listener) {
        orig.addErrorListener(listener);
    }
}

1	package de.peeeq.wurstscript.jass;
2
3	import de.peeeq.wurstscript.WLogger;
4	import de.peeeq.wurstscript.antlr.JassLexer;
5	import de.peeeq.wurstscript.antlr.JassParser;
6	import de.peeeq.wurstscript.utils.LineOffsets;
7	import org.antlr.v4.runtime.*;
8	import org.antlr.v4.runtime.misc.Pair;
9	import org.eclipse.jdt.annotation.Nullable;
10
11	import java.util.ArrayDeque;
12	import java.util.LinkedList;
13	import java.util.Queue;
14
15	public class ExtendedJassLexer implements TokenSource {
16
17	private final JassLexer orig;
18	private final Queue<Token> nextTokens = new ArrayDeque<>();	1✔
19	private State state = State.INIT;	1✔
20	private @Nullable Token eof = null;	1✔
21	private @Nullable Token firstNewline;
22	private final LineOffsets lineOffsets = new LineOffsets();	1✔
23	private final boolean debug = false;	1✔
24	private final Pair<TokenSource, CharStream> sourcePair;
25
26	enum State {	1✔
27	INIT, NEWLINES, BEGIN_LINE	1✔
28	}
29
30	public ExtendedJassLexer(CharStream input) {	1✔
31	orig = new JassLexer(input);	1✔
32	sourcePair = new Pair<>(orig, input);	1✔
33	}	1✔
34
35	@Override
36	public int getCharPositionInLine() {
37	return orig.getCharPositionInLine();	×
38	}
39
40	@Override
41	public CharStream getInputStream() {
42	return orig.getInputStream();	×
43	}
44
45	@Override
46	public int getLine() {
47	return orig.getLine();	×
48	}
49
50	@Override
51	public String getSourceName() {
52	return orig.getSourceName();	×
53	}
54
55	@Override
56	public TokenFactory<?> getTokenFactory() {
57	return orig.getTokenFactory();	×
58	}
59
60	@Override
61	public Token nextToken() {
62	Token t = nextTokenIntern();	1✔
63
64	if (debug) WLogger.info(" new token: " + t);
65	return t;	1✔
66	}
67
68
69	private Token nextTokenIntern() {
70	if (!nextTokens.isEmpty()) {	1✔
71	return nextTokens.poll();	1✔
72	}
73
74	Token eof_local = eof;	1✔
75	if (eof_local != null) {	1✔
76	return makeToken(JassParser.EOF, eof_local.getStartIndex(), eof_local.getStopIndex());	1✔
77	}
78
79
80	for (; ; ) {
81	Token token = orig.nextToken();	1✔
82
83	if (debug) WLogger.info("orig token = " + token);
84
85	if (token == null) {	1✔
86	continue;	×
87	}
88
89	if (token.getType() == JassParser.NL) {	1✔
90	lineOffsets.set(token.getLine(), token.getStopIndex());	1✔
91	}
92
93	if (token.getType() == JassParser.EOF) {	1✔
94	// at EOF close all blocks and return an extra newline
95	eof = token;	1✔
96	// add a single newline
97	return makeToken(JassParser.NL, token.getStartIndex(), token.getStopIndex());	1✔
98	}
99
100	if (token.getType() == JassParser.ID	1✔
101	&& token.getText().equals("debug")	1✔
102	&& (state == State.NEWLINES)) {
103	// ignore 'debug' at beginning of line
104	continue;	1✔
105	}
106
107
108	switch (state) {	1✔
109	case INIT:
110	if (token.getType() == JassParser.NL) {	1✔
111	firstNewline = token;	1✔
112	state(State.NEWLINES);	1✔
113	continue;	1✔
114	}
115	return token;	1✔
116	case NEWLINES:
117	if (token.getType() == JassParser.NL) {	1✔
118	continue;	1✔
119	} else {
120	nextTokens.add(token);	1✔
121	state(State.INIT);	1✔
122	return firstNewline;	1✔
123	}
124	case BEGIN_LINE:
125	if (token.getType() == JassParser.NL) {	×
126	state(State.NEWLINES);	×
127	} else {
128	state(State.INIT);	×
129	nextTokens.add(token);	×
130	return firstNewline;	×
131	}
132	}
133	}	×
134	}
135
136
137	private void state(State s) {
138	if (debug) WLogger.info("state " + state + " -> " + s);
139	state = s;	1✔
140	}	1✔
141
142	private Token makeToken(int type, int start, int stop) {
143	Pair<TokenSource, CharStream> source = sourcePair;	1✔
144	int channel = 0;	1✔
145	return new CommonToken(source, type, channel, start, stop);	1✔
146	}
147
148	@Override
149	public void setTokenFactory(@SuppressWarnings("null") TokenFactory<?> factory) {
150	orig.setTokenFactory(factory);	×
151	}	×
152
153
154	public LineOffsets getLineOffsets() {
155	return lineOffsets;	1✔
156	}
157
158
159	public void addErrorListener(ANTLRErrorListener listener) {
160	orig.addErrorListener(listener);	1✔
161	}	1✔
162	}

wurstscript / WurstScript / 265

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous