fork download
copy 
  1. /* package whatever; // don't place package name! */
  2.  
  3. import java.util.*;
  4. import java.lang.*;
  5. import java.io.*;
  6. import java.nio.*;
  7. import java.lang.reflect.*;
  8.  
  9. /* Name of the class has to be "Main" only if the class is public. */
  10. class Ideone
  11. {
  12.  
  13. 	public static void main (String[] args) throws java.lang.Exception
  14. 	{
  15. 		// your code goes here
  16. 		MyClass mc = new MyClass();
  17.  
  18. 		method_info mi_cnst = new method_info(
  19. 			method_info.ACC_PUBLIC,
  20. 			mc.addCP(new CONSTANT_Utf8_info("<init>")),
  21. 			mc.addCP(new CONSTANT_Utf8_info("()V")));
  22. 		mc.addMethod(mi_cnst);
  23. 		Code_attribute ca_cnst = new Code_attribute(mc);
  24. 		mi_cnst.add(ca_cnst);
  25. 		ca_cnst.addCode(0x2A); // aload_0
  26. 		ca_cnst.addCode(0xB7); // invokespecial
  27. 		ca_cnst.addCodeShort(
  28. 			mc.addCP(new CONSTANT_Methodref_info(
  29. 				mc, "java/lang/Object",
  30. 					"<init>", "()V")));
  31. 		ca_cnst.addCode(0xB1); // return
  32.  
  33. 		method_info mi_main = new method_info(
  34. 			method_info.ACC_PUBLIC | method_info.ACC_STATIC,
  35. 			mc.addCP(new CONSTANT_Utf8_info("main")),
  36. 			mc.addCP(new CONSTANT_Utf8_info("([Ljava/lang/String;)V")));
  37. 		mc.addMethod(mi_main);
  38. 		Code_attribute ca_main = new Code_attribute(mc);
  39. 		mi_main.add(ca_main);
  40. 		ca_main.max_stack = 2;
  41. 		ca_main.addCode(0xB2); // getstatic
  42. 		ca_main.addCodeShort(
  43. 			mc.addCP(new CONSTANT_Fieldref_info(
  44. 				mc, "java/lang/System",
  45. 					"out", "Ljava/io/PrintStream;")));
  46. 		ca_main.addCode(0x12); // ldc
  47. 		ca_main.addCode(
  48. 			mc.addCP(new CONSTANT_String_info(mc, "Hello World!")));
  49. 		ca_main.addCode(0xB6); // invokevirtual
  50. 		ca_main.addCodeShort(
  51. 			mc.addCP(new CONSTANT_Methodref_info(
  52. 				mc, "java/io/PrintStream", 
  53. 					"println", "(Ljava/lang/String;)V"))); 
  54. 		ca_main.addCode(0xB1); // return
  55.  
  56.  
  57. 		// バイトコード生成！
  58. 		byte[] buf = mc.toBytes();
  59.  
  60.  
  61. 		// 生成したバイトコードを試すとこ！
  62. 		try {
  63. 			MyClassLoader loader = new MyClassLoader();
  64. 			Object hoge = loader.getHoge(buf).newInstance();
  65. 			Method[] mm = hoge.getClass().getMethods();
  66.  
  67. 			mm[0].invoke(null, new String[1]);
  68. 			String[] ss = new String[1];
  69. 			hoge.getClass().getMethod("main", ss.getClass()).invoke(null, ss);
  70.  
  71. 		} catch (Throwable e) {
  72. 			System.out.println("ロード失敗！！");
  73. 			System.out.println(e.toString());
  74. 		}
  75.  
  76. 		System.out.println("--生成したバイトコード--");
  77. 		for (int i = 0; i < buf.length; i++) {
  78. 			System.out.printf("%02X ", buf[i]);
  79. 			if ((i & 0x7) == 0x7) {
  80. 				System.out.print(" ");
  81. 			}
  82. 			if ((i & 0xF) == 0xF) {
  83. 				System.out.println();
  84. 			}
  85.  
  86. 		}
  87.  
  88. 		System.out.println();
  89. 		System.out.println("--Constant pool--");
  90. 		int c = 1;
  91. 		for (Iterator<cp_info> i = mc.constant_pool.iterator()
  92. 				; i.hasNext(); c++) {
  93. 			System.out.println(c + ":: " + i.next().toString());		
  94. 		}
  95.  
  96. 	}
  97.  
  98. 	static class MyClassLoader extends ClassLoader {
  99. 		MyClassLoader() {}
  100. 		public Class<?> getHoge(byte[] b) {
  101. //			return defineClass(b, 0, b.length);
  102. 			return defineClass("Hoge", b, 0, b.length);
  103. 		}
  104. 	}
  105.  
  106.  
  107. 	static class MyClass {
  108. 		public static final int ACC_PUBLIC = 0x01;
  109. 		public static final int ACC_SUPER  = 0x20;
  110.  
  111. 		byte[] 	magic;
  112. 		int  	minor_version;
  113. 		int  	major_version;
  114. 		ArrayList<cp_info> constant_pool;
  115. 		int 	access_flags;
  116. 		int		this_class;
  117. 		int		super_class;
  118. 		int		interfaces_count;
  119. 		IntBuffer interfaces;
  120. 		ArrayList<field_info> fields;
  121. 		ArrayList<method_info> methods;
  122. 		ArrayList<attribute_info> attributes;
  123. 		{
  124. 			magic = new byte[4];
  125. 			magic[0] = (byte)0xCA;
  126. 			magic[1] = (byte)0xFE;
  127. 			magic[2] = (byte)0xBA;
  128. 			magic[3] = (byte)0xBE;
  129.  
  130. 			access_flags = ACC_PUBLIC | ACC_SUPER;
  131.  
  132. 			minor_version = 0;
  133. 			major_version = 0x31;
  134.  
  135. 			constant_pool = new ArrayList<cp_info>();
  136. 			interfaces_count = 0;
  137. 			interfaces = IntBuffer.allocate(5);
  138. 			fields = null;
  139. 			methods = null;
  140. 			attributes = null;
  141. 		}
  142.  
  143. 		MyClass() {
  144. 			this_class = addCP(
  145. 				new CONSTANT_Class_info(this, "Hoge"));
  146. 			super_class = addCP(
  147. 				new CONSTANT_Class_info(this, "java/lang/Object"));
  148. 			/*
  149. 			addAttribute(
  150. 				new SourceFile_attribute(this, "Hoge.java"));			
  151. 			*/
  152. 		}
  153.  
  154. 		int addCP(cp_info cp) {
  155. 			int i = constant_pool.indexOf(cp);
  156. 			if (i < 0) {
  157. 				constant_pool.add(cp);
  158. 				return constant_pool.size();
  159. 			}
  160. 			return i + 1;
  161. 		}
  162.  
  163. 		void addMethod(method_info mt) {
  164. 			if (methods == null) {
  165. 				methods = new ArrayList<method_info>();
  166. 			}
  167. 			methods.add(mt);
  168. 		}
  169.  
  170. 		void addAttribute(attribute_info ab) {
  171. 			if (attributes == null) {
  172. 				attributes = new ArrayList<attribute_info>();
  173. 			}
  174. 			attributes.add(ab);
  175. 		}
  176.  
  177. 		byte[] toBytes() throws IOException {
  178. 			ByteArrayOutputStream buf = null;
  179. 			DataOutputStream out = null;
  180. 			try {
  181. 				buf = new ByteArrayOutputStream();
  182. 				out = new DataOutputStream(buf);
  183. 				out.write(magic, 0, magic.length);
  184. 				out.writeShort(minor_version);
  185. 				out.writeShort(major_version);
  186. 				out.writeShort(constant_pool.size() + 1);
  187. 				for (Iterator<cp_info> i = constant_pool.iterator()
  188. 						; i.hasNext(); ) {
  189. 					i.next().write(out);			
  190. 				}
  191. 				out.writeShort(access_flags);
  192. 				out.writeShort(this_class);
  193. 				out.writeShort(super_class);
  194.  
  195. 				out.writeShort(interfaces_count);
  196. 				for (int i = 0; i < interfaces_count; i++) {
  197. 					out.writeShort(interfaces.get(i));
  198. 				}
  199.  
  200. 				if (fields == null) {
  201. 					out.writeShort(0);
  202. 				} else {
  203. 					out.writeShort(fields.size());
  204. 					for (Iterator<field_info> i = fields.iterator()
  205. 							; i.hasNext(); ) {
  206. 						i.next().write(out);
  207. 					}
  208. 				}
  209.  
  210. 				if (methods == null) {
  211. 					out.writeShort(0);
  212. 				} else {
  213. 					out.writeShort(methods.size());
  214. 					for (Iterator<method_info> i = methods.iterator()
  215. 							; i.hasNext(); ) {
  216. 						i.next().write(out);
  217. 					}
  218. 				}
  219.  
  220. 				if (attributes == null) {
  221. 					out.writeShort(0);
  222. 				} else {
  223. 					out.writeShort(attributes.size());
  224. 					for (Iterator<attribute_info> i = attributes.iterator()
  225. 							; i.hasNext(); ) {
  226. 						i.next().write(out);
  227. 					}
  228. 				}
  229.  
  230. 				return buf.toByteArray();
  231. 			} finally {
  232. 				if (out != null) out.close();
  233. 				if (buf != null) buf.close();
  234. 			}
  235. 		}
  236. 	}
  237.  
  238. 	static interface Icp_info {
  239. 		byte CONSTANT_Class = 7;
  240. 		byte CONSTANT_Fieldref = 9;
  241. 		byte CONSTANT_Methodref = 10;
  242. 		byte CONSTANT_InterfaceMethodref = 11;
  243. 		byte CONSTANT_String = 8;
  244. 		byte CONSTANT_Integer = 3;
  245. 		byte CONSTANT_Float = 4;
  246. 		byte CONSTANT_Long = 5;
  247. 		byte CONSTANT_Double = 6;
  248. 		byte CONSTANT_NameAndType = 12;
  249. 		byte CONSTANT_Utf8 = 1;
  250. 		void write(DataOutputStream out) throws IOException;
  251. 	}
  252.  
  253. 	static abstract class cp_info implements Icp_info {
  254. 		public final byte tag;
  255. 		protected cp_info(byte tag) { this.tag = tag; }
  256. 	}
  257.  
  258. 	static class CONSTANT_Class_info extends cp_info {
  259. 		public final int name_index;
  260. 		CONSTANT_Class_info(int i) { super(CONSTANT_Class); name_index = i; }
  261. 		CONSTANT_Class_info(MyClass mc, String c) {
  262. 			super(CONSTANT_Class);
  263. 			name_index = mc.addCP(new CONSTANT_Utf8_info(c));
  264. 		}
  265. 		public void write(DataOutputStream out) throws IOException {
  266. 			out.writeByte(tag);
  267. 			out.writeShort(name_index);
  268. 		}
  269. 		public boolean equals(Object obj) {
  270. 			if (obj == null) return false; if (this == obj) return true;
  271. 			if (!(obj instanceof CONSTANT_Class_info)) return false;
  272. 			CONSTANT_Class_info v = (CONSTANT_Class_info)obj;
  273. 			return name_index == v.name_index;
  274. 		}
  275. 		public String toString() {
  276. 			return "Class " + name_index;
  277. 		}
  278. 	}
  279. 	static class CONSTANT_ref_info extends cp_info {
  280. 		public final int class_index;
  281. 		public final int name_and_type_index;
  282. 		protected CONSTANT_ref_info(byte tag, int a, int b) { super(tag);
  283. 			class_index = a; name_and_type_index = b;}
  284. 		CONSTANT_ref_info(byte t, MyClass mc, String c, String m, String d) {
  285. 			this(t
  286. 				, mc.addCP(new CONSTANT_Class_info(mc, c))
  287. 				, mc.addCP(new CONSTANT_NameAndType_info(mc, m, d)));
  288. 		}
  289. 		public void write(DataOutputStream out) throws IOException {
  290. 			out.writeByte(tag);
  291. 			out.writeShort(class_index);
  292. 			out.writeShort(name_and_type_index);
  293. 		}
  294. 		public boolean equals(Object obj) {
  295. 			if (obj == null) return false; if (this == obj) return true;
  296. 			if (!(obj instanceof CONSTANT_ref_info)) return false;
  297. 			CONSTANT_ref_info v = (CONSTANT_ref_info)obj;
  298. 			return (class_index == v.class_index) && 
  299. 				(name_and_type_index == v.name_and_type_index);
  300. 		}
  301. 		public String toString() {
  302. 			return "c:" + class_index + " nat:" + name_and_type_index;
  303. 		}
  304. 	}
  305. 	static class CONSTANT_Fieldref_info extends CONSTANT_ref_info {
  306. 		CONSTANT_Fieldref_info(int a, int b) { super(CONSTANT_Fieldref,a,b); }
  307. 		CONSTANT_Fieldref_info(MyClass mc, String c, String m, String d) {
  308. 			super(CONSTANT_Fieldref, mc, c, m, d);
  309. 		}
  310. 		public String toString() {
  311. 			return "Field " + super.toString();
  312. 		}
  313. 	}
  314. 	static class CONSTANT_Methodref_info extends CONSTANT_ref_info {
  315. 		CONSTANT_Methodref_info(int a, int b) { super(CONSTANT_Methodref,a,b); }
  316. 		CONSTANT_Methodref_info(MyClass mc, String c, String m, String d) {
  317. 			super(CONSTANT_Methodref, mc, c, m, d);
  318. 		}
  319. 		public String toString() {
  320. 			return "Method " + super.toString();
  321. 		}
  322. 	}
  323. 	static class CONSTANT_InterfaceMethodref_info extends CONSTANT_ref_info {
  324. 		CONSTANT_InterfaceMethodref_info(int a, int b) { super(CONSTANT_InterfaceMethodref,a,b); }
  325. 	}
  326. 	static class CONSTANT_String_info extends cp_info {
  327. 		public final int string_index;
  328. 		CONSTANT_String_info(int i) { super(CONSTANT_String); string_index = i; }
  329. 		CONSTANT_String_info(MyClass mc, String s) {
  330. 			super(CONSTANT_String);
  331. 			string_index = mc.addCP(new CONSTANT_Utf8_info(s));
  332. 		}
  333. 		public void write(DataOutputStream out) throws IOException {
  334. 			out.writeByte(tag);
  335. 			out.writeShort(string_index);
  336. 		}
  337. 		public boolean equals(Object obj) {
  338. 			if (obj == null) return false; if (this == obj) return true;
  339. 			if (!(obj instanceof CONSTANT_String_info)) return false;
  340. 			CONSTANT_String_info v = (CONSTANT_String_info)obj;
  341. 			return string_index == v.string_index;
  342. 		}
  343. 		public String toString() {
  344. 			return "String " + string_index;
  345. 		}
  346. 	}
  347. 	static class CONSTANT_Integer_info extends cp_info {
  348. 		public final int bytes;
  349. 		CONSTANT_Integer_info(int v) { super(CONSTANT_Integer); bytes = v; }
  350. 		public void write(DataOutputStream out) throws IOException {
  351. 			out.writeByte(tag);
  352. 			out.writeInt(bytes);
  353. 		}
  354. 		public boolean equals(Object obj) {
  355. 			if (obj == null) return false; if (this == obj) return true;
  356. 			if (!(obj instanceof CONSTANT_Integer_info)) return false;
  357. 			CONSTANT_Integer_info v = (CONSTANT_Integer_info)obj;
  358. 			return bytes == v.bytes;
  359. 		}
  360. 	}
  361. 	static class CONSTANT_Float_info extends cp_info {
  362. 		public final float bytes;
  363. 		CONSTANT_Float_info(float v) { super(CONSTANT_Float); bytes = v; }
  364. 		public void write(DataOutputStream out) throws IOException {
  365. 			out.writeByte(tag);
  366. 			out.writeFloat(bytes);
  367. 		}
  368. 		public boolean equals(Object obj) {
  369. 			if (obj == null) return false; if (this == obj) return true;
  370. 			if (!(obj instanceof CONSTANT_Float_info)) return false;
  371. 			CONSTANT_Float_info v = (CONSTANT_Float_info)obj;
  372. 			return bytes == v.bytes;
  373. 		}
  374. 	}
  375. 	static class CONSTANT_Long_info extends cp_info {
  376. 		public final long bytes;
  377. 		CONSTANT_Long_info(long v) { super(CONSTANT_Long); bytes = v; }
  378. 		public void write(DataOutputStream out) throws IOException {
  379. 			out.writeByte(tag);
  380. 			out.writeLong(bytes);
  381. 		}
  382. 		public boolean equals(Object obj) {
  383. 			if (obj == null) return false; if (this == obj) return true;
  384. 			if (!(obj instanceof CONSTANT_Long_info)) return false;
  385. 			CONSTANT_Long_info v = (CONSTANT_Long_info)obj;
  386. 			return bytes == v.bytes;
  387. 		}
  388. 	}
  389. 	static class CONSTANT_Double_info extends cp_info {
  390. 		public final double bytes;
  391. 		CONSTANT_Double_info(double d) { super(CONSTANT_Double); bytes = d; }
  392. 		public void write(DataOutputStream out) throws IOException {
  393. 			out.writeByte(tag);
  394. 			out.writeDouble(bytes);
  395. 		}
  396. 		public boolean equals(Object obj) {
  397. 			if (obj == null) return false; if (this == obj) return true;
  398. 			if (!(obj instanceof CONSTANT_Double_info)) return false;
  399. 			CONSTANT_Double_info v = (CONSTANT_Double_info)obj;
  400. 			return bytes == v.bytes;
  401. 		}
  402. 	}
  403. 	static class CONSTANT_NameAndType_info extends cp_info {
  404. 		public int name_index = 0;
  405. 		public int descriptor_index = 0;
  406. 		CONSTANT_NameAndType_info(int n, int d) {
  407. 			super(CONSTANT_NameAndType); name_index = n; descriptor_index=d; }
  408. 		CONSTANT_NameAndType_info(MyClass mc, String n, String d) {
  409. 			super(CONSTANT_NameAndType);
  410. 			name_index = mc.addCP(new CONSTANT_Utf8_info(n));
  411. 			descriptor_index = mc.addCP(new CONSTANT_Utf8_info(d));
  412. 		}
  413. 		public void write(DataOutputStream out) throws IOException {
  414. 			out.writeByte(tag);
  415. 			out.writeShort(name_index);
  416. 			out.writeShort(descriptor_index);
  417. 		}
  418. 		public boolean equals(Object obj) {
  419. 			if (obj == null) return false; if (this == obj) return true;
  420. 			if (!(obj instanceof CONSTANT_NameAndType_info)) return false;
  421. 			CONSTANT_NameAndType_info v = (CONSTANT_NameAndType_info)obj;
  422. 			return (name_index == v.name_index) && 
  423. 				(descriptor_index == v.descriptor_index);
  424. 		}
  425. 		public String toString() {
  426. 			return "NameAndType n:" + name_index + " d:" + descriptor_index;
  427. 		}
  428. 	}
  429. 	static class CONSTANT_Utf8_info extends cp_info {
  430. 		public final String bytes;
  431. 		CONSTANT_Utf8_info(String str) { super(CONSTANT_Utf8); bytes = str; }
  432. 		public void write(DataOutputStream out) throws IOException {
  433. 			out.writeByte(tag);
  434. 			out.writeShort(bytes.length());
  435. 			byte[] b = bytes.getBytes();
  436. 			out.write(b, 0, b.length);
  437. 		}
  438. 		public boolean equals(Object obj) {
  439. 			if (obj == null) return false; if (this == obj) return true;
  440. 			if (!(obj instanceof CONSTANT_Utf8_info)) return false;
  441. 			CONSTANT_Utf8_info v = (CONSTANT_Utf8_info)obj;
  442. 			if (bytes == null) return v.bytes == null;
  443. 			return bytes.equals(v.bytes);
  444. 		}
  445. 		public String toString() {
  446. 			return "\"" + bytes + "\"";
  447. 		}
  448. 	}
  449.  
  450. 	static abstract class attribute_info {
  451. 		public final int attribute_name_index;
  452. 		protected attribute_info(int i) { attribute_name_index = i; }
  453. 		public abstract void write(DataOutputStream out) throws IOException;
  454. 	}
  455.  
  456. 	static class exception_info {
  457. 		public int start_pc = 0;
  458. 		public int end_pc = 0;
  459. 		public int handler_pc = 0;
  460. 		public int catch_type = 0;
  461. 		public void write(DataOutputStream out) throws IOException {
  462. 			out.writeShort(start_pc);
  463. 			out.writeShort(end_pc);
  464. 			out.writeShort(handler_pc);
  465. 			out.writeShort(catch_type);
  466. 		}
  467.  
  468. 	}
  469.  
  470. 	static class SourceFile_attribute extends attribute_info {
  471. 		public final int sourcefile_index;
  472. 		SourceFile_attribute(MyClass mc, String s) {
  473. 			super(mc.addCP(new CONSTANT_Utf8_info("SourceFile")));
  474. 			sourcefile_index = mc.addCP(
  475. 				new CONSTANT_Utf8_info(s));
  476. 		}
  477. 		public void write(DataOutputStream out) throws IOException {
  478. 			out.writeShort(attribute_name_index);
  479. 			out.writeInt(2);
  480. 			out.writeShort(sourcefile_index);
  481. 		}
  482. 	}
  483.  
  484.  
  485. 	static class Code_attribute extends attribute_info {
  486. 		public int max_stack = 1;
  487. 		public int max_locals = 1;
  488. 		public ByteArrayOutputStream code = null;;
  489. 		public DataOutputStream data = null;
  490. 		public ArrayList<exception_info> exception_table = null;
  491. 		public ArrayList<attribute_info> attributes = null;
  492. 		Code_attribute(MyClass mc) {
  493. 			super(mc.addCP(new CONSTANT_Utf8_info("Code")));
  494. 			code = new ByteArrayOutputStream();
  495. 			data = new DataOutputStream(code);
  496. 		}
  497. 		public void addCode(int c) throws IOException {
  498. 			data.write(c);
  499. 		}
  500. 		public void addCodeShort(int c) throws IOException {
  501. 			data.writeShort(c);
  502. 		}
  503. 		public void write(DataOutputStream out) throws IOException {
  504. 			out.writeShort(attribute_name_index);
  505. 			ByteArrayOutputStream buf  = null;
  506. 			DataOutputStream tmp = null;
  507. 			try {
  508. 				buf = new ByteArrayOutputStream();
  509. 				tmp = new DataOutputStream(buf);
  510. 				tmp.writeShort(max_stack);
  511. 				tmp.writeShort(max_locals);
  512. 				tmp.writeInt(code.size());
  513. 				tmp.write(code.toByteArray(), 0, code.size());
  514. 				if (exception_table == null) {
  515. 					tmp.writeShort(0);
  516. 				} else {
  517. 					tmp.writeShort(exception_table.size());
  518. 					for (Iterator<exception_info>
  519. 							i = exception_table.iterator()
  520. 							; i.hasNext(); ) {
  521. 						i.next().write(tmp);
  522. 					}
  523. 				}
  524. 				if (attributes == null) {
  525. 					tmp.writeShort(0);
  526. 				} else {
  527. 					tmp.writeShort(attributes.size());
  528. 					for (Iterator<attribute_info>
  529. 							i = attributes.iterator()
  530. 							; i.hasNext(); ) {
  531. 						i.next().write(tmp);
  532. 					}
  533. 				}
  534. 				byte[] b = buf.toByteArray();
  535. 				out.writeInt(b.length);
  536. 				out.write(b, 0, b.length);
  537. 			} finally {
  538. 				if (tmp != null) tmp.close();
  539. 				if (buf != null) buf.close();
  540. 			}
  541. 		}
  542. 	}
  543.  
  544. 	static abstract class member_info {
  545. 		public int access_flags;
  546. 		public int name_index;
  547. 		public int descriptor_index;
  548. 		public ArrayList<attribute_info> attributes = null;
  549. 		protected member_info(int ac, int n, int d) {
  550. 			access_flags = ac;
  551. 			name_index = n;
  552. 			descriptor_index = d;
  553. 		}
  554. 		public void add(attribute_info a) {
  555. 			if (attributes == null) {
  556. 				attributes = new ArrayList<attribute_info>();
  557. 			}
  558. 			attributes.add(a);
  559. 		}
  560. 		public void write(DataOutputStream out) throws IOException {
  561. 			out.writeShort(access_flags);
  562. 			out.writeShort(name_index);
  563. 			out.writeShort(descriptor_index);
  564. 			if (attributes == null) {
  565. 				out.writeShort(0);
  566. 			} else {
  567. 				out.writeShort(attributes.size());
  568. 				for (Iterator<attribute_info> i = attributes.iterator()
  569. 						; i.hasNext(); ) {
  570. 					i.next().write(out);			
  571. 				}
  572. 			}
  573. 		}
  574. 	}
  575.  
  576. 	static class field_info extends member_info {
  577. 		public static final int ACC_PUBLIC 		= 0x01;
  578. 		public static final int ACC_PRIVATE 	= 0x02;
  579. 		public static final int ACC_PROTECTED 	= 0x04;
  580. 		public static final int ACC_STATIC 		= 0x08;
  581. 		public static final int ACC_FINAL 		= 0x10;
  582. 		field_info(int ac, int n, int d) { super(ac, n, d); }
  583. 	}
  584.  
  585. 	static class method_info extends member_info {
  586. 		public static final int ACC_PUBLIC 		= 0x01;
  587. 		public static final int ACC_PRIVATE 	= 0x02;
  588. 		public static final int ACC_PROTECTED 	= 0x04;
  589. 		public static final int ACC_STATIC 		= 0x08;
  590. 		public static final int ACC_FINAL 		= 0x10;
  591. 		method_info(int ac, int n, int d) { super(ac,n,d); }
  592. 	}
  593. }
