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

67.14

de.peeeq.wurstscript/src/main/java/de/peeeq/wurstscript/translation/imtranslation/ImHelper.java

package de.peeeq.wurstscript.translation.imtranslation;

import de.peeeq.wurstscript.ast.WParameter;
import de.peeeq.wurstscript.ast.WParameters;
import de.peeeq.wurstscript.attributes.CompileError;
import de.peeeq.wurstscript.jassIm.*;
import de.peeeq.wurstscript.utils.Constants;

import java.util.*;

public class ImHelper {

    public static Set<ImFunction> calculateFunctionsOfProg(ImProg prog) {
        Set<ImFunction> allFunctions = new HashSet<>(prog.getFunctions());
        for(ImClass c : prog.getClasses()) {
            allFunctions.addAll(c.getFunctions());
        }
        return allFunctions;
    }

    static void translateParameters(WParameters params, ImVars result, ImTranslator t) {
        for (WParameter p : params) {
            result.add(t.getVarFor(p));
        }
    }

    public static ImType toArray(ImType t) {
        if (t instanceof ImArrayType) {
            // already an array (should never happen?)
            return t;
        } if (t instanceof ImArrayTypeMulti) {
            ImArrayTypeMulti mat = ((ImArrayTypeMulti) t);
            ArrayList<Integer> nsize = new ArrayList<>(mat.getArraySize());
            nsize.add(Constants.MAX_ARRAY_SIZE);
            return JassIm.ImArrayTypeMulti(mat.getEntryType(), nsize);
        } else {
            return JassIm.ImArrayType(t);
        }
    }

    public static void replaceVar(List<ImStmt> stmts, final ImVar oldVar, final ImVar newVar) {
        for (ImStmt s : stmts) {
            replaceVar(s, oldVar, newVar);
        }
    }

    public static void replaceVar(ImStmt s, final ImVar oldVar, final ImVar newVar) {
        s.accept(new VarReplaceVisitor() {

            @Override
            ImVar getReplaceVar(ImVar v) {
                super.visit(v);
                return v == oldVar ? newVar : null;
            }
        });
    }


    public static void replaceVar(ImStmt s, final Map<ImVar, ImVar> substitutions) {
        s.accept(new VarReplaceVisitor() {
            @Override
            ImVar getReplaceVar(ImVar v) {
                super.visit(v);
                return substitutions.get(v);
            }
        });
    }

    public static ImNull nullExpr() {
        return JassIm.ImNull(JassIm.ImVoid());
    }

    public static ImStatementExpr statementExprVoid(ImStmts stmts) {
        return JassIm.ImStatementExpr(stmts, nullExpr());
    }

    public static ImStatementExpr statementExprVoid(ImStmt... stmts) {
        return ImHelper.statementExprVoid(JassIm.ImStmts(stmts));
    }



    abstract static class VarReplaceVisitor extends ImStmt.DefaultVisitor {
        abstract ImVar getReplaceVar(ImVar v);

        @Override
        public void visit(ImVarArrayAccess e) {
            super.visit(e);
            ImVar newVar = getReplaceVar(e.getVar());
            if (newVar != null) {
                e.setVar(newVar);
            }

        }


        @Override
        public void visit(ImVarAccess e) {
            super.visit(e);
            ImVar newVar = getReplaceVar(e.getVar());
            if (newVar != null) {
                e.setVar(newVar);
            }
        }
    }

    public static void replaceElem(Element oldElem, Element newElement) {
        Element parent = oldElem.getParent();
        if (parent == null) throw new Error("Element has no parent: " + oldElem);
        for (int i = 0; i < parent.size(); i++) {
            if (parent.get(i) == oldElem) {
                parent.set(i, newElement);
                return;
            }
        }
        throw new Error("Element " + oldElem + " not found in parent. This should never happen ;)");
    }

    public static ImExpr defaultValueForType(ImSimpleType t) {
        String type = t.getTypename();
        switch (type) {
            case "integer":
                return JassIm.ImIntVal(0);
            case "boolean":
                return JassIm.ImBoolVal(false);
            case "real":
                return JassIm.ImRealVal("0.");
            default:
                return JassIm.ImNull(t);
        }
    }

