fork download
copy 
  1. import java.awt.*;
  2. import java.awt.event.ActionEvent;
  3. import java.awt.event.KeyEvent;
  4. import java.awt.event.KeyListener;
  5.  
  6. import javax.swing.*;
  7.  
  8.  
  9. public class Vam extends JFrame{
  10.  
  11. 	private static final int FRAME_WIDTH = 800;
  12. 	private static final int FRAME_HEIGHT = 800;
  13.  
  14. 	boolean stop;
  15.  
  16. 	public static byte SR; //Aufbau: (0,0,0,0,0,Overflow,GraterZero,SmallerZero)
  17. 	public static byte BZ;
  18. 	public static byte A;
  19. 	public static byte R1;
  20. 	public static byte R2;
  21. 	public static byte R3;
  22. 	public static byte R4;
  23. 	public static byte R5;
  24. 	public static byte R6;
  25. 	public static byte R7;
  26. 	public static byte R8;
  27. 	public static byte R9;
  28. 	public static byte R10;
  29. 	public static byte R11;
  30. 	public static byte R12;
  31. 	public static byte R13;
  32. 	public static byte R14;
  33. 	public static byte R15;
  34.  
  35.  
  36. 	private int numberOfLines = 1;
  37.  
  38. 	private JPanel panelLeft = new JPanel();
  39. 		private JScrollPane scrollPane = new JScrollPane(panelLeft);
  40. 		private JPanel lineNumbering = new JPanel();
  41. 			private JTextArea textArea = new JTextArea(numberOfLines, 30);
  42.  
  43. 	private JPanel panelRight;
  44. 		private JLabel[][] labels = new JLabel[2][18];
  45. 		private JButton start;
  46. 		private JButton reset;
  47.  
  48. 	Vam(){
  49. 		setSize(FRAME_WIDTH, FRAME_HEIGHT);
  50. 		setResizable(false);
  51. 		setLayout(new GridLayout(1, 2));
  52. 		setTitle("Virtual Assembler Machine");
  53. 		setDefaultCloseOperation(EXIT_ON_CLOSE);
  54.  
  55. 		textArea.addKeyListener(new MyKeyListener());
  56. 		scrollPane.getVerticalScrollBar().setUnitIncrement(10); //sets the scroll-speed
  57.  
  58. 		lineNumbering.setLayout(new GridLayout(numberOfLines, 2));
  59. 		for(int i=0; i<numberOfLines; ++i) {
  60. 			if(numberOfLines<10) {
  61. 				lineNumbering.add(new JLabel(String.valueOf(numberOfLines)+"   "));
  62. 			} else {
  63. 				lineNumbering.add(new JLabel(String.valueOf(numberOfLines)));
  64. 			}
  65. 			lineNumbering.add(new JLabel(":"));
  66. 		}
  67.  
  68. 		panelLeft.add(lineNumbering);
  69. 		panelLeft.add(textArea);
  70.  
  71. 		reset();
  72.  
  73. 		add(scrollPane);
  74. 		add(panelRight);
  75. 		setVisible(true);
  76. 	}
  77.  
  78. 	public class MyKeyListener implements KeyListener{
  79. 		@Override
  80. 		public void keyPressed(KeyEvent e) {
  81. 			if(e.getKeyCode() == KeyEvent.VK_ENTER) {
  82. 				System.out.println("ENTER " + textArea.getLineCount()+" "+numberOfLines);
  83. 				//System.out.println(textArea.getText());
  84. 				numberOfLines = textArea.getLineCount()+1;
  85. 				lineNumbering.setLayout(new GridLayout(numberOfLines, 2));
  86. 				if(numberOfLines<10) {
  87. 					lineNumbering.add(new JLabel(String.valueOf(numberOfLines)+"   "));
  88. 				} else {
  89. 					lineNumbering.add(new JLabel(String.valueOf(numberOfLines)));
  90. 				}
  91. 				lineNumbering.add(new JLabel(":"));
  92. 			}
  93.  
  94. 			if(e.getKeyCode() == KeyEvent.VK_BACK_SPACE) {
  95. 				System.out.println("BACKSPACE " + textArea.getLineCount()+" "+numberOfLines);
  96. 				//System.out.println(textArea.getText());
  97. 				if(textArea.getLineCount() == numberOfLines) {
  98. 					try {
  99. 						Robot r = new Robot();
  100. 						System.out.println("BACVCK");
  101. 						r.keyPress(KeyEvent.VK_BACK_SPACE);
  102. 						r.keyRelease(KeyEvent.VK_BACK_SPACE);
  103. 						System.out.println(textArea.getLineCount()+" "+numberOfLines);
  104. 						if(textArea.getLineCount() != numberOfLines) {
  105. 							numberOfLines = textArea.getLineCount()-1;
  106. 							lineNumbering.setLayout(new GridLayout(numberOfLines, 2));
  107. 							lineNumbering.remove(lineNumbering.getComponentCount()-1);
  108. 							lineNumbering.remove(lineNumbering.getComponentCount()-1);
  109. 						}
  110. 					}catch(Exception ex) {}
  111. 				}
  112. 			}
  113. 		}
  114.  
  115. 		@Override
  116. 		public void keyReleased(KeyEvent e) {}
  117.  
  118. 		@Override
  119. 		public void keyTyped(KeyEvent e) {}
  120. 	}
  121.  
  122. 	public String getFullText() {
  123. 		return textArea.getText();
  124. 	}
  125.  
  126. 	//line is the same number as the numbering of the lines on the right side 
  127. 	public String getTextInLine(int line) {
  128. 		String ret = textArea.getText();
  129. 		for(int i=0; i<line-1; ++i) {
  130. 			ret = ret.substring(ret.indexOf("\n")+1);
  131. 		}
  132. 		if(ret.contains("\n"))ret = ret.substring(0, ret.indexOf("\n"));
  133.  
  134. 		return ret;
  135. 	}
  136.  
  137. 	//call this method, to update the values 
  138. 	public JPanel rightPanel(byte[] by) {
  139. 		JPanel ret = new JPanel();
  140. 		ret.setLayout(new GridLayout(19, 2, 40, 0));
  141.  
  142. 		labels[0][0] = new JLabel("SR");
  143. 		labels[0][1] = new JLabel("BZ");
  144. 		labels[0][2] = new JLabel("A");
  145.  
  146. 		for (int i=0; i<15; ++i) {
  147. 			labels[0][i+3] = new JLabel("R"+(i+1));
  148. 		}
  149.  
  150. 		for(int i=0; i<18; i++) {
  151. 			labels[1][i] = new JLabel(String.format("%8s", Integer.toBinaryString(by[i] & 0xFF)).replace(' ', '0'));
  152. 		}
  153.  
  154. 		for(int i=0; i<18; i++) {
  155. 			ret.add(labels[0][i]);
  156. 			ret.add(labels[1][i]);
  157. 		}
  158.  
  159. 		start = new JButton(new AbstractAction("Start"){
  160.             public void actionPerformed(ActionEvent e) {
  161.             	start();
  162.             }
  163. 		});
  164.  
  165. 		reset = new JButton(new AbstractAction("Reset"){
  166.             public void actionPerformed(ActionEvent e) {
  167.             	reset();
  168.             }
  169. 		});
  170.  
  171. 		ret.add(start);
  172. 		ret.add(reset);
  173.  
  174. 		return ret;
  175. 	}
  176.  
  177. 	private void reset() {
  178. 		stop = false;
  179. 		SR = 0;
  180. 		BZ = 1;
  181. 		A = 0;
  182. 		R1 = 0;
  183. 		R2 = 0;
  184. 		R3 = 0;
  185. 		R4 = 0;
  186. 		R5 = 0;
  187. 		R6 = 0;
  188. 		R7 = 0;
  189. 		R8 = 0;
  190. 		R9 = 0;
  191. 		R10 = 0;
  192. 		R11 = 0;
  193. 		R12 = 0;
  194. 		R13 = 0;
  195. 		R14 = 0;
  196. 		R15 = 0;
  197.  
  198. 		byte[] by = {SR, BZ, A, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15};
  199. 		panelRight = rightPanel(by);
  200. 	}
  201.  
  202. 	private void start() {
  203. 		while(!stop) {
  204. 			check(getTextInLine(BZ));
  205. 		}
  206. 		byte[] by = {SR, BZ, A, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15};
  207. 		panelRight = rightPanel(by);
  208. 	}
  209.  
  210. 	private void def(String input) {//dafault
  211. 		System.out.println("unknown command: \"" + input +"\"");
  212. 	}
  213.  
  214. 	//calls the right method 
  215. 	private void execute(String command, String rest) {
  216. 		if(rest.length()>0) {
  217. 			if(rest.charAt(0) == ' ') {
  218. 				switch(command) {
  219. 				case "ADD":
  220. 					add(Integer.valueOf(rest.substring(1)));
  221. 					break;
  222. 				case "DLOAD":
  223. 					dload(Integer.valueOf(rest.substring(1)));
  224. 					break;
  225. 				case "DIV":
  226. 					div(Integer.valueOf(rest.substring(1)));
  227. 					break;
  228. 				case "JEQ":
  229. 					jeq(Integer.valueOf(rest.substring(1)));
  230. 					break;
  231. 				case "JGE":
  232. 					jge(Integer.valueOf(rest.substring(1)));
  233. 					break;
  234. 				case "JGT":
  235. 					jgt(Integer.valueOf(rest.substring(1)));
  236. 					break;
  237. 				case "JLE":
  238. 					jle(Integer.valueOf(rest.substring(1)));
  239. 					break;
  240. 				case "JLT":
  241. 					jlt(Integer.valueOf(rest.substring(1)));
  242. 					break;
  243. 				case "JNE":
  244. 					jne(Integer.valueOf(rest.substring(1)));
  245. 					break;
  246. 				case "JUMP":
  247. 					jump(Integer.valueOf(rest.substring(1)));
  248. 					break;
  249. 				case "LOAD":
  250. 					load(Integer.valueOf(rest.substring(1)));
  251. 					break;
  252. 				case "MULT":
  253. 					mult(Integer.valueOf(rest.substring(1)));
  254. 					break;
  255. 				case "STORE":
  256. 					store(Integer.valueOf(rest.substring(1)));
  257. 					break;
  258. 				case "SUB":
  259. 					sub(Integer.valueOf(rest.substring(1)));
  260. 					break;
  261. 				}
  262. 			}else {
  263. 				def(command+rest);
  264. 			}
  265.  
  266. 		}else {
  267. 			if(command.equals("END")) {
  268. 				end();
  269. 			}else {
  270. 				def(command+rest);
  271. 			}
  272. 		}
  273. 	}
  274.  
  275. 	private void end() {
  276. 		stop = true;
  277. 		BZ++;
  278. 	}
  279.  
  280. 	private void add(int number) {
  281. 		int i;
  282. 		int temp;
  283. 		switch(number) {
  284. 			case 1: i = R1;
  285. 			case 2: i = R2;
  286. 			case 3: i = R3;
  287. 			case 4: i = R4;
  288. 			case 5: i = R5;
  289. 			case 6: i = R6;
  290. 			case 7: i = R7;
  291. 			case 8: i = R8;
  292. 			case 9: i = R9;
  293. 			case 10: i = R10;
  294. 			case 11: i = R11;
  295. 			case 12: i = R12;
  296. 			case 13: i = R13;
  297. 			case 14: i = R14;
  298. 			case 15: i = R15;
  299. 			default: 
  300. 				System.out.println(number+"is not a valid register!");
  301. 				i=0;
  302. 				end();
  303. 		}
  304. 		temp=A+i;
  305.  
  306. 		SR = (byte) (SR & Byte.valueOf("11111100")); //set last 2 bit to 0
  307. 		if(temp>0) {
  308. 			SR = (byte) (SR | Byte.valueOf("00000010")); //set bit before last to 1
  309. 		}else {
  310. 			if(temp<0) {
  311. 				SR = (byte) (SR | Byte.valueOf("00000001"));//set last bit to 1
  312. 			}
  313. 		}
  314. 		if(temp<128&&temp>-129) {
  315. 			A=(byte)temp;
  316. 			SR = (byte) (SR & Byte.valueOf("11111011"));//set 6. bit to 0
  317. 										//           11111111112222222222333
  318. 	}else {								//  12345678901234567890123456789012
  319. 			A = (byte)(temp & Byte.valueOf("00000000000000000000000011111111"));
  320. 			SR = (byte) (SR | Byte.valueOf("00000100"));//set 6. bit to 1
  321. 		}
  322.  
  323. 		BZ++;
  324.  
  325. 	}
  326.  
  327. 	private void dload(int number) {
  328. 		if(number<128&&number>-129) {
  329. 			A = (byte)number;
  330. 		}else {
  331. 			System.out.println(number+" is too big");
  332. 		}
  333. 	}
  334.  
  335. 	private void div(int number) {
  336. 		int i;
  337. 		int temp;
  338. 		switch(number) {
  339. 			case 1: i = R1;
  340. 			case 2: i = R2;
  341. 			case 3: i = R3;
  342. 			case 4: i = R4;
  343. 			case 5: i = R5;
  344. 			case 6: i = R6;
  345. 			case 7: i = R7;
  346. 			case 8: i = R8;
  347. 			case 9: i = R9;
  348. 			case 10: i = R10;
  349. 			case 11: i = R11;
  350. 			case 12: i = R12;
  351. 			case 13: i = R13;
  352. 			case 14: i = R14;
  353. 			case 15: i = R15;
  354. 			default: 
  355. 				System.out.println(number+"is not a valid register!");
  356. 				i=0;
  357. 				end();
  358. 		}
  359. 		temp=A/i;
  360.  
  361. 		SR = (byte) (SR & Byte.valueOf("11111100")); //set last 2 bit to 0
  362. 		if(temp>0) {
  363. 			SR = (byte) (SR | Byte.valueOf("00000010")); //set bit before last to 1
  364. 		}else {
  365. 			if(temp<0) {
  366. 				SR = (byte) (SR | Byte.valueOf("00000001"));//set last bit to 1
  367. 			}
  368. 		}
  369. 		if(temp<128&&temp>-129) {
  370. 			A=(byte)temp;
  371. 			SR = (byte) (SR & Byte.valueOf("11111011"));//set 6. bit to 0
  372. 										//           11111111112222222222333
  373. 		}else {							//  12345678901234567890123456789012
  374. 			A = (byte)(temp & Byte.valueOf("00000000000000000000000011111111"));
  375. 			SR = (byte) (SR | Byte.valueOf("00000100"));//set 6. bit to 1
  376. 		}
  377. 		BZ++;
  378. 	}
  379.  
  380. 	private void jeq(int number) {
  381. 		String status = String.format("%8s", Integer.toBinaryString(SR & 0xFF)).replace(' ', '0');
  382. 		if(status.charAt(6)=='0'&&status.charAt(7)=='0') {
  383. 			BZ=(byte)number;
  384. 		}else {
  385. 			BZ++;
  386. 		}
  387. 	}
  388.  
  389. 	private void jge(int number) {
  390. 		String status = String.format("%8s", Integer.toBinaryString(SR & 0xFF)).replace(' ', '0');
  391. 		if(status.charAt(7)=='0') {
  392. 			BZ=(byte)number;
  393. 		}else {
  394. 			BZ++;
  395. 		}
  396. 	}
  397.  
  398. 	private void jgt(int number) {
  399. 		String status = String.format("%8s", Integer.toBinaryString(SR & 0xFF)).replace(' ', '0');
  400. 		if(status.charAt(6)=='1') {
  401. 			BZ=(byte)number;
  402. 		}else {
  403. 			BZ++;
  404. 		}
  405. 	}
  406.  
  407. 	private void jle(int number) {
  408. 		String status = String.format("%8s", Integer.toBinaryString(SR & 0xFF)).replace(' ', '0');
  409. 		if(status.charAt(6)=='0') {
  410. 			BZ=(byte)number;
  411. 		}else {
  412. 			BZ++;
  413. 		}
  414. 	}
  415.  
  416. 	private void jlt(int number) {
  417. 		String status = String.format("%8s", Integer.toBinaryString(SR & 0xFF)).replace(' ', '0');
  418. 		if(status.charAt(7)=='0') {
  419. 			BZ=(byte)number;
  420. 		}else {
  421. 			BZ++;
  422. 		}
  423. 	}
  424.  
  425. 	private void jne(int number) {
  426. 		String status = String.format("%8s", Integer.toBinaryString(SR & 0xFF)).replace(' ', '0');
  427. 		if(status.charAt(6)=='1'||status.charAt(7)=='1') {
  428. 			BZ=(byte)number;
  429. 		}else {
  430. 			BZ++;
  431. 		}
  432. 	}
  433.  
  434. 	private void jump(int number) {
  435. 		BZ = (byte)number;
  436. 	}
  437.  
  438. 	private void load(int number) {
  439. 		int i;
  440. 		switch(number) {
  441. 			case 1: i = R1;
  442. 			case 2: i = R2;
  443. 			case 3: i = R3;
  444. 			case 4: i = R4;
  445. 			case 5: i = R5;
  446. 			case 6: i = R6;
  447. 			case 7: i = R7;
  448. 			case 8: i = R8;
  449. 			case 9: i = R9;
  450. 			case 10: i = R10;
  451. 			case 11: i = R11;
  452. 			case 12: i = R12;
  453. 			case 13: i = R13;
  454. 			case 14: i = R14;
  455. 			case 15: i = R15;
  456. 			default: 
  457. 				System.out.println(number+"is not a valid register!");
  458. 				i=0;
  459. 				end();
  460. 		}
  461. 		A=(byte)i;
  462.  
  463. 		SR = (byte) (SR & Byte.valueOf("11111100")); //set last 2 bit to 0
  464. 		if(A>0) {
  465. 			SR = (byte) (SR | Byte.valueOf("00000010")); //set bit before last to 1
  466. 		}else {
  467. 			if(A<0) {
  468. 				SR = (byte) (SR | Byte.valueOf("00000001"));//set last bit to 1
  469. 			}
  470. 		}
  471. 		BZ++;
  472. 	}
  473.  
  474. 	private void mult(int number) {
  475. 		int i;
  476. 		int temp;
  477. 		switch(number) {
  478. 			case 1: i = R1;
  479. 			case 2: i = R2;
  480. 			case 3: i = R3;
  481. 			case 4: i = R4;
  482. 			case 5: i = R5;
  483. 			case 6: i = R6;
  484. 			case 7: i = R7;
  485. 			case 8: i = R8;
  486. 			case 9: i = R9;
  487. 			case 10: i = R10;
  488. 			case 11: i = R11;
  489. 			case 12: i = R12;
  490. 			case 13: i = R13;
  491. 			case 14: i = R14;
  492. 			case 15: i = R15;
  493. 			default: 
  494. 				System.out.println(number+"is not a valid register!");
  495. 				i=0;
  496. 				end();
  497. 		}
  498. 		temp=A*i;
  499.  
  500. 		SR = (byte) (SR & Byte.valueOf("11111100")); //set last 2 bit to 0
  501. 		if(temp>0) {
  502. 			SR = (byte) (SR | Byte.valueOf("00000010")); //set bit before last to 1
  503. 		}else {
  504. 			if(temp<0) {
  505. 				SR = (byte) (SR | Byte.valueOf("00000001"));//set last bit to 1
  506. 			}
  507. 		}
  508. 		if(temp<128&&temp>-129) {
  509. 			A=(byte)temp;
  510. 			SR = (byte) (SR & Byte.valueOf("11111011"));//set 6. bit to 0
  511. 										//           11111111112222222222333
  512. 		}else {							//  12345678901234567890123456789012
  513. 			A = (byte)(temp & Byte.valueOf("00000000000000000000000011111111"));
  514. 			SR = (byte) (SR | Byte.valueOf("00000100"));//set 6. bit to 1
  515. 		}
  516. 		BZ++;
  517. 	}
  518.  
  519. 	private void store(int number) {
  520. 		switch(number) {
  521. 			case 1: R1 = A;
  522. 			case 2: R2 = A;
  523. 			case 3: R3 = A;
  524. 			case 4: R4 = A;
  525. 			case 5: R5 = A;
  526. 			case 6: R6 = A;
  527. 			case 7: R7 = A;
  528. 			case 8: R8 = A;
  529. 			case 9: R9 = A;
  530. 			case 10: R10 = A;
  531. 			case 11: R11 = A;
  532. 			case 12: R12 = A;
  533. 			case 13: R13 = A;
  534. 			case 14: R14 = A;
  535. 			case 15: R15 = A;
  536. 			default: 
  537. 				System.out.println(number+"is not a valid register!");
  538. 				end();
  539. 		}
  540. 	}
  541.  
  542. 	private void sub(int number) {
  543. 		int i;
  544. 		int temp;
  545. 		switch(number) {
  546. 			case 1: i = R1;
  547. 			case 2: i = R2;
  548. 			case 3: i = R3;
  549. 			case 4: i = R4;
  550. 			case 5: i = R5;
  551. 			case 6: i = R6;
  552. 			case 7: i = R7;
  553. 			case 8: i = R8;
  554. 			case 9: i = R9;
  555. 			case 10: i = R10;
  556. 			case 11: i = R11;
  557. 			case 12: i = R12;
  558. 			case 13: i = R13;
  559. 			case 14: i = R14;
  560. 			case 15: i = R15;
  561. 			default: 
  562. 				System.out.println(number+"is not a valid register!");
  563. 				i=0;
  564. 				end();
  565. 		}
  566. 		temp=A-i;
  567.  
  568. 		SR = (byte) (SR & Byte.valueOf("11111100")); //set last 2 bit to 0
  569. 		if(temp>0) {
  570. 			SR = (byte) (SR | Byte.valueOf("00000010")); //set bit before last to 1
  571. 		}else {
  572. 			if(temp<0) {
  573. 				SR = (byte) (SR | Byte.valueOf("00000001"));//set last bit to 1
  574. 			}
  575. 		}
  576. 		if(temp<128&&temp>-129) {
  577. 			A=(byte)temp;
  578. 			SR = (byte) (SR & Byte.valueOf("11111011"));//set 6. bit to 0
  579. 										//           11111111112222222222333
  580. 		}else {							//  12345678901234567890123456789012
  581. 			A = (byte)(temp & Byte.valueOf("00000000000000000000000011111111"));
  582. 			SR = (byte) (SR | Byte.valueOf("00000100"));//set 6. bit to 1
  583. 		}
  584. 		BZ++;
  585. 	}
  586.  
  587. 	//separates the command and the rest
  588. 	public void check(String input) {
  589. 		switch(input.charAt(0)){
  590. 		case 'A'://A
  591. 			switch(input.charAt(1)){
  592. 			case 'D'://AD
  593. 				switch(input.charAt(2)){
  594. 				case 'D'://ADD
  595. 					execute(input.substring(0, 3), input.substring(3));
  596. 					break;
  597. 				default:
  598. 					def(input);
  599. 					break;
  600. 				}
  601. 				break;
  602. 			default:
  603. 				def(input);
  604. 				break;
  605. 			}
  606. 			break;
  607. 		case 'D'://D
  608. 			switch(input.charAt(1)){
  609. 			case 'L'://DL
  610. 				switch(input.charAt(2)){
  611. 				case 'O'://DLO
  612. 					switch(input.charAt(3)){
  613. 					case 'A'://DLOA
  614. 						switch(input.charAt(4)){
  615. 						case 'D'://DLOAD
  616. 							execute(input.substring(0, 5), input.substring(5));
  617. 							break;
  618. 						default:
  619. 							def(input);
  620. 							break;
  621. 						}
  622. 						break;
  623. 					default:
  624. 						def(input);
  625. 						break;
  626. 					}
  627. 					break;
  628. 				default:
  629. 					def(input);
  630. 					break;
  631. 				}
  632. 				break;
  633. 			case 'I'://DI
  634. 				switch(input.charAt(2)){
  635. 				case 'V'://DIV
  636. 					execute(input.substring(0, 3), input.substring(3));
  637. 					break;
  638. 				default:
  639. 					def(input);
  640. 					break;
  641. 				}
  642. 				break;
  643. 			default:
  644. 				def(input);
  645. 				break;
  646. 			}
  647. 			break;
  648. 		case 'E'://E
  649. 			switch(input.charAt(1)){
  650. 			case 'N'://EN
  651. 				switch(input.charAt(2)){
  652. 				case 'D'://END
  653. 					execute(input.substring(0, 3), input.substring(3));
  654. 					break;
  655. 				default:
  656. 					def(input);
  657. 					break;
  658. 				}
  659. 				break;
  660. 			default:
  661. 				def(input);
  662. 				break;
  663. 			}
  664. 			break;
  665.  
  666. 		case 'J'://J
  667. 			switch(input.charAt(1)){
  668. 			case 'E'://JE
  669. 				switch(input.charAt(2)){
  670. 				case 'Q'://JEQ
  671. 					execute(input.substring(0, 3), input.substring(3));
  672. 					break;
  673. 				default:
  674. 					def(input);
  675. 					break;
  676. 				}
  677. 				break;
  678. 			default:
  679. 				def(input);
  680. 				break;
  681. 			case 'G'://JG
  682. 				switch(input.charAt(2)){
  683. 				case 'E'://JGE
  684. 					execute(input.substring(0, 3), input.substring(3));
  685. 				case 'T'://JGT
  686. 					execute(input.substring(0, 3), input.substring(3));
  687. 				default:
  688. 					def(input);
  689. 				}
  690. 			case 'L'://JL
  691. 				switch(input.charAt(2)){
  692. 				case 'E'://JLE
  693. 					execute(input.substring(0, 3), input.substring(3));
  694. 				case 'T'://JLT
  695. 					execute(input.substring(0, 3), input.substring(3));
  696. 				default:
  697. 					def(input);
  698. 				}
  699. 			case 'N'://JN
  700. 				switch(input.charAt(2)){
  701. 				case 'E'://JNE
  702. 					execute(input.substring(0, 3), input.substring(3));
  703. 				default:
  704. 					def(input);
  705. 				}
  706. 			case 'U'://JU
  707. 				switch(input.charAt(2)){
  708. 				case 'M'://JUM
  709. 					switch(input.charAt(3)){
  710. 					case 'P'://JUMP
  711. 						execute(input.substring(0, 4), input.substring(4));
  712. 					default:
  713. 						def(input);
  714. 					}
  715. 				default:
  716. 					def(input);
  717. 				}				
  718. 			}
  719. 		case 'L'://L
  720. 			switch(input.charAt(1)){
  721. 			case 'O'://LO
  722. 				switch(input.charAt(2)){
  723. 				case 'A'://LOA
  724. 					switch(input.charAt(3)){
  725. 					case 'D'://LOAD
  726. 						execute(input.substring(0, 4), input.substring(4));
  727. 					default:
  728. 						def(input);
  729. 					}
  730. 				default:
  731. 					def(input);
  732. 				}
  733. 			default:
  734. 				def(input);
  735. 			}
  736.  
  737. 		case 'M'://M
  738. 			switch(input.charAt(1)){
  739. 			case 'U'://MU
  740. 				switch(input.charAt(2)){
  741. 				case 'L'://MUL
  742. 					switch(input.charAt(3)){
  743. 					case 'T'://MULT
  744. 						execute(input.substring(0, 4), input.substring(4));
  745. 					default:
  746. 						def(input);
  747. 					}
  748. 				default:
  749. 					def(input);
  750. 				}
  751. 			default:
  752. 				def(input);
  753. 			}
  754.  
  755. 		case 'S'://S
  756. 			switch(input.charAt(1)){
  757. 			case 'T'://ST
  758. 				switch(input.charAt(2)){
  759. 				case 'O'://STO
  760. 					switch(input.charAt(3)){
  761. 					case 'R'://STOR
  762. 						switch(input.charAt(4)){
  763. 						case 'E'://STORE
  764. 							execute(input.substring(0, 5), input.substring(5));
  765. 						default:
  766. 							def(input);
  767. 						}
  768. 					default:
  769. 						def(input);
  770. 					}
  771. 				default:
  772. 					def(input);
  773. 				}
  774. 			case 'U'://SU
  775. 				switch(input.charAt(2)){
  776. 				case 'B'://SUB
  777. 					execute(input.substring(0, 3), input.substring(3));
  778. 				default:
  779. 					def(input);
  780. 				}
  781. 			default:
  782. 				def(input);
  783. 			}
  784.  
  785. 		default:
  786. 			def(input);
  787. 		}
  788. 	}
  789.  
  790. 	public static void main(String args[]) {
  791. 		new Vam();
  792. 	}
  793. }
  794.  
  795. /* Just a simple program to test:
  796. DLOAD 10
  797. LOAD 1
  798. DLOAD 2
  799. ADD 1
  800. LOAD 2
  801. END
  802.  */
Compilation error #stdin compilation error #stdout 0s 0KB
comments (?)
stdin
copy 
Standard input is empty
compilation info 
Main.java:9: error: class Vam is public, should be declared in a file named Vam.java
public class Vam extends JFrame{
       ^
1 error
stdout
copy 
Standard output is empty
https://ideone.com/rPoJbB
language:
Java (HotSpot 12)
created:
5 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!