wurstscript / WurstScript / 228

Committed 29 Nov 2023 05:00PM UTC coverage: 62.48% (-0.09%) from 62.574%

Build # 228

Build Type

push

circleci

Committed by

web-flow

Commit Message

Show dialog for choosing game path, cleanup (#1083)

* show dialog for choosing game path

* cleanup code

* remove logs and refactor

* remove confusing mpq error, make some mpq loads readonly

Run Details

17295 of 27681 relevant lines covered (62.48%)

0.62 hits per line

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

80.27

de.peeeq.wurstscript/src/main/java/de/peeeq/wurstscript/intermediatelang/interpreter/ILInterpreter.java

package de.peeeq.wurstscript.intermediatelang.interpreter;

import de.peeeq.wurstio.jassinterpreter.DebugPrintError;
import de.peeeq.wurstio.jassinterpreter.InterpreterException;
import de.peeeq.wurstio.jassinterpreter.VarargArray;
import de.peeeq.wurstscript.ast.Annotation;
import de.peeeq.wurstscript.ast.HasModifier;
import de.peeeq.wurstscript.ast.Modifier;
import de.peeeq.wurstscript.gui.WurstGui;
import de.peeeq.wurstscript.intermediatelang.*;
import de.peeeq.wurstscript.jassIm.*;
import de.peeeq.wurstscript.jassinterpreter.ReturnException;
import de.peeeq.wurstscript.jassinterpreter.TestFailException;
import de.peeeq.wurstscript.jassinterpreter.TestSuccessException;
import de.peeeq.wurstscript.parser.WPos;
import de.peeeq.wurstscript.translation.imtranslation.FunctionFlagEnum;
import de.peeeq.wurstscript.translation.imtranslation.ImHelper;
import org.eclipse.jdt.annotation.Nullable;

import java.io.File;
import java.util.Arrays;
import java.util.LinkedHashMap;
import java.util.Objects;
import java.util.Optional;
import java.util.stream.Collectors;

import static de.peeeq.wurstscript.translation.imoptimizer.UselessFunctionCallsRemover.isFunctionPure;

public class ILInterpreter implements AbstractInterpreter {
    private ImProg prog;
    private static boolean cache = false;
    private final ProgramState globalState;
    private final TimerMockHandler timerMockHandler = new TimerMockHandler();

    public ILInterpreter(ImProg prog, WurstGui gui, Optional<File> mapFile, ProgramState globalState, boolean cache) {
        this.prog = prog;
        this.globalState = globalState;
        ILInterpreter.cache = cache;
        globalState.addNativeProvider(new BuiltinFuncs(globalState));
//        globalState.addNativeProvider(new NativeFunctions());
    }

    public ILInterpreter(ImProg prog, WurstGui gui, Optional<File> mapFile, boolean isCompiletime, boolean cache) {
        this(prog, gui, mapFile, new ProgramState(gui, prog, isCompiletime), cache);
    }

    public static LocalState runFunc(ProgramState globalState, ImFunction f, @Nullable Element caller,
                                     ILconst... args) {
        if (Thread.currentThread().isInterrupted()) {
            throw new InterpreterException(globalState, "Execution interrupted");
        }
        try {
            if (f.hasFlag(FunctionFlagEnum.IS_VARARG)) {
                // for vararg functions, rewrite args and put last argument
                ILconst[] newArgs = new ILconst[f.getParameters().size()];
                if (newArgs.length - 1 >= 0) System.arraycopy(args, 0, newArgs, 0, newArgs.length - 1);

                ILconst[] varargArray = new ILconst[1 + args.length - newArgs.length];
                for (int i = newArgs.length - 1, j = 0; i < args.length; i++, j++) {
                    varargArray[j] = args[i];
                }
                newArgs[newArgs.length - 1] = new VarargArray(varargArray);
                args = newArgs;
            }

            if (f.getParameters().size() != args.length) {
                throw new Error("wrong number of parameters when calling func " + f.getName() + "(" +
                    Arrays.stream(args).map(Object::toString).collect(Collectors.joining(", ")) + ")");
            }

            for (int i = 0; i < f.getParameters().size(); i++) {
                // TODO could do typecheck here
                args[i] = adjustTypeOfConstant(args[i], f.getParameters().get(i).getType());
            }

            if (isCompiletimeNative(f)) {
                return runBuiltinFunction(globalState, f, args);
            }

            if (f.isNative()) {
                return runBuiltinFunction(globalState, f, args);
            }

            LocalState localState = new LocalState();
            int i = 0;
            for (ImVar p : f.getParameters()) {
                localState.setVal(p, args[i]);
                i++;
            }

            if (f.getBody().isEmpty()) {
                return localState.setReturnVal(ILconstNull.instance());
            } else {
                globalState.setLastStatement(f.getBody().get(0));
            }

            globalState.pushStackframe(f, args, (caller == null ? f : caller).attrTrace().attrErrorPos());

            try {
                f.getBody().runStatements(globalState, localState);
                globalState.popStackframe();
            } catch (ReturnException e) {
                globalState.popStackframe();
                ILconst retVal = e.getVal();
                retVal = adjustTypeOfConstant(retVal, f.getReturnType());
                return localState.setReturnVal(retVal);
            }
            if (f.getReturnType() instanceof ImVoid) {
                return localState;
            }
            throw new InterpreterException("function " + f.getName() + " did not return any value...");
        } catch (InterpreterException e) {
            String msg = buildStacktrace(globalState, e);
            e.setStacktrace(msg);
            e.setTrace(getTrace(globalState, f));
            throw e;
        } catch (TestSuccessException | TestFailException | DebugPrintError e) {
            throw e;
        } catch (Throwable e) {
            String msg = buildStacktrace(globalState, e);
            de.peeeq.wurstscript.ast.Element trace = getTrace(globalState, f);
            throw new InterpreterException(trace, "You encountered a bug in the interpreter: " + e, e).setStacktrace(msg);
        }
    }

    public static de.peeeq.wurstscript.ast.Element getTrace(ProgramState globalState, ImFunction f) {
        Element lastStatement = globalState.getLastStatement();
        return lastStatement == null ? f.attrTrace() : lastStatement.attrTrace();
    }

    public static String buildStacktrace(ProgramState globalState, Throwable e) {
        StringBuilder err = new StringBuilder();
        try {
            WPos src = globalState.getLastStatement().attrTrace().attrSource();
            err.append("at : ").append(new File(src.getFile()).getName()).append(", line ").append(src.getLine()).append("\n");
        } catch (Exception _e) {
            // ignore
        }
        globalState.getStackFrames().appendTo(err);
        return err.toString();
    }

    @SuppressWarnings("null")
    private static ILconst adjustTypeOfConstant(@Nullable ILconst retVal, ImType expectedType) {
        if (retVal instanceof ILconstInt && isTypeReal(expectedType)) {
            ILconstInt retValI = (ILconstInt) retVal;
            retVal = new ILconstReal(retValI.getVal());
        }
        return retVal;
    }

    private static boolean isTypeReal(ImType t) {
        if (t instanceof ImSimpleType) {
            ImSimpleType st = (ImSimpleType) t;
            return st.getTypename().equals("real");
        }
        return false;
    }

    public static LinkedHashMap<ImFunction, LinkedHashMap<Integer, LocalState>> localStateCache = new LinkedHashMap<>();

    private static LocalState runBuiltinFunction(ProgramState globalState, ImFunction f, ILconst... args) {
        if (cache && isFunctionPure(f.getName())) {
            int combinedHash = Objects.hash((Object[]) args);
            if (localStateCache.containsKey(f) && localStateCache.get(f).containsKey(combinedHash)) {
                return localStateCache.get(f).get(combinedHash);
            }
        }
        StringBuilder errors = new StringBuilder();
        for (NativesProvider natives : globalState.getNativeProviders()) {
            try {
                LocalState localState = new LocalState(natives.invoke(f.getName(), args));
                if (cache && isFunctionPure(f.getName())) {
                    int combinedHash = Objects.hash((Object[]) args);
                    LinkedHashMap<Integer, LocalState> cached = localStateCache.getOrDefault(f, new LinkedHashMap<>());
                    cached.put(combinedHash, localState);
                    localStateCache.put(f, cached);
                }
                return localState;
            } catch (NoSuchNativeException e) {
                errors.append("\n").append(e.getMessage());
                // ignore
            }
        }
        globalState.compilationError("function " + f.getName() + " cannot be used from the Wurst interpreter.\n" + errors);
        if (f.getReturnType() instanceof ImVoid) {
            return new LocalState();
        }
        ILconst returnValue = ImHelper.defaultValueForComplexType(f.getReturnType()).evaluate(globalState, new LocalState());
        return new LocalState(returnValue);
    }

    private static boolean isCompiletimeNative(ImFunction f) {
        if (f.getTrace() instanceof HasModifier) {
            HasModifier f2 = (HasModifier) f.getTrace();
            for (Modifier m : f2.getModifiers()) {
                if (m instanceof Annotation) {
                    Annotation annotation = (Annotation) m;
                    if (annotation.getAnnotationType().equals("@compiletimenative")) {
                        return true;
                    }
                }
            }
        }
        return false;
    }

    public LocalState executeFunction(String funcName, @Nullable Element trace) {
        globalState.resetStackframes();
        for (ImFunction f : prog.getFunctions()) {
            if (f.getName().equals(funcName)) {
                return runFunc(globalState, f, trace);
            }
        }

        throw new Error("no function with name " + funcName + "was found.");
    }

    public void runVoidFunc(ImFunction f, @Nullable Element trace) {
        globalState.resetStackframes();
        ILconst[] args = {};
        if (!f.getParameters().isEmpty()) {
            // this should only happen because of added stacktrace parameter
            args = new ILconstString[]{new ILconstString("initial call")};
        }
        runFunc(globalState, f, trace, args);
    }

    public Element getLastStatement() {
        return globalState.getLastStatement();
    }

    public void writebackGlobalState(boolean injectObjects) {
        globalState.writeBack(injectObjects);

    }

    public ProgramState getGlobalState() {
        return globalState;
    }

    public void addNativeProvider(NativesProvider np) {
        globalState.addNativeProvider(np);
    }

    public void setProgram(ImProg imProg) {
        this.prog = imProg;
        this.getGlobalState().setProg(imProg);
        globalState.resetStackframes();
    }

    public ProgramState.StackTrace getStackFrames() {
        return globalState.getStackFrames();

    }

    @Override
    public void runFuncRef(ILconstFuncRef obj, @Nullable Element trace) {
        runVoidFunc(obj.getFunc(), trace);
    }

    @Override
    public TimerMockHandler getTimerMockHandler() {
        return timerMockHandler;
    }

    @Override
    public void completeTimers() {
        timerMockHandler.completeTimers();
    }

    @Override
    public ImProg getImProg() {
        return prog;
    }

    @Override
    public int getInstanceCount(int val) {
        return (int) globalState.getAllObjects()
            .stream()
            .filter(o -> o.getType().getClassDef().attrTypeId() == val)
            .filter(o -> !o.isDestroyed())
            .count();
    }

    @Override
    public int getMaxInstanceCount(int val) {
        return (int) globalState.getAllObjects()
            .stream()
            .filter(o -> o.getType().getClassDef().attrTypeId() == val)
            .count();
    }
}

1	package de.peeeq.wurstscript.intermediatelang.interpreter;
2
3	import de.peeeq.wurstio.jassinterpreter.DebugPrintError;
4	import de.peeeq.wurstio.jassinterpreter.InterpreterException;
5	import de.peeeq.wurstio.jassinterpreter.VarargArray;
6	import de.peeeq.wurstscript.ast.Annotation;
7	import de.peeeq.wurstscript.ast.HasModifier;
8	import de.peeeq.wurstscript.ast.Modifier;
9	import de.peeeq.wurstscript.gui.WurstGui;
10	import de.peeeq.wurstscript.intermediatelang.*;
11	import de.peeeq.wurstscript.jassIm.*;
12	import de.peeeq.wurstscript.jassinterpreter.ReturnException;
13	import de.peeeq.wurstscript.jassinterpreter.TestFailException;
14	import de.peeeq.wurstscript.jassinterpreter.TestSuccessException;
15	import de.peeeq.wurstscript.parser.WPos;
16	import de.peeeq.wurstscript.translation.imtranslation.FunctionFlagEnum;
17	import de.peeeq.wurstscript.translation.imtranslation.ImHelper;
18	import org.eclipse.jdt.annotation.Nullable;
19
20	import java.io.File;
21	import java.util.Arrays;
22	import java.util.LinkedHashMap;
23	import java.util.Objects;
24	import java.util.Optional;
25	import java.util.stream.Collectors;
26
27	import static de.peeeq.wurstscript.translation.imoptimizer.UselessFunctionCallsRemover.isFunctionPure;
28
29	public class ILInterpreter implements AbstractInterpreter {
30	private ImProg prog;
31	private static boolean cache = false;	1✔
32	private final ProgramState globalState;
33	private final TimerMockHandler timerMockHandler = new TimerMockHandler();	1✔
34
35	public ILInterpreter(ImProg prog, WurstGui gui, Optional<File> mapFile, ProgramState globalState, boolean cache) {	1✔
36	this.prog = prog;	1✔
37	this.globalState = globalState;	1✔
38	ILInterpreter.cache = cache;	1✔
39	globalState.addNativeProvider(new BuiltinFuncs(globalState));	1✔
40	// globalState.addNativeProvider(new NativeFunctions());
41	}	1✔
42
43	public ILInterpreter(ImProg prog, WurstGui gui, Optional<File> mapFile, boolean isCompiletime, boolean cache) {
44	this(prog, gui, mapFile, new ProgramState(gui, prog, isCompiletime), cache);	1✔
45	}	1✔
46
47	public static LocalState runFunc(ProgramState globalState, ImFunction f, @Nullable Element caller,
48	ILconst... args) {
49	if (Thread.currentThread().isInterrupted()) {	1✔
50	throw new InterpreterException(globalState, "Execution interrupted");	×
51	}
52	try {
53	if (f.hasFlag(FunctionFlagEnum.IS_VARARG)) {	1✔
54	// for vararg functions, rewrite args and put last argument
55	ILconst[] newArgs = new ILconst[f.getParameters().size()];	1✔
56	if (newArgs.length - 1 >= 0) System.arraycopy(args, 0, newArgs, 0, newArgs.length - 1);	1✔
57
58	ILconst[] varargArray = new ILconst[1 + args.length - newArgs.length];	1✔
59	for (int i = newArgs.length - 1, j = 0; i < args.length; i++, j++) {	1✔
60	varargArray[j] = args[i];	1✔
61	}
62	newArgs[newArgs.length - 1] = new VarargArray(varargArray);	1✔
63	args = newArgs;	1✔
64	}
65
66	if (f.getParameters().size() != args.length) {	1✔
67	throw new Error("wrong number of parameters when calling func " + f.getName() + "(" +	×
68	Arrays.stream(args).map(Object::toString).collect(Collectors.joining(", ")) + ")");	×
69	}
70
71	for (int i = 0; i < f.getParameters().size(); i++) {	1✔
72	// TODO could do typecheck here
73	args[i] = adjustTypeOfConstant(args[i], f.getParameters().get(i).getType());	1✔
74	}
75
76	if (isCompiletimeNative(f)) {	1✔
77	return runBuiltinFunction(globalState, f, args);	1✔
78	}
79
80	if (f.isNative()) {	1✔
81	return runBuiltinFunction(globalState, f, args);	1✔
82	}
83
84	LocalState localState = new LocalState();	1✔
85	int i = 0;	1✔
86	for (ImVar p : f.getParameters()) {	1✔
87	localState.setVal(p, args[i]);	1✔
88	i++;	1✔
89	}	1✔
90
91	if (f.getBody().isEmpty()) {	1✔
92	return localState.setReturnVal(ILconstNull.instance());	1✔
93	} else {
94	globalState.setLastStatement(f.getBody().get(0));	1✔
95	}
96
97	globalState.pushStackframe(f, args, (caller == null ? f : caller).attrTrace().attrErrorPos());	1✔
98
99	try {
100	f.getBody().runStatements(globalState, localState);	1✔
101	globalState.popStackframe();	1✔
102	} catch (ReturnException e) {	1✔
103	globalState.popStackframe();	1✔
104	ILconst retVal = e.getVal();	1✔
105	retVal = adjustTypeOfConstant(retVal, f.getReturnType());	1✔
106	return localState.setReturnVal(retVal);	1✔
107	}	1✔
108	if (f.getReturnType() instanceof ImVoid) {	1✔
109	return localState;	1✔
110	}
111	throw new InterpreterException("function " + f.getName() + " did not return any value...");	×
112	} catch (InterpreterException e) {	1✔
113	String msg = buildStacktrace(globalState, e);	1✔
114	e.setStacktrace(msg);	1✔
115	e.setTrace(getTrace(globalState, f));	1✔
116	throw e;	1✔
117	} catch (TestSuccessException \| TestFailException \| DebugPrintError e) {	1✔
118	throw e;	1✔
119	} catch (Throwable e) {	×
120	String msg = buildStacktrace(globalState, e);	×
121	de.peeeq.wurstscript.ast.Element trace = getTrace(globalState, f);	×
122	throw new InterpreterException(trace, "You encountered a bug in the interpreter: " + e, e).setStacktrace(msg);	×
123	}
124	}
125
126	public static de.peeeq.wurstscript.ast.Element getTrace(ProgramState globalState, ImFunction f) {
127	Element lastStatement = globalState.getLastStatement();	1✔
128	return lastStatement == null ? f.attrTrace() : lastStatement.attrTrace();	1✔
129	}
130
131	public static String buildStacktrace(ProgramState globalState, Throwable e) {
132	StringBuilder err = new StringBuilder();	1✔
133	try {
134	WPos src = globalState.getLastStatement().attrTrace().attrSource();	1✔
135	err.append("at : ").append(new File(src.getFile()).getName()).append(", line ").append(src.getLine()).append("\n");	1✔
136	} catch (Exception _e) {	×
137	// ignore
138	}	1✔
139	globalState.getStackFrames().appendTo(err);	1✔
140	return err.toString();	1✔
141	}
142
143	@SuppressWarnings("null")
144	private static ILconst adjustTypeOfConstant(@Nullable ILconst retVal, ImType expectedType) {
145	if (retVal instanceof ILconstInt && isTypeReal(expectedType)) {	1✔
146	ILconstInt retValI = (ILconstInt) retVal;	1✔
147	retVal = new ILconstReal(retValI.getVal());	1✔
148	}
149	return retVal;	1✔
150	}
151
152	private static boolean isTypeReal(ImType t) {
153	if (t instanceof ImSimpleType) {	1✔
154	ImSimpleType st = (ImSimpleType) t;	1✔
155	return st.getTypename().equals("real");	1✔
156	}
157	return false;	1✔
158	}
159
160	public static LinkedHashMap<ImFunction, LinkedHashMap<Integer, LocalState>> localStateCache = new LinkedHashMap<>();	1✔
161
162	private static LocalState runBuiltinFunction(ProgramState globalState, ImFunction f, ILconst... args) {
163	if (cache && isFunctionPure(f.getName())) {	1✔
164	int combinedHash = Objects.hash((Object[]) args);	×
165	if (localStateCache.containsKey(f) && localStateCache.get(f).containsKey(combinedHash)) {	×
166	return localStateCache.get(f).get(combinedHash);	×
167	}
168	}
169	StringBuilder errors = new StringBuilder();	1✔
170	for (NativesProvider natives : globalState.getNativeProviders()) {	1✔
171	try {
172	LocalState localState = new LocalState(natives.invoke(f.getName(), args));	1✔
173	if (cache && isFunctionPure(f.getName())) {	1✔
174	int combinedHash = Objects.hash((Object[]) args);	×
175	LinkedHashMap<Integer, LocalState> cached = localStateCache.getOrDefault(f, new LinkedHashMap<>());	×
176	cached.put(combinedHash, localState);	×
177	localStateCache.put(f, cached);	×
178	}
179	return localState;	1✔
180	} catch (NoSuchNativeException e) {	1✔
181	errors.append("\n").append(e.getMessage());	1✔
182	// ignore
183	}
184	}	1✔
185	globalState.compilationError("function " + f.getName() + " cannot be used from the Wurst interpreter.\n" + errors);	×
186	if (f.getReturnType() instanceof ImVoid) {	×
187	return new LocalState();	×
188	}
189	ILconst returnValue = ImHelper.defaultValueForComplexType(f.getReturnType()).evaluate(globalState, new LocalState());	×
190	return new LocalState(returnValue);	×
191	}
192
193	private static boolean isCompiletimeNative(ImFunction f) {
194	if (f.getTrace() instanceof HasModifier) {	1✔
195	HasModifier f2 = (HasModifier) f.getTrace();	1✔
196	for (Modifier m : f2.getModifiers()) {	1✔
197	if (m instanceof Annotation) {	1✔
198	Annotation annotation = (Annotation) m;	1✔
199	if (annotation.getAnnotationType().equals("@compiletimenative")) {	1✔
200	return true;	1✔
201	}
202	}
203	}	1✔
204	}
205	return false;	1✔
206	}
207
208	public LocalState executeFunction(String funcName, @Nullable Element trace) {
209	globalState.resetStackframes();	1✔
210	for (ImFunction f : prog.getFunctions()) {	1✔
211	if (f.getName().equals(funcName)) {	1✔
212	return runFunc(globalState, f, trace);	×
213	}
214	}	1✔
215
216	throw new Error("no function with name " + funcName + "was found.");	×
217	}
218
219	public void runVoidFunc(ImFunction f, @Nullable Element trace) {
220	globalState.resetStackframes();	1✔
221	ILconst[] args = {};	1✔
222	if (!f.getParameters().isEmpty()) {	1✔
223	// this should only happen because of added stacktrace parameter
224	args = new ILconstString[]{new ILconstString("initial call")};	1✔
225	}
226	runFunc(globalState, f, trace, args);	1✔
227	}	1✔
228
229	public Element getLastStatement() {
230	return globalState.getLastStatement();	×
231	}
232
233	public void writebackGlobalState(boolean injectObjects) {
234	globalState.writeBack(injectObjects);	1✔
235
236	}	1✔
237
238	public ProgramState getGlobalState() {
239	return globalState;	1✔
240	}
241
242	public void addNativeProvider(NativesProvider np) {
243	globalState.addNativeProvider(np);	1✔
244	}	1✔
245
246	public void setProgram(ImProg imProg) {
247	this.prog = imProg;	×
248	this.getGlobalState().setProg(imProg);	×
249	globalState.resetStackframes();	×
250	}	×
251
252	public ProgramState.StackTrace getStackFrames() {
253	return globalState.getStackFrames();	×
254
255	}
256
257	@Override
258	public void runFuncRef(ILconstFuncRef obj, @Nullable Element trace) {
259	runVoidFunc(obj.getFunc(), trace);	1✔
260	}	1✔
261
262	@Override
263	public TimerMockHandler getTimerMockHandler() {
264	return timerMockHandler;	1✔
265	}
266
267	@Override
268	public void completeTimers() {
269	timerMockHandler.completeTimers();	1✔
270	}	1✔
271
272	@Override
273	public ImProg getImProg() {
274	return prog;	1✔
275	}
276
277	@Override
278	public int getInstanceCount(int val) {
279	return (int) globalState.getAllObjects()	1✔
280	.stream()	1✔
281	.filter(o -> o.getType().getClassDef().attrTypeId() == val)	1✔
282	.filter(o -> !o.isDestroyed())	1✔
283	.count();	1✔
284	}
285
286	@Override
287	public int getMaxInstanceCount(int val) {
288	return (int) globalState.getAllObjects()	1✔
289	.stream()	1✔
290	.filter(o -> o.getType().getClassDef().attrTypeId() == val)	1✔
291	.count();	1✔
292	}
293	}

wurstscript / WurstScript / 228

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