    public static ImExpr defaultValueForComplexType(ImType t) {
        return t.match(new ImType.Matcher<ImExpr>() {
            @Override
            public ImExpr case_ImArrayTypeMulti(ImArrayTypeMulti imArrayTypeMulti) {
                throw new CompileError(t, "Cannot find default value for type " + t);
            }

            @Override
            public ImExpr case_ImAnyType(ImAnyType at) {
                return JassIm.ImNull(at);
            }

            @Override
            public ImExpr case_ImTupleType(ImTupleType tt) {
                ImExprs res = JassIm.ImExprs();
                for (ImType it : tt.getTypes()) {
                    res.add(defaultValueForComplexType(it));
                }
                return JassIm.ImTupleExpr(res);
            }

            @Override
            public ImExpr case_ImArrayType(ImArrayType imArrayType) {
                throw new CompileError(t, "Cannot find default value for type " + t);
            }

            @Override
            public ImExpr case_ImTypeVarRef(ImTypeVarRef imTypeVarRef) {
                throw new CompileError(t, "Cannot find default value for type " + t);
            }

            @Override
            public ImExpr case_ImVoid(ImVoid imVoid) {
                throw new CompileError(t, "Cannot find default value for type " + t);
            }

            @Override
            public ImExpr case_ImClassType(ImClassType imClassType) {
                return JassIm.ImIntVal(0);
            }

            @Override
            public ImExpr case_ImSimpleType(ImSimpleType st) {
                return defaultValueForType(st);
            }
        });
    }


}

