Skip to content

Commit dedd667

Browse files
QubiluxQubilux
committed
Fix Math.pow(...) issue
1 parent be1972a commit dedd667

File tree

2 files changed

+49
-37
lines changed

2 files changed

+49
-37
lines changed

‎compiler/src/main/java/dev/ultreon/pythonc/JvmWriter.java

Lines changed: 2 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -720,17 +720,8 @@ public void powValues() {
720720
Type right = context.pop();
721721

722722
var mv = pc.mv == null ? pc.rootInitMv : pc.mv;
723-
if (left == Type.INT_TYPE && right == Type.INT_TYPE) {
724-
mv.visitMethodInsn(INVOKESTATIC, "java/lang/Math", "pow", "(II)D", false);
725-
context.push(Type.DOUBLE_TYPE);
726-
} else if (left == Type.LONG_TYPE && right == Type.INT_TYPE) {
727-
mv.visitMethodInsn(INVOKESTATIC, "java/lang/Math", "pow", "(JI)D", false);
728-
context.push(Type.DOUBLE_TYPE);
729-
} else if (left == Type.INT_TYPE && right == Type.LONG_TYPE) {
730-
mv.visitMethodInsn(INVOKESTATIC, "java/lang/Math", "pow", "(JI)D", false);
731-
context.push(Type.DOUBLE_TYPE);
732-
} else if (left == Type.LONG_TYPE && right == Type.LONG_TYPE) {
733-
mv.visitMethodInsn(INVOKESTATIC, "java/lang/Math", "pow", "(JJ)D", false);
723+
if (left == Type.DOUBLE_TYPE && right == Type.DOUBLE_TYPE) {
724+
mv.visitMethodInsn(INVOKESTATIC, "java/lang/Math", "pow", "(DD)D", false);
734725
context.push(Type.DOUBLE_TYPE);
735726
} else {
736727
throw new RuntimeException("Unsupported pow between " + left + " and " + right);

‎compiler/src/main/java/dev/ultreon/pythonc/PyEval.java

Lines changed: 47 additions & 26 deletions
Original file line numberDiff line numberDiff line change
@@ -35,7 +35,7 @@ public Object preload(MethodVisitor mv, PythonCompiler compiler, boolean boxed)
3535
public void load(MethodVisitor mv, PythonCompiler compiler, Object preloaded, boolean boxed) {
3636
switch (finalValue) {
3737
case PyExpr pyExpr -> {
38-
pyExpr.load(mv, compiler, pyExpr.preload(mv, compiler, false), false);
38+
loadValue(mv, compiler, pyExpr);
3939
if (finalAddition != null) {
4040
if (pyExpr.type(compiler) == Type.INT_TYPE) {
4141
Type type = typeOf(finalAddition, compiler);
@@ -50,7 +50,7 @@ public void load(MethodVisitor mv, PythonCompiler compiler, Object preloaded, bo
5050
Type type = typeOf(finalAddition, compiler);
5151
if (type == Type.FLOAT_TYPE) {
5252
compiler.writer.smartCast(Type.DOUBLE_TYPE);
53-
compiler.loadExpr(ctx, finalAddition);
53+
loadAddition(compiler);
5454
compiler.writer.smartCast(Type.DOUBLE_TYPE);
5555
doOperation(mv);
5656
return;
@@ -63,12 +63,12 @@ public void load(MethodVisitor mv, PythonCompiler compiler, Object preloaded, bo
6363
compiler.writer.smartCast(Type.DOUBLE_TYPE);
6464
} else if (type == Type.LONG_TYPE) {
6565
compiler.writer.smartCast(Type.DOUBLE_TYPE);
66-
compiler.loadExpr(ctx, finalAddition);
66+
loadAddition(compiler);
6767
compiler.writer.smartCast(Type.DOUBLE_TYPE);
6868
doOperation(mv);
6969
return;
7070
} else if (type == Type.INT_TYPE) {
71-
compiler.loadExpr(ctx, finalAddition);
71+
loadAddition(compiler);
7272
compiler.writer.smartCast(Type.FLOAT_TYPE);
7373
doOperation(mv);
7474
return;
@@ -78,12 +78,12 @@ public void load(MethodVisitor mv, PythonCompiler compiler, Object preloaded, bo
7878
if (type == Type.LONG_TYPE) {
7979
compiler.writer.smartCast(Type.DOUBLE_TYPE);
8080
} else if (type == Type.INT_TYPE) {
81-
compiler.loadExpr(ctx, finalAddition);
81+
loadAddition(compiler);
8282
compiler.writer.smartCast(Type.DOUBLE_TYPE);
8383
doOperation(mv);
8484
return;
8585
} else if (type == Type.FLOAT_TYPE) {
86-
compiler.loadExpr(ctx, finalAddition);
86+
loadAddition(compiler);
8787
compiler.writer.smartCast(Type.DOUBLE_TYPE);
8888
doOperation(mv);
8989
return;
@@ -94,7 +94,7 @@ public void load(MethodVisitor mv, PythonCompiler compiler, Object preloaded, bo
9494
}
9595
}
9696
case Integer integer -> {
97-
compiler.loadConstant(ctx, integer, mv);
97+
loadConst(mv, compiler, integer);
9898
if (finalAddition != null) {
9999
Type type = typeOf(finalAddition, compiler);
100100
if (type == Type.LONG_TYPE) {
@@ -107,12 +107,12 @@ public void load(MethodVisitor mv, PythonCompiler compiler, Object preloaded, bo
107107
}
108108
}
109109
case Long aLong -> {
110-
compiler.loadConstant(ctx, aLong, mv);
110+
loadConst(mv, compiler, aLong);
111111
if (finalAddition != null) {
112112
Type type = typeOf(finalAddition, compiler);
113113
if (type == Type.FLOAT_TYPE) {
114114
mv.visitInsn(L2D);
115-
compiler.loadExpr(ctx, finalAddition);
115+
loadAddition(compiler);
116116
mv.visitInsn(F2D);
117117
doOperation(mv);
118118
return;
@@ -122,90 +122,90 @@ public void load(MethodVisitor mv, PythonCompiler compiler, Object preloaded, bo
122122
}
123123
}
124124
case Float aFloat -> {
125-
compiler.loadConstant(ctx, aFloat, mv);
125+
loadConst(mv, compiler, aFloat);
126126

127127
if (finalAddition != null) {
128128
Type type = typeOf(finalAddition, compiler);
129129
if (type == Type.DOUBLE_TYPE) {
130130
mv.visitInsn(F2D);
131131
} else if (type == Type.LONG_TYPE) {
132132
mv.visitInsn(F2D);
133-
compiler.loadExpr(ctx, finalAddition);
133+
loadAddition(compiler);
134134
mv.visitInsn(L2D);
135135
doOperation(mv);
136136
return;
137137
} else if (type == Type.INT_TYPE) {
138-
compiler.loadExpr(ctx, finalAddition);
138+
loadAddition(compiler);
139139
mv.visitInsn(I2F);
140140
doOperation(mv);
141141
return;
142142
}
143143
}
144144
}
145145
case Double aDouble -> {
146-
compiler.loadConstant(ctx, aDouble, mv);
146+
loadConst(mv, compiler, aDouble);
147147

148148
if (finalAddition != null) {
149149
Type type = typeOf(finalAddition, compiler);
150150
if (type == Type.LONG_TYPE) {
151-
compiler.loadExpr(ctx, finalAddition);
151+
loadAddition(compiler);
152152
compiler.writer.smartCast(Type.DOUBLE_TYPE);
153153
doOperation(mv);
154154
return;
155155
} else if (type == Type.INT_TYPE) {
156-
compiler.loadExpr(ctx, finalAddition);
156+
loadAddition(compiler);
157157
compiler.writer.smartCast(Type.DOUBLE_TYPE);
158158
doOperation(mv);
159159
return;
160160
} else if (type == Type.FLOAT_TYPE) {
161-
compiler.loadExpr(ctx, finalAddition);
161+
loadAddition(compiler);
162162
compiler.writer.smartCast(Type.DOUBLE_TYPE);
163163
doOperation(mv);
164164
return;
165165
}
166166
}
167167
}
168-
case String s -> compiler.loadConstant(ctx, s, mv);
168+
case String s -> loadConst(mv, compiler, s);
169169
case Boolean aBoolean -> {
170-
compiler.loadConstant(ctx, aBoolean, mv);
170+
loadConst(mv, compiler, aBoolean);
171171

172172
if (finalAddition != null) {
173173
Type type = typeOf(finalAddition, compiler);
174174
if (type == Type.INT_TYPE) {
175-
compiler.loadExpr(ctx, finalAddition);
175+
loadAddition(compiler);
176176
mv.visitInsn(I2F);
177177
doOperation(mv);
178178
return;
179179
} else if (type == Type.LONG_TYPE) {
180-
compiler.loadExpr(ctx, finalAddition);
180+
loadAddition(compiler);
181181
mv.visitInsn(L2D);
182182
doOperation(mv);
183183
return;
184184
} else if (type == Type.FLOAT_TYPE) {
185-
compiler.loadExpr(ctx, finalAddition);
185+
loadAddition(compiler);
186186
mv.visitInsn(F2D);
187187
doOperation(mv);
188188
return;
189189
}
190190
}
191191
}
192192
case Character aChar -> {
193-
compiler.loadConstant(ctx, aChar, mv);
193+
loadConst(mv, compiler, aChar);
194194

195195
if (finalAddition != null) {
196196
Type type = typeOf(finalAddition, compiler);
197197
if (type == Type.INT_TYPE) {
198-
compiler.loadExpr(ctx, finalAddition);
198+
loadAddition(compiler);
199199
mv.visitInsn(I2F);
200200
doOperation(mv);
201201
return;
202202
} else if (type == Type.LONG_TYPE) {
203-
compiler.loadExpr(ctx, finalAddition);
203+
loadAddition(compiler);
204204
mv.visitInsn(L2D);
205205
doOperation(mv);
206206
return;
207207
} else if (type == Type.FLOAT_TYPE) {
208-
compiler.loadExpr(ctx, finalAddition);
208+
loadAddition(compiler);
209209
mv.visitInsn(F2D);
210210
doOperation(mv);
211211
return;
@@ -216,11 +216,32 @@ public void load(MethodVisitor mv, PythonCompiler compiler, Object preloaded, bo
216216
default -> throw new RuntimeException("No supported matching loadExpr found for:\n" + ctx.getText());
217217
}
218218
if (finalAddition != null) {
219-
compiler.loadExpr(ctx, finalAddition);
219+
loadAddition(compiler);
220220
doOperation(mv);
221221
}
222222
}
223223

224+
private void loadConst(MethodVisitor mv, PythonCompiler compiler, Object aChar) {
225+
compiler.loadConstant(ctx, aChar, mv);
226+
if (this.operator == Operator.POW) {
227+
compiler.writer.smartCast(Type.DOUBLE_TYPE);
228+
}
229+
}
230+
231+
private void loadValue(MethodVisitor mv, PythonCompiler compiler, PyExpr pyExpr) {
232+
pyExpr.load(mv, compiler, pyExpr.preload(mv, compiler, false), false);
233+
if (this.operator == Operator.POW) {
234+
compiler.writer.smartCast(Type.DOUBLE_TYPE);
235+
}
236+
}
237+
238+
private void loadAddition(PythonCompiler compiler) {
239+
compiler.loadExpr(ctx, finalAddition);
240+
if (this.operator == Operator.POW) {
241+
compiler.writer.smartCast(Type.DOUBLE_TYPE);
242+
}
243+
}
244+
224245
private void doOperation(MethodVisitor mv) {
225246
if (operator == Operator.ADD) {
226247
compiler.writer.addValues();

0 commit comments

Comments
 (0)