Success #stdin #stdout 0.13s 380544KB
comments (?)
stdin
copy 
Standard input is empty
stdout
copy 
Hello World!
Hello World!
--生成したバイトコード--
CA FE BA BE 00 00 00 31  00 1A 01 00 04 48 6F 67  
65 07 00 01 01 00 10 6A  61 76 61 2F 6C 61 6E 67  
2F 4F 62 6A 65 63 74 07  00 03 01 00 06 3C 69 6E  
69 74 3E 01 00 03 28 29  56 01 00 04 43 6F 64 65  
0C 00 05 00 06 0A 00 04  00 08 01 00 04 6D 61 69  
6E 01 00 16 28 5B 4C 6A  61 76 61 2F 6C 61 6E 67  
2F 53 74 72 69 6E 67 3B  29 56 01 00 10 6A 61 76  
61 2F 6C 61 6E 67 2F 53  79 73 74 65 6D 07 00 0C  
01 00 03 6F 75 74 01 00  15 4C 6A 61 76 61 2F 69  
6F 2F 50 72 69 6E 74 53  74 72 65 61 6D 3B 0C 00  
0E 00 0F 09 00 0D 00 10  01 00 0C 48 65 6C 6C 6F  
20 57 6F 72 6C 64 21 08  00 12 01 00 13 6A 61 76  
61 2F 69 6F 2F 50 72 69  6E 74 53 74 72 65 61 6D  
07 00 14 01 00 07 70 72  69 6E 74 6C 6E 01 00 15  
28 4C 6A 61 76 61 2F 6C  61 6E 67 2F 53 74 72 69  
6E 67 3B 29 56 0C 00 16  00 17 0A 00 15 00 18 00  
21 00 02 00 04 00 00 00  00 00 02 00 01 00 05 00  
06 00 01 00 07 00 00 00  11 00 01 00 01 00 00 00  
05 2A B7 00 09 B1 00 00  00 00 00 09 00 0A 00 0B  
00 01 00 07 00 00 00 15  00 02 00 01 00 00 00 09  
B2 00 11 12 13 B6 00 19  B1 00 00 00 00 00 00 
--Constant pool--
1:: "Hoge"
2:: Class 1
3:: "java/lang/Object"
4:: Class 3
5:: "<init>"
6:: "()V"
7:: "Code"
8:: NameAndType n:5 d:6
9:: Method c:4 nat:8
10:: "main"
11:: "([Ljava/lang/String;)V"
12:: "java/lang/System"
13:: Class 12
14:: "out"
15:: "Ljava/io/PrintStream;"
16:: NameAndType n:14 d:15
17:: Field c:13 nat:16
18:: "Hello World!"
19:: String 18
20:: "java/io/PrintStream"
21:: Class 20
22:: "println"
23:: "(Ljava/lang/String;)V"
24:: NameAndType n:22 d:23
25:: Method c:21 nat:24
https://ideone.com/hDFWFy
language:
Java (HotSpot 12)
created:
10 years ago
visibility:
public

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!