hg/bck2brwsr: vm/src/main/java/org/apidesign/vm4brwsr/ByteCodeToJavaScript.java@5134b17d623c (annotated)

jaroslav@106	1	/**
jaroslav@106	2	* Back 2 Browser Bytecode Translator
jaroslav@106	3	* Copyright (C) 2012 Jaroslav Tulach <jaroslav.tulach@apidesign.org>
jaroslav@106	4	*
jaroslav@106	5	* This program is free software: you can redistribute it and/or modify
jaroslav@106	6	* it under the terms of the GNU General Public License as published by
jaroslav@106	7	* the Free Software Foundation, version 2 of the License.
jaroslav@106	8	*
jaroslav@106	9	* This program is distributed in the hope that it will be useful,
jaroslav@106	10	* but WITHOUT ANY WARRANTY; without even the implied warranty of
jaroslav@106	11	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
jaroslav@106	12	* GNU General Public License for more details.
jaroslav@106	13	*
jaroslav@106	14	* You should have received a copy of the GNU General Public License
jaroslav@106	15	* along with this program. Look for COPYING file in the top folder.
jaroslav@106	16	* If not, see http://opensource.org/licenses/GPL-2.0.
jaroslav@106	17	*/
jaroslav@22	18	package org.apidesign.vm4brwsr;
jaroslav@0	19
jaroslav@0	20	import java.io.IOException;
jaroslav@0	21	import java.io.InputStream;
jaroslav@21	22	import java.util.ArrayList;
jaroslav@18	23	import java.util.Collection;
jaroslav@0	24	import java.util.List;
jaroslav@91	25	import org.apidesign.bck2brwsr.core.ExtraJavaScript;
jaroslav@94	26	import org.apidesign.bck2brwsr.core.JavaScriptBody;
jaroslav@91	27	import org.netbeans.modules.classfile.Annotation;
jaroslav@91	28	import org.netbeans.modules.classfile.AnnotationComponent;
jaroslav@94	29	import org.netbeans.modules.classfile.ArrayElementValue;
jaroslav@2	30	import static org.netbeans.modules.classfile.ByteCodes.*;
jaroslav@8	31	import org.netbeans.modules.classfile.CPClassInfo;
jaroslav@8	32	import org.netbeans.modules.classfile.CPEntry;
jaroslav@8	33	import org.netbeans.modules.classfile.CPFieldInfo;
jaroslav@4	34	import org.netbeans.modules.classfile.CPMethodInfo;
jaroslav@21	35	import org.netbeans.modules.classfile.CPStringInfo;
jaroslav@0	36	import org.netbeans.modules.classfile.ClassFile;
jaroslav@13	37	import org.netbeans.modules.classfile.ClassName;
jaroslav@0	38	import org.netbeans.modules.classfile.Code;
jaroslav@91	39	import org.netbeans.modules.classfile.ElementValue;
jaroslav@0	40	import org.netbeans.modules.classfile.Method;
jaroslav@0	41	import org.netbeans.modules.classfile.Parameter;
jaroslav@91	42	import org.netbeans.modules.classfile.PrimitiveElementValue;
jaroslav@9	43	import org.netbeans.modules.classfile.Variable;
jaroslav@0	44
jaroslav@0	45	/** Translator of the code inside class files to JavaScript.
jaroslav@0	46	*
jaroslav@0	47	* @author Jaroslav Tulach <jtulach@netbeans.org>
jaroslav@0	48	*/
jaroslav@0	49	public final class ByteCodeToJavaScript {
jaroslav@0	50	private final ClassFile jc;
jaroslav@0	51	private final Appendable out;
jaroslav@18	52	private final Collection<? super String> references;
jaroslav@0	53
jaroslav@18	54	private ByteCodeToJavaScript(
jaroslav@18	55	ClassFile jc, Appendable out, Collection<? super String> references
jaroslav@18	56	) {
jaroslav@0	57	this.jc = jc;
jaroslav@0	58	this.out = out;
jaroslav@18	59	this.references = references;
jaroslav@0	60	}
jaroslav@18	61
jaroslav@18	62	/**
jaroslav@18	63	* Converts a given class file to a JavaScript version.
jaroslav@18	64	*
jaroslav@0	65	* @param classFile input stream with code of the .class file
jaroslav@0	66	* @param out a {@link StringBuilder} or similar to generate the output to
jaroslav@18	67	* @param references a write only collection where the system adds list of
jaroslav@18	68	* other classes that were referenced and should be loaded in order the
jaroslav@18	69	* generated JavaScript code works properly. The names are in internal
jaroslav@18	70	* JVM form so String is <code>java/lang/String</code>. Can be <code>null</code>
jaroslav@18	71	* if one is not interested in knowing references
jaroslav@91	72	* @param scripts write only collection with names of resources to read
jaroslav@97	73	* @return the initialization code for this class, if any. Otherwise <code>null</code>
jaroslav@91	74	*
jaroslav@0	75	* @throws IOException if something goes wrong during read or write or translating
jaroslav@0	76	*/
jaroslav@18	77
jaroslav@97	78	public static String compile(
jaroslav@18	79	InputStream classFile, Appendable out,
jaroslav@91	80	Collection<? super String> references,
jaroslav@91	81	Collection<? super String> scripts
jaroslav@18	82	) throws IOException {
jaroslav@0	83	ClassFile jc = new ClassFile(classFile, true);
jaroslav@91	84	final ClassName extraAnn = ClassName.getClassName(ExtraJavaScript.class.getName().replace('.', '/'));
jaroslav@91	85	Annotation a = jc.getAnnotation(extraAnn);
jaroslav@91	86	if (a != null) {
jaroslav@91	87	final ElementValue annVal = a.getComponent("resource").getValue();
jaroslav@91	88	String res = ((PrimitiveElementValue)annVal).getValue().getValue().toString();
jaroslav@91	89	scripts.add(res);
jaroslav@91	90	final AnnotationComponent process = a.getComponent("processByteCode");
jaroslav@93	91	if (process != null && "const=0".equals(process.getValue().toString())) {
jaroslav@97	92	return null;
jaroslav@91	93	}
jaroslav@91	94	}
jaroslav@91	95
jaroslav@18	96	ByteCodeToJavaScript compiler = new ByteCodeToJavaScript(
jaroslav@18	97	jc, out, references
jaroslav@18	98	);
jaroslav@21	99	List<String> toInitilize = new ArrayList<String>();
jaroslav@0	100	for (Method m : jc.getMethods()) {
jaroslav@0	101	if (m.isStatic()) {
jaroslav@21	102	compiler.generateStaticMethod(m, toInitilize);
jaroslav@10	103	} else {
jaroslav@10	104	compiler.generateInstanceMethod(m);
jaroslav@0	105	}
jaroslav@0	106	}
jaroslav@9	107	for (Variable v : jc.getVariables()) {
jaroslav@9	108	if (v.isStatic()) {
jaroslav@9	109	compiler.generateStaticField(v);
jaroslav@9	110	}
jaroslav@9	111	}
jaroslav@10	112
jaroslav@18	113	final String className = jc.getName().getInternalName().replace('/', '_');
jaroslav@13	114	out.append("\nfunction ").append(className);
jaroslav@10	115	out.append("() {");
jaroslav@10	116	for (Variable v : jc.getVariables()) {
jaroslav@10	117	if (!v.isStatic()) {
jaroslav@10	118	out.append("\n this." + v.getName() + " = 0;");
jaroslav@10	119	}
jaroslav@10	120	}
jaroslav@98	121	out.append("\n}\n\nfunction ").append(className).append("_proto() {");
jaroslav@98	122	out.append("\n if (").append(className).
jaroslav@98	123	append(".prototype.$instOf_").append(className).append(") {");
jaroslav@98	124	out.append("\n return ").append(className).append(".prototype;");
jaroslav@98	125	out.append("\n }");
jaroslav@13	126	ClassName sc = jc.getSuperClass();
jaroslav@13	127	if (sc != null) {
jaroslav@98	128	out.append("\n ").append(sc.getInternalName().replace('/', '_')).append("_proto();");
jaroslav@98	129	out.append("\n ").append(className)
jaroslav@39	130	.append(".prototype = new ").append(sc.getInternalName().replace('/', '_')).append(';');
jaroslav@13	131	}
jaroslav@38	132	for (Method m : jc.getMethods()) {
jaroslav@102	133	if (!m.getName().contains("<init>") && !m.getName().contains("<cinit>")) {
jaroslav@98	134	compiler.generateMethodReference("\n " + className + ".prototype.", m);
jaroslav@38	135	}
jaroslav@38	136	}
jaroslav@98	137	out.append("\n " + className + ".prototype.$instOf_").append(className).append(" = true;");
jaroslav@40	138	for (ClassName superInterface : jc.getInterfaces()) {
jaroslav@98	139	out.append("\n " + className + ".prototype.$instOf_").append(superInterface.getInternalName().replace('/', '_')).append(" = true;");
jaroslav@40	140	}
jaroslav@98	141	out.append("\n return ").append(className).append(".prototype;");
jaroslav@98	142	out.append("\n}");
jaroslav@98	143	out.append("\n").append(className).append("_proto();");
jaroslav@97	144	StringBuilder sb = new StringBuilder();
jaroslav@21	145	for (String init : toInitilize) {
jaroslav@97	146	sb.append("\n").append(init).append("();");
jaroslav@21	147	}
jaroslav@97	148	return sb.toString();
jaroslav@0	149	}
jaroslav@21	150	private void generateStaticMethod(Method m, List<String> toInitilize) throws IOException {
jaroslav@94	151	if (javaScriptBody(m, true)) {
jaroslav@94	152	return;
jaroslav@94	153	}
jaroslav@21	154	final String mn = findMethodName(m);
jaroslav@1	155	out.append("\nfunction ").append(
jaroslav@18	156	jc.getName().getInternalName().replace('/', '_')
jaroslav@21	157	).append('_').append(mn);
jaroslav@21	158	if (mn.equals("classV")) {
jaroslav@21	159	toInitilize.add(jc.getName().getInternalName().replace('/', '_') + '_' + mn);
jaroslav@21	160	}
jaroslav@0	161	out.append('(');
jaroslav@0	162	String space = "";
jaroslav@10	163	List<Parameter> args = m.getParameters();
jaroslav@2	164	for (int index = 0, i = 0; i < args.size(); i++) {
jaroslav@0	165	out.append(space);
jaroslav@2	166	out.append("arg").append(String.valueOf(index));
jaroslav@0	167	space = ",";
jaroslav@32	168	final String desc = findDescriptor(args.get(i).getDescriptor());
jaroslav@3	169	if ("D".equals(desc) \|\| "J".equals(desc)) {
jaroslav@2	170	index += 2;
jaroslav@2	171	} else {
jaroslav@2	172	index++;
jaroslav@2	173	}
jaroslav@0	174	}
jaroslav@5	175	out.append(") {").append("\n");
jaroslav@0	176	final Code code = m.getCode();
jaroslav@18	177	if (code != null) {
jaroslav@18	178	int len = code.getMaxLocals();
jaroslav@18	179	for (int index = args.size(), i = args.size(); i < len; i++) {
jaroslav@18	180	out.append(" var ");
jaroslav@18	181	out.append("arg").append(String.valueOf(i)).append(";\n");
jaroslav@18	182	}
jaroslav@21	183	out.append(" var stack = new Array();\n");
jaroslav@18	184	produceCode(code.getByteCodes());
jaroslav@18	185	} else {
jaroslav@18	186	out.append(" /* no code found for ").append(m.getTypeSignature()).append(" */\n");
jaroslav@0	187	}
jaroslav@10	188	out.append("}");
jaroslav@10	189	}
jaroslav@10	190
jaroslav@38	191	private void generateMethodReference(String prefix, Method m) throws IOException {
jaroslav@12	192	final String name = findMethodName(m);
jaroslav@38	193	out.append(prefix).append(name).append(" = ")
jaroslav@18	194	.append(jc.getName().getInternalName().replace('/', '_'))
jaroslav@12	195	.append('_').append(name).append(";");
jaroslav@12	196	}
jaroslav@12	197
jaroslav@10	198	private void generateInstanceMethod(Method m) throws IOException {
jaroslav@94	199	if (javaScriptBody(m, false)) {
jaroslav@94	200	return;
jaroslav@94	201	}
jaroslav@10	202	out.append("\nfunction ").append(
jaroslav@18	203	jc.getName().getInternalName().replace('/', '_')
jaroslav@10	204	).append('_').append(findMethodName(m));
jaroslav@10	205	out.append("(arg0");
jaroslav@10	206	String space = ",";
jaroslav@10	207	List<Parameter> args = m.getParameters();
jaroslav@10	208	for (int index = 1, i = 0; i < args.size(); i++) {
jaroslav@10	209	out.append(space);
jaroslav@10	210	out.append("arg").append(String.valueOf(index));
jaroslav@32	211	final String desc = findDescriptor(args.get(i).getDescriptor());
jaroslav@10	212	if ("D".equals(desc) \|\| "J".equals(desc)) {
jaroslav@10	213	index += 2;
jaroslav@10	214	} else {
jaroslav@10	215	index++;
jaroslav@10	216	}
jaroslav@10	217	}
jaroslav@10	218	out.append(") {").append("\n");
jaroslav@10	219	final Code code = m.getCode();
jaroslav@18	220	if (code != null) {
jaroslav@18	221	int len = code.getMaxLocals();
jaroslav@18	222	for (int index = args.size(), i = args.size(); i < len; i++) {
jaroslav@18	223	out.append(" var ");
jaroslav@18	224	out.append("arg").append(String.valueOf(i + 1)).append(";\n");
jaroslav@18	225	}
jaroslav@96	226	out.append(";\n var stack = new Array();\n");
jaroslav@18	227	produceCode(code.getByteCodes());
jaroslav@18	228	} else {
jaroslav@18	229	out.append(" /* no code found for ").append(m.getTypeSignature()).append(" */\n");
jaroslav@10	230	}
jaroslav@0	231	out.append("}");
jaroslav@0	232	}
jaroslav@0	233
jaroslav@0	234	private void produceCode(byte[] byteCodes) throws IOException {
jaroslav@10	235	out.append("\n var gt = 0;\n for(;;) switch(gt) {\n");
jaroslav@0	236	for (int i = 0; i < byteCodes.length; i++) {
jaroslav@0	237	int prev = i;
jaroslav@10	238	out.append(" case " + i).append(": ");
jaroslav@0	239	final int c = (byteCodes[i] + 256) % 256;
jaroslav@0	240	switch (c) {
jaroslav@2	241	case bc_aload_0:
jaroslav@2	242	case bc_iload_0:
jaroslav@2	243	case bc_lload_0:
jaroslav@2	244	case bc_fload_0:
jaroslav@2	245	case bc_dload_0:
jaroslav@0	246	out.append("stack.push(arg0);");
jaroslav@0	247	break;
jaroslav@2	248	case bc_aload_1:
jaroslav@2	249	case bc_iload_1:
jaroslav@2	250	case bc_lload_1:
jaroslav@2	251	case bc_fload_1:
jaroslav@2	252	case bc_dload_1:
jaroslav@0	253	out.append("stack.push(arg1);");
jaroslav@0	254	break;
jaroslav@2	255	case bc_aload_2:
jaroslav@2	256	case bc_iload_2:
jaroslav@2	257	case bc_lload_2:
jaroslav@2	258	case bc_fload_2:
jaroslav@2	259	case bc_dload_2:
jaroslav@2	260	out.append("stack.push(arg2);");
jaroslav@2	261	break;
jaroslav@3	262	case bc_aload_3:
jaroslav@3	263	case bc_iload_3:
jaroslav@3	264	case bc_lload_3:
jaroslav@3	265	case bc_fload_3:
jaroslav@3	266	case bc_dload_3:
jaroslav@3	267	out.append("stack.push(arg3);");
jaroslav@3	268	break;
jaroslav@3	269	case bc_iload:
jaroslav@3	270	case bc_lload:
jaroslav@3	271	case bc_fload:
jaroslav@3	272	case bc_dload:
jaroslav@3	273	case bc_aload: {
jaroslav@3	274	final int indx = (byteCodes[++i] + 256) % 256;
jaroslav@3	275	out.append("stack.push(arg").append(indx + ");");
jaroslav@3	276	break;
jaroslav@3	277	}
jaroslav@31	278	case bc_istore:
jaroslav@31	279	case bc_lstore:
jaroslav@31	280	case bc_fstore:
jaroslav@31	281	case bc_dstore:
jaroslav@31	282	case bc_astore: {
jaroslav@31	283	final int indx = (byteCodes[++i] + 256) % 256;
jaroslav@31	284	out.append("arg" + indx).append(" = stack.pop()");
jaroslav@31	285	break;
jaroslav@31	286	}
jaroslav@8	287	case bc_astore_0:
jaroslav@5	288	case bc_istore_0:
jaroslav@5	289	case bc_lstore_0:
jaroslav@5	290	case bc_fstore_0:
jaroslav@5	291	case bc_dstore_0:
jaroslav@5	292	out.append("arg0 = stack.pop();");
jaroslav@5	293	break;
jaroslav@8	294	case bc_astore_1:
jaroslav@5	295	case bc_istore_1:
jaroslav@5	296	case bc_lstore_1:
jaroslav@5	297	case bc_fstore_1:
jaroslav@5	298	case bc_dstore_1:
jaroslav@5	299	out.append("arg1 = stack.pop();");
jaroslav@5	300	break;
jaroslav@8	301	case bc_astore_2:
jaroslav@5	302	case bc_istore_2:
jaroslav@5	303	case bc_lstore_2:
jaroslav@5	304	case bc_fstore_2:
jaroslav@5	305	case bc_dstore_2:
jaroslav@5	306	out.append("arg2 = stack.pop();");
jaroslav@5	307	break;
jaroslav@8	308	case bc_astore_3:
jaroslav@5	309	case bc_istore_3:
jaroslav@5	310	case bc_lstore_3:
jaroslav@5	311	case bc_fstore_3:
jaroslav@5	312	case bc_dstore_3:
jaroslav@5	313	out.append("arg3 = stack.pop();");
jaroslav@5	314	break;
jaroslav@2	315	case bc_iadd:
jaroslav@2	316	case bc_ladd:
jaroslav@2	317	case bc_fadd:
jaroslav@2	318	case bc_dadd:
jaroslav@0	319	out.append("stack.push(stack.pop() + stack.pop());");
jaroslav@0	320	break;
jaroslav@2	321	case bc_isub:
jaroslav@2	322	case bc_lsub:
jaroslav@2	323	case bc_fsub:
jaroslav@2	324	case bc_dsub:
jaroslav@3	325	out.append("{ var tmp = stack.pop(); stack.push(stack.pop() - tmp); }");
jaroslav@2	326	break;
jaroslav@2	327	case bc_imul:
jaroslav@2	328	case bc_lmul:
jaroslav@2	329	case bc_fmul:
jaroslav@2	330	case bc_dmul:
jaroslav@1	331	out.append("stack.push(stack.pop() * stack.pop());");
jaroslav@1	332	break;
jaroslav@3	333	case bc_idiv:
jaroslav@3	334	case bc_ldiv:
jaroslav@3	335	out.append("{ var tmp = stack.pop(); stack.push(Math.floor(stack.pop() / tmp)); }");
jaroslav@3	336	break;
jaroslav@3	337	case bc_fdiv:
jaroslav@3	338	case bc_ddiv:
jaroslav@3	339	out.append("{ var tmp = stack.pop(); stack.push(stack.pop() / tmp); }");
jaroslav@3	340	break;
jaroslav@7	341	case bc_iand:
jaroslav@7	342	case bc_land:
jaroslav@7	343	out.append("stack.push(stack.pop() & stack.pop());");
jaroslav@7	344	break;
jaroslav@7	345	case bc_ior:
jaroslav@7	346	case bc_lor:
jaroslav@7	347	out.append("stack.push(stack.pop() \| stack.pop());");
jaroslav@7	348	break;
jaroslav@6	349	case bc_ixor:
jaroslav@6	350	case bc_lxor:
jaroslav@6	351	out.append("stack.push(stack.pop() ^ stack.pop());");
jaroslav@6	352	break;
jaroslav@93	353	case bc_ineg:
jaroslav@93	354	case bc_lneg:
jaroslav@93	355	case bc_fneg:
jaroslav@93	356	case bc_dneg:
jaroslav@93	357	out.append("stack.push(- stack.pop());");
jaroslav@93	358	break;
jaroslav@93	359	case bc_ishl:
jaroslav@93	360	case bc_lshl:
jaroslav@93	361	out.append("{ var v = stack.pop(); stack.push(stack.pop() << v); }");
jaroslav@93	362	break;
jaroslav@93	363	case bc_ishr:
jaroslav@93	364	case bc_lshr:
jaroslav@93	365	out.append("{ var v = stack.pop(); stack.push(stack.pop() >> v); }");
jaroslav@93	366	break;
jaroslav@93	367	case bc_iushr:
jaroslav@93	368	case bc_lushr:
jaroslav@93	369	out.append("{ var v = stack.pop(); stack.push(stack.pop() >>> v); }");
jaroslav@93	370	break;
jaroslav@5	371	case bc_iinc: {
jaroslav@5	372	final int varIndx = (byteCodes[++i] + 256) % 256;
jaroslav@104	373	final int incrBy = byteCodes[++i];
jaroslav@5	374	if (incrBy == 1) {
jaroslav@5	375	out.append("arg" + varIndx).append("++;");
jaroslav@5	376	} else {
jaroslav@5	377	out.append("arg" + varIndx).append(" += " + incrBy).append(";");
jaroslav@5	378	}
jaroslav@5	379	break;
jaroslav@5	380	}
jaroslav@10	381	case bc_return:
jaroslav@10	382	out.append("return;");
jaroslav@10	383	break;
jaroslav@2	384	case bc_ireturn:
jaroslav@2	385	case bc_lreturn:
jaroslav@2	386	case bc_freturn:
jaroslav@2	387	case bc_dreturn:
jaroslav@10	388	case bc_areturn:
jaroslav@0	389	out.append("return stack.pop();");
jaroslav@1	390	break;
jaroslav@2	391	case bc_i2l:
jaroslav@2	392	case bc_i2f:
jaroslav@2	393	case bc_i2d:
jaroslav@2	394	case bc_l2i:
jaroslav@3	395	// max int check?
jaroslav@2	396	case bc_l2f:
jaroslav@2	397	case bc_l2d:
jaroslav@3	398	case bc_f2d:
jaroslav@3	399	case bc_d2f:
jaroslav@3	400	out.append("/* number conversion */");
jaroslav@3	401	break;
jaroslav@2	402	case bc_f2i:
jaroslav@2	403	case bc_f2l:
jaroslav@2	404	case bc_d2i:
jaroslav@2	405	case bc_d2l:
jaroslav@3	406	out.append("stack.push(Math.floor(stack.pop()));");
jaroslav@3	407	break;
jaroslav@2	408	case bc_i2b:
jaroslav@2	409	case bc_i2c:
jaroslav@2	410	case bc_i2s:
jaroslav@2	411	out.append("/* number conversion */");
jaroslav@2	412	break;
jaroslav@46	413	case bc_aconst_null:
jaroslav@46	414	out.append("stack.push(null);");
jaroslav@46	415	break;
jaroslav@48	416	case bc_iconst_m1:
jaroslav@48	417	out.append("stack.push(-1);");
jaroslav@48	418	break;
jaroslav@4	419	case bc_iconst_0:
jaroslav@4	420	case bc_dconst_0:
jaroslav@4	421	case bc_lconst_0:
jaroslav@4	422	case bc_fconst_0:
jaroslav@4	423	out.append("stack.push(0);");
jaroslav@4	424	break;
jaroslav@4	425	case bc_iconst_1:
jaroslav@4	426	case bc_lconst_1:
jaroslav@4	427	case bc_fconst_1:
jaroslav@4	428	case bc_dconst_1:
jaroslav@4	429	out.append("stack.push(1);");
jaroslav@4	430	break;
jaroslav@4	431	case bc_iconst_2:
jaroslav@4	432	case bc_fconst_2:
jaroslav@4	433	out.append("stack.push(2);");
jaroslav@4	434	break;
jaroslav@4	435	case bc_iconst_3:
jaroslav@4	436	out.append("stack.push(3);");
jaroslav@4	437	break;
jaroslav@4	438	case bc_iconst_4:
jaroslav@4	439	out.append("stack.push(4);");
jaroslav@4	440	break;
jaroslav@4	441	case bc_iconst_5:
jaroslav@4	442	out.append("stack.push(5);");
jaroslav@4	443	break;
jaroslav@20	444	case bc_ldc: {
jaroslav@21	445	int indx = byteCodes[++i];
jaroslav@20	446	CPEntry entry = jc.getConstantPool().get(indx);
jaroslav@21	447	String v = encodeConstant(entry);
jaroslav@21	448	out.append("stack.push(").append(v).append(");");
jaroslav@20	449	break;
jaroslav@20	450	}
jaroslav@8	451	case bc_ldc_w:
jaroslav@8	452	case bc_ldc2_w: {
jaroslav@8	453	int indx = readIntArg(byteCodes, i);
jaroslav@8	454	CPEntry entry = jc.getConstantPool().get(indx);
jaroslav@8	455	i += 2;
jaroslav@21	456	String v = encodeConstant(entry);
jaroslav@21	457	out.append("stack.push(").append(v).append(");");
jaroslav@8	458	break;
jaroslav@8	459	}
jaroslav@20	460	case bc_lcmp:
jaroslav@20	461	case bc_fcmpl:
jaroslav@20	462	case bc_fcmpg:
jaroslav@20	463	case bc_dcmpl:
jaroslav@20	464	case bc_dcmpg: {
jaroslav@20	465	out.append("{ var delta = stack.pop() - stack.pop(); stack.push(delta < 0 ?-1 : (delta == 0 ? 0 : 1)); }");
jaroslav@20	466	break;
jaroslav@20	467	}
jaroslav@104	468	case bc_if_acmpeq:
jaroslav@104	469	i = generateIf(byteCodes, i, "===");
jaroslav@104	470	break;
jaroslav@104	471	case bc_if_acmpne:
jaroslav@104	472	i = generateIf(byteCodes, i, "!=");
jaroslav@104	473	break;
jaroslav@4	474	case bc_if_icmpeq: {
jaroslav@4	475	i = generateIf(byteCodes, i, "==");
jaroslav@4	476	break;
jaroslav@4	477	}
jaroslav@7	478	case bc_ifeq: {
jaroslav@7	479	int indx = i + readIntArg(byteCodes, i);
jaroslav@7	480	out.append("if (stack.pop() == 0) { gt = " + indx);
jaroslav@7	481	out.append("; continue; }");
jaroslav@7	482	i += 2;
jaroslav@7	483	break;
jaroslav@7	484	}
jaroslav@20	485	case bc_ifne: {
jaroslav@20	486	int indx = i + readIntArg(byteCodes, i);
jaroslav@20	487	out.append("if (stack.pop() != 0) { gt = " + indx);
jaroslav@20	488	out.append("; continue; }");
jaroslav@20	489	i += 2;
jaroslav@20	490	break;
jaroslav@20	491	}
jaroslav@20	492	case bc_iflt: {
jaroslav@20	493	int indx = i + readIntArg(byteCodes, i);
jaroslav@20	494	out.append("if (stack.pop() < 0) { gt = " + indx);
jaroslav@20	495	out.append("; continue; }");
jaroslav@20	496	i += 2;
jaroslav@20	497	break;
jaroslav@20	498	}
jaroslav@20	499	case bc_ifle: {
jaroslav@20	500	int indx = i + readIntArg(byteCodes, i);
jaroslav@20	501	out.append("if (stack.pop() <= 0) { gt = " + indx);
jaroslav@20	502	out.append("; continue; }");
jaroslav@20	503	i += 2;
jaroslav@20	504	break;
jaroslav@20	505	}
jaroslav@20	506	case bc_ifgt: {
jaroslav@20	507	int indx = i + readIntArg(byteCodes, i);
jaroslav@20	508	out.append("if (stack.pop() > 0) { gt = " + indx);
jaroslav@20	509	out.append("; continue; }");
jaroslav@20	510	i += 2;
jaroslav@20	511	break;
jaroslav@20	512	}
jaroslav@20	513	case bc_ifge: {
jaroslav@20	514	int indx = i + readIntArg(byteCodes, i);
jaroslav@20	515	out.append("if (stack.pop() >= 0) { gt = " + indx);
jaroslav@20	516	out.append("; continue; }");
jaroslav@20	517	i += 2;
jaroslav@20	518	break;
jaroslav@20	519	}
jaroslav@16	520	case bc_ifnonnull: {
jaroslav@16	521	int indx = i + readIntArg(byteCodes, i);
jaroslav@16	522	out.append("if (stack.pop()) { gt = " + indx);
jaroslav@16	523	out.append("; continue; }");
jaroslav@16	524	i += 2;
jaroslav@16	525	break;
jaroslav@16	526	}
jaroslav@16	527	case bc_ifnull: {
jaroslav@16	528	int indx = i + readIntArg(byteCodes, i);
jaroslav@16	529	out.append("if (!stack.pop()) { gt = " + indx);
jaroslav@16	530	out.append("; continue; }");
jaroslav@16	531	i += 2;
jaroslav@16	532	break;
jaroslav@16	533	}
jaroslav@4	534	case bc_if_icmpne:
jaroslav@4	535	i = generateIf(byteCodes, i, "!=");
jaroslav@4	536	break;
jaroslav@4	537	case bc_if_icmplt:
jaroslav@4	538	i = generateIf(byteCodes, i, ">");
jaroslav@4	539	break;
jaroslav@4	540	case bc_if_icmple:
jaroslav@4	541	i = generateIf(byteCodes, i, ">=");
jaroslav@4	542	break;
jaroslav@4	543	case bc_if_icmpgt:
jaroslav@4	544	i = generateIf(byteCodes, i, "<");
jaroslav@4	545	break;
jaroslav@4	546	case bc_if_icmpge:
jaroslav@4	547	i = generateIf(byteCodes, i, "<=");
jaroslav@4	548	break;
jaroslav@5	549	case bc_goto: {
jaroslav@5	550	int indx = i + readIntArg(byteCodes, i);
jaroslav@5	551	out.append("gt = " + indx).append("; continue;");
jaroslav@5	552	i += 2;
jaroslav@5	553	break;
jaroslav@5	554	}
jaroslav@115	555	case bc_lookupswitch: {
jaroslav@115	556	int table = (i - 1) / 4 * 4 + 4;
jaroslav@115	557	int dflt = i + readInt4(byteCodes, table);
jaroslav@115	558	table += 4;
jaroslav@115	559	int n = readInt4(byteCodes, table);
jaroslav@115	560	table += 4;
jaroslav@115	561	out.append("switch (stack.pop()) {\n");
jaroslav@115	562	while (n-- > 0) {
jaroslav@115	563	int cnstnt = readInt4(byteCodes, table);
jaroslav@115	564	table += 4;
jaroslav@115	565	int offset = i + readInt4(byteCodes, table);
jaroslav@115	566	table += 4;
jaroslav@115	567	out.append(" case " + cnstnt).append(": gt = " + offset).append("; continue;\n");
jaroslav@115	568	}
jaroslav@115	569	out.append(" default: gt = " + dflt).append("; continue;\n}");
jaroslav@115	570	i = table - 1;
jaroslav@115	571	break;
jaroslav@115	572	}
jaroslav@115	573	case bc_tableswitch: {
jaroslav@115	574	int table = (i - 1) / 4 * 4 + 4;
jaroslav@115	575	int dflt = i + readInt4(byteCodes, table);
jaroslav@115	576	table += 4;
jaroslav@115	577	int low = readInt4(byteCodes, table);
jaroslav@115	578	table += 4;
jaroslav@115	579	int high = readInt4(byteCodes, table);
jaroslav@115	580	table += 4;
jaroslav@115	581	out.append("switch (stack.pop()) {\n");
jaroslav@115	582	while (low <= high) {
jaroslav@115	583	int offset = i + readInt4(byteCodes, table);
jaroslav@115	584	table += 4;
jaroslav@115	585	out.append(" case " + low).append(": gt = " + offset).append("; continue;\n");
jaroslav@115	586	low++;
jaroslav@115	587	}
jaroslav@115	588	out.append(" default: gt = " + dflt).append("; continue;\n}");
jaroslav@115	589	i = table - 1;
jaroslav@115	590	break;
jaroslav@115	591	}
jaroslav@46	592	case bc_invokeinterface: {
jaroslav@46	593	i = invokeVirtualMethod(byteCodes, i) + 2;
jaroslav@46	594	break;
jaroslav@46	595	}
jaroslav@12	596	case bc_invokevirtual:
jaroslav@12	597	i = invokeVirtualMethod(byteCodes, i);
jaroslav@12	598	break;
jaroslav@10	599	case bc_invokespecial:
jaroslav@10	600	i = invokeStaticMethod(byteCodes, i, false);
jaroslav@4	601	break;
jaroslav@10	602	case bc_invokestatic:
jaroslav@10	603	i = invokeStaticMethod(byteCodes, i, true);
jaroslav@10	604	break;
jaroslav@8	605	case bc_new: {
jaroslav@8	606	int indx = readIntArg(byteCodes, i);
jaroslav@8	607	CPClassInfo ci = jc.getConstantPool().getClass(indx);
jaroslav@8	608	out.append("stack.push(");
jaroslav@18	609	out.append("new ").append(ci.getClassName().getInternalName().replace('/','_'));
jaroslav@10	610	out.append(");");
jaroslav@18	611	addReference(ci.getClassName().getInternalName());
jaroslav@8	612	i += 2;
jaroslav@8	613	break;
jaroslav@8	614	}
jaroslav@21	615	case bc_newarray: {
jaroslav@21	616	int type = byteCodes[i++];
jaroslav@21	617	out.append("stack.push(new Array(stack.pop()));");
jaroslav@21	618	break;
jaroslav@21	619	}
jaroslav@21	620	case bc_anewarray: {
jaroslav@21	621	i += 2; // skip type of array
jaroslav@21	622	out.append("stack.push(new Array(stack.pop()));");
jaroslav@21	623	break;
jaroslav@21	624	}
jaroslav@21	625	case bc_arraylength:
jaroslav@21	626	out.append("stack.push(stack.pop().length);");
jaroslav@21	627	break;
jaroslav@21	628	case bc_iastore:
jaroslav@21	629	case bc_lastore:
jaroslav@21	630	case bc_fastore:
jaroslav@21	631	case bc_dastore:
jaroslav@21	632	case bc_aastore:
jaroslav@21	633	case bc_bastore:
jaroslav@21	634	case bc_castore:
jaroslav@21	635	case bc_sastore: {
jaroslav@21	636	out.append("{ var value = stack.pop(); var indx = stack.pop(); stack.pop()[indx] = value; }");
jaroslav@21	637	break;
jaroslav@21	638	}
jaroslav@21	639	case bc_iaload:
jaroslav@21	640	case bc_laload:
jaroslav@21	641	case bc_faload:
jaroslav@21	642	case bc_daload:
jaroslav@21	643	case bc_aaload:
jaroslav@21	644	case bc_baload:
jaroslav@21	645	case bc_caload:
jaroslav@21	646	case bc_saload: {
jaroslav@21	647	out.append("{ var indx = stack.pop(); stack.push(stack.pop()[indx]); }");
jaroslav@21	648	break;
jaroslav@21	649	}
jaroslav@93	650	case bc_pop2:
jaroslav@93	651	out.append("stack.pop();");
jaroslav@93	652	case bc_pop:
jaroslav@93	653	out.append("stack.pop();");
jaroslav@93	654	break;
jaroslav@8	655	case bc_dup:
jaroslav@8	656	out.append("stack.push(stack[stack.length - 1]);");
jaroslav@8	657	break;
jaroslav@8	658	case bc_bipush:
jaroslav@8	659	out.append("stack.push(" + byteCodes[++i] + ");");
jaroslav@8	660	break;
jaroslav@31	661	case bc_sipush:
jaroslav@31	662	out.append("stack.push(" + readIntArg(byteCodes, i) + ");");
jaroslav@31	663	i += 2;
jaroslav@31	664	break;
jaroslav@8	665	case bc_getfield: {
jaroslav@8	666	int indx = readIntArg(byteCodes, i);
jaroslav@8	667	CPFieldInfo fi = (CPFieldInfo) jc.getConstantPool().get(indx);
jaroslav@21	668	out.append("stack.push(stack.pop().").append(fi.getFieldName()).append(");");
jaroslav@8	669	i += 2;
jaroslav@8	670	break;
jaroslav@8	671	}
jaroslav@9	672	case bc_getstatic: {
jaroslav@9	673	int indx = readIntArg(byteCodes, i);
jaroslav@9	674	CPFieldInfo fi = (CPFieldInfo) jc.getConstantPool().get(indx);
jaroslav@18	675	final String in = fi.getClassName().getInternalName();
jaroslav@18	676	out.append("stack.push(").append(in.replace('/', '_'));
jaroslav@9	677	out.append('_').append(fi.getFieldName()).append(");");
jaroslav@9	678	i += 2;
jaroslav@18	679	addReference(in);
jaroslav@9	680	break;
jaroslav@9	681	}
jaroslav@9	682	case bc_putstatic: {
jaroslav@9	683	int indx = readIntArg(byteCodes, i);
jaroslav@9	684	CPFieldInfo fi = (CPFieldInfo) jc.getConstantPool().get(indx);
jaroslav@18	685	final String in = fi.getClassName().getInternalName();
jaroslav@18	686	out.append(in.replace('/', '_'));
jaroslav@9	687	out.append('_').append(fi.getFieldName()).append(" = stack.pop();");
jaroslav@9	688	i += 2;
jaroslav@18	689	addReference(in);
jaroslav@9	690	break;
jaroslav@9	691	}
jaroslav@10	692	case bc_putfield: {
jaroslav@10	693	int indx = readIntArg(byteCodes, i);
jaroslav@10	694	CPFieldInfo fi = (CPFieldInfo) jc.getConstantPool().get(indx);
jaroslav@10	695	out.append("{ var v = stack.pop(); stack.pop().")
jaroslav@10	696	.append(fi.getFieldName()).append(" = v; }");
jaroslav@10	697	i += 2;
jaroslav@10	698	break;
jaroslav@10	699	}
jaroslav@30	700	case bc_checkcast: {
jaroslav@30	701	int indx = readIntArg(byteCodes, i);
jaroslav@30	702	CPClassInfo ci = jc.getConstantPool().getClass(indx);
jaroslav@42	703	final String type = ci.getClassName().getType();
jaroslav@42	704	if (!type.startsWith("[")) {
jaroslav@42	705	// no way to check arrays right now
jaroslav@42	706	out.append("if(stack[stack.length - 1].$instOf_")
jaroslav@42	707	.append(type.replace('/', '_'))
jaroslav@42	708	.append(" != 1) throw {};"); // XXX proper exception
jaroslav@42	709	}
jaroslav@30	710	i += 2;
jaroslav@30	711	break;
jaroslav@30	712	}
jaroslav@17	713	case bc_instanceof: {
jaroslav@17	714	int indx = readIntArg(byteCodes, i);
jaroslav@17	715	CPClassInfo ci = jc.getConstantPool().getClass(indx);
jaroslav@17	716	out.append("stack.push(stack.pop().$instOf_")
jaroslav@18	717	.append(ci.getClassName().getInternalName().replace('/', '_'))
jaroslav@17	718	.append(" ? 1 : 0);");
jaroslav@17	719	i += 2;
jaroslav@30	720	break;
jaroslav@17	721	}
jaroslav@104	722	case bc_athrow: {
jaroslav@104	723	out.append("{ var t = stack.pop(); stack = new Array(1); stack[0] = t; throw t; }");
jaroslav@104	724	break;
jaroslav@104	725	}
jaroslav@104	726	default: {
jaroslav@104	727	out.append("throw 'unknown bytecode " + c + "';");
jaroslav@104	728	}
jaroslav@8	729
jaroslav@0	730	}
jaroslav@39	731	out.append(" //");
jaroslav@0	732	for (int j = prev; j <= i; j++) {
jaroslav@0	733	out.append(" ");
jaroslav@0	734	final int cc = (byteCodes[j] + 256) % 256;
jaroslav@0	735	out.append(Integer.toString(cc));
jaroslav@0	736	}
jaroslav@39	737	out.append("\n");
jaroslav@0	738	}
jaroslav@10	739	out.append(" }\n");
jaroslav@4	740	}
jaroslav@4	741
jaroslav@4	742	private int generateIf(byte[] byteCodes, int i, final String test) throws IOException {
jaroslav@4	743	int indx = i + readIntArg(byteCodes, i);
jaroslav@4	744	out.append("if (stack.pop() ").append(test).append(" stack.pop()) { gt = " + indx);
jaroslav@4	745	out.append("; continue; }");
jaroslav@4	746	return i + 2;
jaroslav@4	747	}
jaroslav@4	748
jaroslav@4	749	private int readIntArg(byte[] byteCodes, int offsetInstruction) {
jaroslav@5	750	final int indxHi = byteCodes[offsetInstruction + 1] << 8;
jaroslav@5	751	final int indxLo = byteCodes[offsetInstruction + 2];
jaroslav@5	752	return (indxHi & 0xffffff00) \| (indxLo & 0xff);
jaroslav@4	753	}
jaroslav@115	754	private int readInt4(byte[] byteCodes, int offsetInstruction) {
jaroslav@115	755	final int d = byteCodes[offsetInstruction + 0] << 24;
jaroslav@115	756	final int c = byteCodes[offsetInstruction + 1] << 16;
jaroslav@115	757	final int b = byteCodes[offsetInstruction + 2] << 8;
jaroslav@115	758	final int a = byteCodes[offsetInstruction + 3];
jaroslav@115	759	return (d & 0xff000000) \| (c & 0xff0000) \| (b & 0xff00) \| (a & 0xff);
jaroslav@115	760	}
jaroslav@4	761
jaroslav@4	762	private static int countArgs(String descriptor, boolean[] hasReturnType, StringBuilder sig) {
jaroslav@4	763	int cnt = 0;
jaroslav@4	764	int i = 0;
jaroslav@4	765	Boolean count = null;
jaroslav@32	766	boolean array = false;
jaroslav@10	767	int firstPos = sig.length();
jaroslav@4	768	while (i < descriptor.length()) {
jaroslav@4	769	char ch = descriptor.charAt(i++);
jaroslav@4	770	switch (ch) {
jaroslav@4	771	case '(':
jaroslav@4	772	count = true;
jaroslav@4	773	continue;
jaroslav@4	774	case ')':
jaroslav@4	775	count = false;
jaroslav@4	776	continue;
jaroslav@32	777	case 'A':
jaroslav@32	778	array = true;
jaroslav@32	779	break;
jaroslav@4	780	case 'B':
jaroslav@4	781	case 'C':
jaroslav@4	782	case 'D':
jaroslav@4	783	case 'F':
jaroslav@4	784	case 'I':
jaroslav@4	785	case 'J':
jaroslav@4	786	case 'S':
jaroslav@4	787	case 'Z':
jaroslav@4	788	if (count) {
jaroslav@4	789	cnt++;
jaroslav@32	790	if (array) {
jaroslav@32	791	sig.append('A');
jaroslav@32	792	}
jaroslav@4	793	sig.append(ch);
jaroslav@4	794	} else {
jaroslav@4	795	hasReturnType[0] = true;
jaroslav@10	796	sig.insert(firstPos, ch);
jaroslav@32	797	if (array) {
jaroslav@32	798	sig.insert(firstPos, 'A');
jaroslav@32	799	}
jaroslav@4	800	}
jaroslav@93	801	array = false;
jaroslav@4	802	continue;
jaroslav@4	803	case 'V':
jaroslav@4	804	assert !count;
jaroslav@4	805	hasReturnType[0] = false;
jaroslav@10	806	sig.insert(firstPos, 'V');
jaroslav@4	807	continue;
jaroslav@4	808	case 'L':
jaroslav@16	809	int next = descriptor.indexOf(';', i);
jaroslav@4	810	if (count) {
jaroslav@4	811	cnt++;
jaroslav@32	812	if (array) {
jaroslav@32	813	sig.append('A');
jaroslav@32	814	}
jaroslav@16	815	sig.append(ch);
jaroslav@16	816	sig.append(descriptor.substring(i, next).replace('/', '_'));
jaroslav@4	817	} else {
jaroslav@16	818	sig.insert(firstPos, descriptor.substring(i, next).replace('/', '_'));
jaroslav@16	819	sig.insert(firstPos, ch);
jaroslav@32	820	if (array) {
jaroslav@33	821	sig.insert(firstPos, 'A');
jaroslav@32	822	}
jaroslav@4	823	hasReturnType[0] = true;
jaroslav@4	824	}
jaroslav@16	825	i = next + 1;
jaroslav@4	826	continue;
jaroslav@4	827	case '[':
jaroslav@4	828	//arrays++;
jaroslav@4	829	continue;
jaroslav@4	830	default:
jaroslav@4	831	break; // invalid character
jaroslav@4	832	}
jaroslav@4	833	}
jaroslav@4	834	return cnt;
jaroslav@0	835	}
jaroslav@9	836
jaroslav@9	837	private void generateStaticField(Variable v) throws IOException {
jaroslav@9	838	out.append("\nvar ")
jaroslav@18	839	.append(jc.getName().getInternalName().replace('/', '_'))
jaroslav@9	840	.append('_').append(v.getName()).append(" = 0;");
jaroslav@9	841	}
jaroslav@10	842
jaroslav@10	843	private String findMethodName(Method m) {
jaroslav@42	844	StringBuilder name = new StringBuilder();
jaroslav@42	845	String descr = m.getDescriptor();
jaroslav@10	846	if ("<init>".equals(m.getName())) { // NOI18N
jaroslav@42	847	name.append("cons"); // NOI18N
jaroslav@19	848	} else if ("<clinit>".equals(m.getName())) { // NOI18N
jaroslav@42	849	name.append("class"); // NOI18N
jaroslav@10	850	} else {
jaroslav@42	851	name.append(m.getName());
jaroslav@10	852	}
jaroslav@42	853
jaroslav@42	854	boolean hasReturn[] = { false };
jaroslav@42	855	countArgs(findDescriptor(m.getDescriptor()), hasReturn, name);
jaroslav@42	856	return name.toString();
jaroslav@10	857	}
jaroslav@10	858
jaroslav@10	859	private String findMethodName(CPMethodInfo mi, int[] cnt, boolean[] hasReturn) {
jaroslav@10	860	StringBuilder name = new StringBuilder();
jaroslav@42	861	String descr = mi.getDescriptor();
jaroslav@10	862	if ("<init>".equals(mi.getName())) { // NOI18N
jaroslav@10	863	name.append("cons"); // NOI18N
jaroslav@10	864	} else {
jaroslav@10	865	name.append(mi.getName());
jaroslav@10	866	}
jaroslav@32	867	cnt[0] = countArgs(findDescriptor(mi.getDescriptor()), hasReturn, name);
jaroslav@10	868	return name.toString();
jaroslav@10	869	}
jaroslav@10	870
jaroslav@10	871	private int invokeStaticMethod(byte[] byteCodes, int i, boolean isStatic)
jaroslav@10	872	throws IOException {
jaroslav@10	873	int methodIndex = readIntArg(byteCodes, i);
jaroslav@10	874	CPMethodInfo mi = (CPMethodInfo) jc.getConstantPool().get(methodIndex);
jaroslav@10	875	boolean[] hasReturn = { false };
jaroslav@10	876	int[] cnt = { 0 };
jaroslav@10	877	String mn = findMethodName(mi, cnt, hasReturn);
jaroslav@11	878	out.append("{ ");
jaroslav@11	879	for (int j = cnt[0] - 1; j >= 0; j--) {
jaroslav@11	880	out.append("var v" + j).append(" = stack.pop(); ");
jaroslav@11	881	}
jaroslav@11	882
jaroslav@10	883	if (hasReturn[0]) {
jaroslav@10	884	out.append("stack.push(");
jaroslav@10	885	}
jaroslav@18	886	final String in = mi.getClassName().getInternalName();
jaroslav@18	887	out.append(in.replace('/', '_'));
jaroslav@102	888	if (isStatic) {
jaroslav@102	889	out.append(".prototype.");
jaroslav@102	890	} else {
jaroslav@102	891	out.append('_');
jaroslav@102	892	}
jaroslav@10	893	out.append(mn);
jaroslav@10	894	out.append('(');
jaroslav@10	895	String sep = "";
jaroslav@10	896	if (!isStatic) {
jaroslav@10	897	out.append("stack.pop()");
jaroslav@10	898	sep = ", ";
jaroslav@10	899	}
jaroslav@10	900	for (int j = 0; j < cnt[0]; j++) {
jaroslav@10	901	out.append(sep);
jaroslav@11	902	out.append("v" + j);
jaroslav@10	903	sep = ", ";
jaroslav@10	904	}
jaroslav@10	905	out.append(")");
jaroslav@10	906	if (hasReturn[0]) {
jaroslav@10	907	out.append(")");
jaroslav@10	908	}
jaroslav@11	909	out.append("; }");
jaroslav@10	910	i += 2;
jaroslav@18	911	addReference(in);
jaroslav@10	912	return i;
jaroslav@10	913	}
jaroslav@12	914	private int invokeVirtualMethod(byte[] byteCodes, int i)
jaroslav@12	915	throws IOException {
jaroslav@12	916	int methodIndex = readIntArg(byteCodes, i);
jaroslav@12	917	CPMethodInfo mi = (CPMethodInfo) jc.getConstantPool().get(methodIndex);
jaroslav@12	918	boolean[] hasReturn = { false };
jaroslav@12	919	int[] cnt = { 0 };
jaroslav@12	920	String mn = findMethodName(mi, cnt, hasReturn);
jaroslav@12	921	out.append("{ ");
jaroslav@12	922	for (int j = cnt[0] - 1; j >= 0; j--) {
jaroslav@12	923	out.append("var v" + j).append(" = stack.pop(); ");
jaroslav@12	924	}
jaroslav@12	925	out.append("var self = stack.pop(); ");
jaroslav@12	926	if (hasReturn[0]) {
jaroslav@12	927	out.append("stack.push(");
jaroslav@12	928	}
jaroslav@12	929	out.append("self.");
jaroslav@12	930	out.append(mn);
jaroslav@12	931	out.append('(');
jaroslav@12	932	out.append("self");
jaroslav@12	933	for (int j = 0; j < cnt[0]; j++) {
jaroslav@12	934	out.append(", ");
jaroslav@12	935	out.append("v" + j);
jaroslav@12	936	}
jaroslav@12	937	out.append(")");
jaroslav@12	938	if (hasReturn[0]) {
jaroslav@12	939	out.append(")");
jaroslav@12	940	}
jaroslav@12	941	out.append("; }");
jaroslav@12	942	i += 2;
jaroslav@12	943	return i;
jaroslav@12	944	}
jaroslav@18	945
jaroslav@103	946	private void addReference(String cn) throws IOException {
jaroslav@103	947	out.append(" /* needs ").append(cn).append(" */");
jaroslav@18	948	if (references != null) {
jaroslav@18	949	references.add(cn);
jaroslav@18	950	}
jaroslav@18	951	}
jaroslav@16	952
jaroslav@33	953	private void outType(String d, StringBuilder out) {
jaroslav@33	954	int arr = 0;
jaroslav@33	955	while (d.charAt(0) == '[') {
jaroslav@33	956	out.append('A');
jaroslav@33	957	d = d.substring(1);
jaroslav@33	958	}
jaroslav@16	959	if (d.charAt(0) == 'L') {
jaroslav@16	960	assert d.charAt(d.length() - 1) == ';';
jaroslav@16	961	out.append(d.replace('/', '_').substring(0, d.length() - 1));
jaroslav@16	962	} else {
jaroslav@16	963	out.append(d);
jaroslav@16	964	}
jaroslav@16	965	}
jaroslav@21	966
jaroslav@21	967	private String encodeConstant(CPEntry entry) {
jaroslav@21	968	final String v;
jaroslav@93	969	if (entry instanceof CPClassInfo) {
jaroslav@93	970	v = "new java_lang_Class";
jaroslav@93	971	} else if (entry instanceof CPStringInfo) {
jaroslav@21	972	v = "\"" + entry.getValue().toString().replace("\"", "\\\"") + "\"";
jaroslav@21	973	} else {
jaroslav@21	974	v = entry.getValue().toString();
jaroslav@21	975	}
jaroslav@21	976	return v;
jaroslav@21	977	}
jaroslav@32	978
jaroslav@32	979	private String findDescriptor(String d) {
jaroslav@32	980	return d.replace('[', 'A');
jaroslav@32	981	}
jaroslav@94	982
jaroslav@94	983	private boolean javaScriptBody(Method m, boolean isStatic) throws IOException {
jaroslav@94	984	final ClassName extraAnn = ClassName.getClassName(JavaScriptBody.class.getName().replace('.', '/'));
jaroslav@94	985	Annotation a = m.getAnnotation(extraAnn);
jaroslav@94	986	if (a != null) {
jaroslav@94	987	final ElementValue annVal = a.getComponent("body").getValue();
jaroslav@94	988	String body = ((PrimitiveElementValue) annVal).getValue().getValue().toString();
jaroslav@94	989
jaroslav@94	990	final ArrayElementValue arrVal = (ArrayElementValue) a.getComponent("args").getValue();
jaroslav@94	991	final int len = arrVal.getValues().length;
jaroslav@94	992	String[] names = new String[len];
jaroslav@94	993	for (int i = 0; i < len; i++) {
jaroslav@94	994	names[i] = ((PrimitiveElementValue) arrVal.getValues()[i]).getValue().getValue().toString();
jaroslav@94	995	}
jaroslav@94	996	out.append("\nfunction ").append(
jaroslav@94	997	jc.getName().getInternalName().replace('/', '_')).append('_').append(findMethodName(m));
jaroslav@94	998	out.append("(");
jaroslav@94	999	String space;
jaroslav@94	1000	int index;
jaroslav@94	1001	if (!isStatic) {
jaroslav@94	1002	out.append(names[0]);
jaroslav@94	1003	space = ",";
jaroslav@94	1004	index = 1;
jaroslav@94	1005	} else {
jaroslav@94	1006	space = "";
jaroslav@94	1007	index = 0;
jaroslav@94	1008	}
jaroslav@94	1009	List<Parameter> args = m.getParameters();
jaroslav@94	1010	for (int i = 0; i < args.size(); i++) {
jaroslav@94	1011	out.append(space);
jaroslav@94	1012	out.append(names[index]);
jaroslav@94	1013	final String desc = findDescriptor(args.get(i).getDescriptor());
jaroslav@94	1014	index++;
jaroslav@99	1015	space = ",";
jaroslav@94	1016	}
jaroslav@94	1017	out.append(") {").append("\n");
jaroslav@94	1018	out.append(body);
jaroslav@94	1019	out.append("\n}\n");
jaroslav@94	1020	return true;
jaroslav@94	1021	}
jaroslav@94	1022	return false;
jaroslav@94	1023	}
jaroslav@0	1024	}

author	Jaroslav Tulach <jtulach@netbeans.org>
	Tue, 30 Oct 2012 20:29:55 +0100
changeset 127	5134b17d623c
parent 115	3d5597011af0
child 128	8db5cf267d74
permissions	-rw-r--r--