1	package de.peeeq.wurstscript.translation.imtranslation;
2
3	import de.peeeq.wurstscript.ast.WParameter;
4	import de.peeeq.wurstscript.ast.WParameters;
5	import de.peeeq.wurstscript.attributes.CompileError;
6	import de.peeeq.wurstscript.jassIm.*;
7	import de.peeeq.wurstscript.utils.Constants;
8
9	import java.util.*;
10
11	public class ImHelper {	×
12
13	public static Set<ImFunction> calculateFunctionsOfProg(ImProg prog) {
14	Set<ImFunction> allFunctions = new HashSet<>(prog.getFunctions());	1✔
15	for(ImClass c : prog.getClasses()) {	1✔
16	allFunctions.addAll(c.getFunctions());	1✔
17	}	1✔
18	return allFunctions;	1✔
19	}
20
21	static void translateParameters(WParameters params, ImVars result, ImTranslator t) {
22	for (WParameter p : params) {	1✔
23	result.add(t.getVarFor(p));	1✔
24	}	1✔
25	}	1✔
26
27	public static ImType toArray(ImType t) {
28	if (t instanceof ImArrayType) {	1✔
29	// already an array (should never happen?)
30	return t;	×
31	} if (t instanceof ImArrayTypeMulti) {	1✔
32	ImArrayTypeMulti mat = ((ImArrayTypeMulti) t);	1✔
33	ArrayList<Integer> nsize = new ArrayList<>(mat.getArraySize());	1✔
34	nsize.add(Constants.MAX_ARRAY_SIZE);	1✔
35	return JassIm.ImArrayTypeMulti(mat.getEntryType(), nsize);	1✔
36	} else {
37	return JassIm.ImArrayType(t);	1✔
38	}
39	}
40
41	public static void replaceVar(List<ImStmt> stmts, final ImVar oldVar, final ImVar newVar) {
42	for (ImStmt s : stmts) {	×
43	replaceVar(s, oldVar, newVar);	×
44	}	×
45	}	×
46
47	public static void replaceVar(ImStmt s, final ImVar oldVar, final ImVar newVar) {
48	s.accept(new VarReplaceVisitor() {	×
49
50	@Override
51	ImVar getReplaceVar(ImVar v) {
52	super.visit(v);	×
53	return v == oldVar ? newVar : null;	×
54	}
55	});
56	}	×
57
58
59	public static void replaceVar(ImStmt s, final Map<ImVar, ImVar> substitutions) {
60	s.accept(new VarReplaceVisitor() {	1✔
61	@Override
62	ImVar getReplaceVar(ImVar v) {
63	super.visit(v);	1✔
64	return substitutions.get(v);	1✔
65	}
66	});
67	}	1✔
68
69	public static ImNull nullExpr() {
70	return JassIm.ImNull(JassIm.ImVoid());	1✔
71	}
72
73	public static ImStatementExpr statementExprVoid(ImStmts stmts) {
74	return JassIm.ImStatementExpr(stmts, nullExpr());	1✔
75	}
76
77	public static ImStatementExpr statementExprVoid(ImStmt... stmts) {
78	return ImHelper.statementExprVoid(JassIm.ImStmts(stmts));	×
79	}
80
81
82
83	abstract static class VarReplaceVisitor extends ImStmt.DefaultVisitor {	1✔
84	abstract ImVar getReplaceVar(ImVar v);
85
86	@Override
87	public void visit(ImVarArrayAccess e) {
88	super.visit(e);	1✔
89	ImVar newVar = getReplaceVar(e.getVar());	1✔
90	if (newVar != null) {	1✔
91	e.setVar(newVar);	1✔
92	}
93
94	}	1✔
95
96
97	@Override
98	public void visit(ImVarAccess e) {
99	super.visit(e);	1✔
100	ImVar newVar = getReplaceVar(e.getVar());	1✔
101	if (newVar != null) {	1✔
102	e.setVar(newVar);	1✔
103	}
104	}	1✔
105	}
106
107	public static void replaceElem(Element oldElem, Element newElement) {
108	Element parent = oldElem.getParent();	×
109	if (parent == null) throw new Error("Element has no parent: " + oldElem);	×
110	for (int i = 0; i < parent.size(); i++) {	×
111	if (parent.get(i) == oldElem) {	×
112	parent.set(i, newElement);	×
113	return;	×
114	}
115	}
116	throw new Error("Element " + oldElem + " not found in parent. This should never happen ;)");	×
117	}
118
119	public static ImExpr defaultValueForType(ImSimpleType t) {
120	String type = t.getTypename();	1✔
121	switch (type) {	1✔
122	case "integer":
123	return JassIm.ImIntVal(0);	1✔
124	case "boolean":
125	return JassIm.ImBoolVal(false);	1✔
126	case "real":
127	return JassIm.ImRealVal("0.");	1✔
128	default:
129	return JassIm.ImNull(t);	1✔
130	}
131	}
132
133	public static ImExpr defaultValueForComplexType(ImType t) {
134	return t.match(new ImType.Matcher<ImExpr>() {	1✔
135	@Override
136	public ImExpr case_ImArrayTypeMulti(ImArrayTypeMulti imArrayTypeMulti) {
137	throw new CompileError(t, "Cannot find default value for type " + t);	×
138	}
139
140	@Override
141	public ImExpr case_ImAnyType(ImAnyType at) {
142	return JassIm.ImNull(at);	1✔
143	}
144
145	@Override
146	public ImExpr case_ImTupleType(ImTupleType tt) {
147	ImExprs res = JassIm.ImExprs();	1✔
148	for (ImType it : tt.getTypes()) {	1✔
149	res.add(defaultValueForComplexType(it));	1✔
150	}	1✔
151	return JassIm.ImTupleExpr(res);	1✔
152	}
153
154	@Override
155	public ImExpr case_ImArrayType(ImArrayType imArrayType) {
156	throw new CompileError(t, "Cannot find default value for type " + t);	×
157	}
158
159	@Override
160	public ImExpr case_ImTypeVarRef(ImTypeVarRef imTypeVarRef) {
161	throw new CompileError(t, "Cannot find default value for type " + t);	×
162	}
163
164	@Override
165	public ImExpr case_ImVoid(ImVoid imVoid) {
166	throw new CompileError(t, "Cannot find default value for type " + t);	×
167	}
168
169	@Override
170	public ImExpr case_ImClassType(ImClassType imClassType) {
171	return JassIm.ImIntVal(0);	×
172	}
173
174	@Override
175	public ImExpr case_ImSimpleType(ImSimpleType st) {
176	return defaultValueForType(st);	1✔
177	}
178	});
179	}
180
181
182	}

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