fork download 
  1. import java.util.*;
  2. import java.lang.*;
  3. import java.io.*;
  4. import java.util.regex.*;
  5.  
  6. class Ideone
  7. {
  8. 	public static void main (String[] args) throws java.lang.Exception
  9. 	{
  10. 		try {
  11. 			BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
  12. 			Excutor excutor = new Excutor();
  13. 			String line;
  14. 			while ((line = in.readLine()) != null) {
  15. 				try {
  16. 					List<Token> tokens = Tokenizer.tokenize(line);
  17. 					if (excutor.doEditorCommand(tokens) < 0) {
  18. 						break;
  19. 					}
  20. 				} catch (SyntaxError er) {
  21. 					System.out.println(er);
  22. 				}
  23. 			}
  24. //			System.out.println(excutor);
  25. 		} catch (Exception ex) {
  26. 			System.out.println(ex);
  27. 		}
  28.  
  29. 	}
  30. }
  31.  
  32. enum TokenType
  33. {
  34. 	INT, DBL, STR, NAME, SYMBL, SHARP, SEMICOLON,
  35. 	OP_BRKT, CL_BRKT, COMMA, COLON, UNKNOWN
  36. }
  37.  
  38. final class Token
  39. {
  40. 	final TokenType type;
  41. 	final String token;
  42. 	public Token(TokenType type, String token)
  43. 	{
  44. 		this.type = type;
  45. 		this.token = token;
  46. 	}
  47. 	public TokenType getType() { return type; }
  48. 	public String getToken() { return token; }
  49. 	@Override
  50. 	public String toString()
  51. 	{
  52. 		return "[" + type + " : " + token + "]";
  53. 	}
  54.  
  55. 	public boolean isInt() { return TokenType.INT.equals(type); }
  56. 	public boolean isStr() { return TokenType.STR.equals(type); }
  57. 	public boolean isDbl() { return TokenType.DBL.equals(type); }
  58. 	public boolean isName() { return TokenType.NAME.equals(type); }
  59. 	public boolean isSymbl() { return TokenType.SYMBL.equals(type); }
  60. 	public boolean isOpBrkt() { return TokenType.OP_BRKT.equals(type); }
  61. 	public boolean isClBrkt() { return TokenType.CL_BRKT.equals(type); }
  62. 	public boolean isColon() { return TokenType.COLON.equals(type); }
  63. 	public boolean isSemiColon() { return TokenType.SEMICOLON.equals(type); }
  64. 	public boolean isComma() { return TokenType.COMMA.equals(type); }
  65. 	public boolean isSharp() { return TokenType.SHARP.equals(type); }
  66. }
  67.  
  68. class SyntaxError extends java.lang.Exception
  69. {
  70. 	public SyntaxError(String msg) { super(msg); }
  71. 	public SyntaxError(Throwable ex) { super(ex); }
  72. 	public SyntaxError(List<Token> tokens, int index)
  73. 	{
  74. 		super("token index(" + index + "): " + tokens.toString());
  75. 	}
  76. }
  77.  
  78. final class TokenError extends SyntaxError
  79. {
  80. 	public TokenError(String line) { super(line); }
  81. }
  82.  
  83. final class Tokenizer
  84. {
  85. 	private static Pattern p_space = Pattern.compile("^\\s+");
  86. 	private static Pattern p_int = Pattern.compile("^\\d+");
  87. 	private static Pattern p_dbl = Pattern.compile("^\\d*\\.\\d+");
  88. 	private static Pattern p_str = Pattern.compile("^\"(\"\"|[^\"])*\"");
  89. 	private static Pattern p_name = Pattern.compile("^[A-Za-z][A-Za-z0-9]*\\$?");
  90. 	private static Pattern p_symbl = Pattern.compile("^(>=|<=|<>|[=<>+\\*/-])");
  91.  
  92. 	public static List<Token> tokenize(String line) throws TokenError
  93. 	{
  94. 		List<Token> list = new ArrayList<Token>();
  95. 		Matcher m = null;
  96. 		TokenType type = null;
  97. 		String token = null;
  98. 		int offset = 0;
  99.  
  100. 		while (line.length() > 0) {
  101. 			if ((m = p_space.matcher(line)).lookingAt()) {
  102. 				line = line.substring(m.end());
  103. 				continue;
  104. 			} else if ((m = p_dbl.matcher(line)).lookingAt()) {
  105. 				type = TokenType.DBL;
  106. 			} else if ((m = p_int.matcher(line)).lookingAt()) {
  107. 				type = TokenType.INT;
  108. 			} else if ((m = p_str.matcher(line)).lookingAt()) {
  109. 				type = TokenType.STR;
  110. 			} else if ((m = p_name.matcher(line)).lookingAt()) {
  111. 				type = TokenType.NAME;
  112. 			} else if ((m = p_symbl.matcher(line)).lookingAt()) {
  113. 				type = TokenType.SYMBL;
  114. 			} else {
  115. 				m = null;
  116. 				offset = 1;
  117. 				if (line.startsWith(token = "(")) {
  118. 					type = TokenType.OP_BRKT;
  119. 				} else if (line.startsWith(token = ")")) {
  120. 					type = TokenType.CL_BRKT;
  121. 				} else if (line.startsWith(token = ":")) {
  122. 					type = TokenType.COLON;
  123. 				} else if (line.startsWith(token = ",")) {
  124. 					type = TokenType.COMMA;
  125. 				} else if (line.startsWith(token = "#")) {
  126. 					type = TokenType.SHARP;
  127. 				} else if (line.startsWith(token = ";")) {
  128. 					type = TokenType.SEMICOLON;
  129. 				} else {
  130. 					throw new TokenError(line);
  131. 				}
  132. 			}
  133. 			if (m != null) {
  134. 				token = m.group();
  135. 				if (TokenType.NAME.equals(type)) {
  136. 					token = token.toUpperCase();
  137. 				}
  138. 				offset = m.end();
  139. 			}
  140. 			list.add(new Token(type, token));
  141. 			line = line.substring(offset);
  142. 		}
  143. 		return list;
  144. 	}
  145. }
  146.  
  147. final class ExcuteError extends SyntaxError
  148. {
  149. 	public ExcuteError(Throwable ex) { super(ex); } 
  150. 	public ExcuteError(String msg) { super(msg); } 
  151. }
  152.  
  153. class VarArray<T>
  154. {
  155.  
  156. }
  157.  
  158. enum ResultType
  159. {
  160. 	INT, DBL, STR
  161. }
  162.  
  163. class Result
  164. {
  165. 	private int offset;
  166. 	private int intvalue = 0;
  167. 	private double dblvalue = 0;
  168. 	private String strvalue = null;
  169. 	private ResultType type;
  170.  
  171. 	public ResultType getType()
  172. 	{
  173. 		return type;
  174. 	}	
  175.  
  176. 	public int getOffset()
  177. 	{
  178. 		return offset;
  179. 	}
  180.  
  181. 	public Number getNumValue()
  182. 	{
  183. 		if (ResultType.INT.equals(type)) {
  184. 			return Integer.valueOf(intvalue);
  185. 		} else if (ResultType.DBL.equals(type)) {
  186. 			return Double.valueOf(dblvalue);
  187. 		} else {
  188. 			return null;
  189. 		}
  190. 	}
  191. 	public String getStrValue()
  192. 	{
  193. 		return strvalue;
  194. 	}
  195. }
  196.  
  197. final class Excutor
  198. {
  199. 	private NavigableMap<Integer, List<Token>> program = new TreeMap<Integer, List<Token>>();
  200.  
  201. 	private Map<String, VarArray<String>> strarrs = new HashMap<String, VarArray<String>>();
  202. 	private Map<String, VarArray<Number>> numarrs = new HashMap<String, VarArray<Number>>();
  203. 	private Map<String, String> strvars = new HashMap<String, String>();
  204. 	private Map<String, Number> numvars = new HashMap<String, Number>();
  205.  
  206. 	private Integer programcounter = null;
  207. 	private Deque<Integer> programcounterstack = new ArrayDeque<Integer>();
  208.  
  209. 	private int arraybase = 0;
  210. 	private boolean jumpflag = false;
  211.  
  212. 	public Excutor() {}
  213.  
  214. 	private void printLine(Integer linenum, List<Token> tokens)
  215. 	{
  216. 		System.out.printf("%05d ", linenum.intValue());
  217. 		TokenType before = null, type;
  218. 		for (int i = 1; i < tokens.size(); i++) {
  219. 			Token token = tokens.get(i);
  220. 			type = token.getType();
  221. 			if (TokenType.NAME.equals(before)) {
  222. 				switch (type) {
  223. 					case NAME:
  224. 					case INT:
  225. 					case DBL:
  226. 					case SHARP:
  227. 					case STR:
  228. 						System.out.print(' ');
  229. 						break;
  230. 					default:
  231. 						break;
  232. 				}
  233. 			}
  234. 			System.out.print(tokens.get(i).getToken());
  235. 			before = type;
  236. 		}
  237. 		System.out.println();
  238. 	}
  239.  
  240. 	private Result calc(List<Token> tokens, int index) throws SyntaxError
  241. 	{
  242. 		if (index >= tokens.size()) {
  243. 			throw new SyntaxError(tokens, index);
  244. 		}
  245.  
  246. 		Token cur = tokens.get(index);
  247. 		TokenType type = cur.getType();
  248. 		String token = cur.getToken();
  249.  
  250. 		switch (type) {
  251. 			case INT:
  252. 			case DBL:
  253. 			case STR:
  254. 			case SYMBL:
  255. 			case OP_BRKT:
  256. 				break;
  257. 			default:
  258. 				break;
  259. 		}
  260.  
  261. 		// 最初のトークンから始まる項を取得しスタックに上げ
  262. 		// その項の次のトークンである演算子をスタックに上げ
  263. 		// その演算子の次のトークンから始まる項をスタックに上げ
  264. 		// その次に演算子が来たら演算子の優先順位が
  265. 		//  ・高かったらその次の項の読み出し
  266. 		//  ・低かったら スタックにある演算子で演算
  267. 		// 
  268.  
  269. 		return null;
  270. 	}
  271.  
  272. 	public int doEditorCommand(List<Token> tokens) throws SyntaxError
  273. 	{
  274. 		if (tokens == null || tokens.isEmpty()) {
  275. 			return 0;
  276. 		}
  277.  
  278. 		Token first = tokens.get(0);
  279. 		String token = first.getToken();
  280. 		TokenType type = first.getType();
  281.  
  282. 		if (TokenType.INT.equals(type)) {
  283. 			Integer tmpint = Integer.valueOf(token);
  284. 			if (tmpint.intValue() < 1) {
  285. 				throw new SyntaxError(token);
  286. 			}
  287. 			program.put(tmpint, tokens);
  288. 			return 0;
  289. 		} else if (TokenType.NAME.equals(type) == false) {
  290. 			throw new ExcuteError(token);
  291. 		}
  292. 		switch (token) {
  293. 			case "CONT": // プログラムの再開
  294. 			case "EXIT": // インタプリタの終了
  295. 				return -1;
  296. 			case "LIST": // プログラムの表示
  297. 				do_list(tokens);
  298. 				break;
  299. 			case "LOAD": // プログラムのロード
  300. 			case "NEW":  // プログラムと変数の全消去
  301. 			case "RENUM": // プログラムの行番号再割り当て
  302. 				break;
  303. 			case "RUN":  // プログラムの実行
  304. 				do_run(tokens);
  305. 				break;
  306. 			case "SAVE": // プログラムの保存
  307. 				break;
  308. 			default:
  309. 				excute(tokens, 0);
  310. 				break;
  311. 		}
  312. 		System.out.println("Ok");
  313. 		return 0;
  314. 	}
  315.  
  316. 	private void do_list(List<Token> tokens) throws SyntaxError
  317. 	{
  318. 		Integer start = null;
  319. 		Integer end = null;
  320. 		Token first, second, third;
  321. 		Map<Integer, List<Token>> list = null;
  322. 		try {
  323. 			switch (tokens.size()) {
  324. 				case 1:
  325. 					list = program;
  326. 					break;
  327. 				case 2:
  328. 					first = tokens.get(1);
  329. 					if (TokenType.INT.equals(first.getType()) == false) {
  330. 						throw new SyntaxError(tokens ,1);
  331. 					}
  332. 					start = Integer.valueOf(first.getToken());
  333. 					if (start.intValue() < 1) {
  334. 						throw new SyntaxError(tokens ,1);
  335. 					}
  336. 					list = program.tailMap(start);
  337. 					break;
  338. 				case 3:
  339. 					if ("-".equals(tokens.get(1).getToken()) == false) {
  340. 						throw new SyntaxError(tokens ,1);
  341. 					}
  342. 					second = tokens.get(2);
  343. 					if (TokenType.INT.equals(second.getType()) == false) {
  344. 						throw new SyntaxError(tokens ,2);
  345. 					}
  346. 					end = Integer.valueOf(second.getToken());
  347. 					if (end.intValue() < 1) {
  348. 						throw new SyntaxError(tokens ,2);
  349. 					}
  350. 					list = program.headMap(end, true);
  351. 					break;
  352. 				case 4:
  353. 					first = tokens.get(1);
  354. 					if (TokenType.INT.equals(first.getType()) == false) {
  355. 						throw new SyntaxError(tokens ,1);
  356. 					}
  357. 					start = Integer.valueOf(first.getToken());
  358. 					if (start.intValue() < 1) {
  359. 						throw new SyntaxError(tokens ,1);
  360. 					}
  361. 					if ("-".equals(tokens.get(2).getToken()) == false) {
  362. 						throw new SyntaxError(tokens ,2);
  363. 					}
  364. 					third = tokens.get(3);
  365. 					if (TokenType.INT.equals(third.getType()) == false) {
  366. 						throw new SyntaxError(tokens ,3);
  367. 					}
  368. 					end = Integer.valueOf(third.getToken());
  369. 					if (end.intValue() < 1) {
  370. 						throw new SyntaxError(tokens ,3);
  371. 					}
  372. 					list = program.subMap(start, true, end, true);
  373. 					break;
  374. 				default:
  375. 					throw new SyntaxError(tokens, 0);
  376. 			}
  377. 		} catch (SyntaxError er) {
  378. 			throw er;
  379. 		} catch (Exception ex) {
  380. 			throw new ExcuteError(ex);
  381. 		}
  382.  
  383. 		if (list == null) {
  384. 			return;
  385. 		}
  386.  
  387. 		for (Integer key: list.keySet()) {
  388. 			printLine(key, list.get(key));
  389. 		}
  390.  
  391. 	}
  392.  
  393. 	private void do_run(List<Token> tokens) throws SyntaxError
  394. 	{
  395. 		switch (tokens.size()) {
  396. 			case 1:
  397. 				programcounter = program.ceilingKey(Integer.valueOf(1));
  398. 				if (programcounter == null) {
  399. 					throw new SyntaxError("Program is not found");
  400. 				}
  401. 				break;
  402. 			case 2:
  403. 				Token first = tokens.get(1);
  404. 				if (TokenType.INT.equals(first.getType()) == false) {
  405. 					throw new SyntaxError("Illegal Argument");
  406. 				}
  407. 				programcounter = Integer.valueOf(first.getToken());
  408. 				if (programcounter.intValue() < 1) {
  409. 					throw new SyntaxError("Wrong Line Number");
  410. 				}
  411. 				if (program.containsKey(programcounter) == false) {
  412. 					throw new SyntaxError("Not found Line Number");
  413. 				}
  414. 				break;
  415. 			default:
  416. 				throw new SyntaxError("Illegal Arguments");
  417. 		}
  418.  
  419. 		List<Token> line = null;
  420. 		try {
  421. 			while (programcounter != null) {
  422. 				line = program.get(programcounter);
  423. 				excute(line, 1);
  424. 				if (jumpflag == false) {
  425. 					programcounter = program.higherKey(programcounter);
  426. 				} else {
  427. 					jumpflag = false;
  428. 				}
  429. 			}
  430. 		} catch (SyntaxError er) {
  431. 			System.out.println(line);
  432. 			throw er;
  433. 		}
  434.  
  435. 	}
  436.  
  437. 	private int excute(List<Token> tokens, int index) throws SyntaxError
  438. 	{
  439. 		if (index < 0 || index >= tokens.size()) {
  440. 			return tokens.size();
  441. 		}
  442. 		Token first = tokens.get(index);
  443. 		TokenType type = first.getType();
  444.  
  445. 		while (TokenType.COLON.equals(type)) {
  446. 			index++;
  447. 			if (index == tokens.size()) {
  448. 				return index;
  449. 			}
  450. 			first = tokens.get(index);
  451. 			type = first.getType();
  452. 		}
  453.  
  454. 		if (TokenType.NAME.equals(type) == false) {
  455. 			throw new SyntaxError(first.toString());
  456. 		}
  457. 		String cmd = first.getToken();
  458. 		int offset = index;
  459. 		switch (cmd) {
  460. 			case "BASE": // 配列の下限(0/1)の設定
  461. 				offset = cmd_base(tokens, index + 1);
  462. 				break;
  463. 			case "BREAK": // FORループの脱出
  464. 			case "DATA": // データの列挙
  465. 			case "DIM":  // 配列変数の宣言
  466. 			case "ELSE": // IF文のELSE節の開始
  467. 			case "END":  // プログラムの終了
  468. 			case "FILE": // ファイルの割り当て
  469. 			case "FOR":  // 繰り返し
  470. 				break;
  471. 			case "GO":   // GOTOの分割トークン
  472. 				if (index + 2 >= tokens.size()) {
  473. 					throw new SyntaxError(tokens, index);
  474. 				}
  475. 				if ("TO".equals(tokens.get(index + 1).getToken()) == false) {
  476. 					throw new SyntaxError(tokens, index);
  477. 				}
  478. 				offset = cmd_goto(tokens, index + 2);
  479. 				break;
  480. 			case "GOTO": // ジャンプ
  481. 				offset = cmd_goto(tokens, index + 1);
  482. 				break;
  483. 			case "GOSUB": // サブルーチンジャンプ
  484. 				offset = cmd_gosub(tokens, index + 1);
  485. 				break;
  486. 			case "IF":    // 条件節
  487. 			case "INPUT": // キーボードからの値の入力
  488. 				break;
  489. 			case "LET":   // 変数への代入
  490. 				offset = cmd_let(tokens, index + 1);
  491. 				break;
  492. 			case "NEXT":  // FOR文の末端
  493. 			case "PRINT": // 画面へ値を出力
  494. 				break;
  495. 			case "REM":   // コメント行
  496. 				offset = tokens.size();
  497. 				break;
  498. 			case "RESTORE": // データ・ファイルの読み込み位置のリセット
  499. 				break;
  500. 			case "RETURN": // サブルーチンからの脱出
  501. 				offset = cmd_return(tokens, index);
  502. 				break;
  503. 			case "STOP":   // プログラムの中断
  504. 				break;
  505. 			default:
  506. 				offset = cmd_let(tokens, index);
  507. 				break;
  508. 		}
  509. 		return offset;
  510. 	}
  511.  
  512. 	@Override
  513. 	public String toString()
  514. 	{
  515. 		return program.toString().replaceAll("(\\d+=\\[\\[)", "\n$1");
  516. 	}
  517.  
  518. 	private int cmd_goto(List<Token> tokens, int index) throws SyntaxError
  519. 	{
  520. 		if (index >= tokens.size()) {
  521. 			throw new SyntaxError(tokens, index);
  522. 		}
  523. 		if (index + 1 < tokens.size()) {
  524. 			if (TokenType.COLON.equals(tokens.get(index + 1).getType()) == false) {
  525. 				throw new SyntaxError(tokens, index + 1);
  526. 			}
  527. 		}
  528. 		Token first = tokens.get(index);
  529. 		if (TokenType.INT.equals(first.getType()) == false) {
  530. 			throw new SyntaxError(tokens, index);
  531. 		}
  532. 		Integer next = Integer.valueOf(first.getToken());
  533. 		if (program.containsKey(next) == false) {
  534. 			throw new SyntaxError(tokens, index);
  535. 		}
  536. 		programcounter = next;
  537. 		jumpflag = true;
  538. 		return tokens.size();
  539. 	}
  540.  
  541. 	private int cmd_gosub(List<Token> tokens, int index) throws SyntaxError
  542. 	{
  543. 		if (index >= tokens.size()) {
  544. 			throw new SyntaxError(tokens, index);
  545. 		}
  546. 		if (index + 1 < tokens.size()) {
  547. 			if (TokenType.COLON.equals(tokens.get(index + 1).getType()) == false) {
  548. 				throw new SyntaxError(tokens, index + 1);
  549. 			}
  550. 		}
  551. 		Token first = tokens.get(index);
  552. 		if (TokenType.INT.equals(first.getType()) == false) {
  553. 			throw new SyntaxError(tokens, index);
  554. 		}
  555. 		Integer next = Integer.valueOf(first.getToken());
  556. 		if (program.containsKey(next) == false) {
  557. 			throw new SyntaxError(tokens, index);
  558. 		}
  559. 		try {
  560. 			programcounterstack.push(programcounter);
  561. 			programcounter = next;
  562. 			jumpflag = true;
  563. 			return tokens.size();
  564. 		} catch (Exception ex) {
  565. 			throw new ExcuteError(ex);
  566. 		}
  567. 	}
  568.  
  569. 	private int cmd_return(List<Token> tokens, int index) throws SyntaxError
  570. 	{
  571. 		if (index < tokens.size()) {
  572. 			if (TokenType.COLON.equals(tokens.get(index).getType()) == false) {
  573. 				throw new SyntaxError(tokens, index);
  574. 			}
  575. 		}
  576. 		try {
  577. 			Integer back = programcounterstack.pop();
  578. 			programcounter = program.higherKey(back);
  579. 			jumpflag = true;
  580. 			return tokens.size();
  581. 		} catch (Exception ex) {
  582. 			throw new ExcuteError(ex);
  583. 		}
  584. 	}
  585.  
  586.  
  587. 	private int cmd_base(List<Token> tokens, int index) throws SyntaxError
  588. 	{
  589. 		try {
  590. 			Token first = tokens.get(index);
  591. 			if (TokenType.INT.equals(first.getType()) == false) {
  592. 				throw new SyntaxError(tokens, index);
  593. 			}
  594. 			int tmpint = Integer.parseInt(first.getToken());
  595. 			if (tmpint != 0 && tmpint != 1) {
  596. 				throw new SyntaxError(tokens, index + 1);
  597. 			}
  598. 			arraybase = tmpint;
  599. 			return excute(tokens, index + 1);
  600. 		} catch (SyntaxError er) {
  601. 			throw er;
  602. 		} catch (Exception ex) {
  603. 			throw new ExcuteError(ex);
  604. 		}
  605. 	}
  606.  
  607. 	private int cmd_let(List<Token> tokens, int index) throws SyntaxError
  608. 	{
  609. 		try {
  610. 			Token first = tokens.get(index);
  611. 			String name = first.getToken();
  612. 			// if (checkKeyword(name)) // 予約語チェック
  613. 			//     throw new SyntaxError("Wrong variable name: " + name); 
  614. 			index++;
  615. 			if (name.lastIndexOf("$") > 0) {
  616. 				if (strarrs.containsKey(name)) {
  617. 					if (TokenType.OP_BRKT.equals(tokens.get(index).getType()) == false) {
  618. 						throw new SyntaxError(tokens, index);
  619. 					}
  620. 				} else  {
  621. 					if ("=".equals(tokens.get(index).getToken()) == false) {
  622. 						throw new SyntaxError(tokens, index);
  623. 					}
  624. 					index++;
  625. 					// Result result = calc(tokens, index);
  626. 					// if (result.getType() != "STRING")
  627. 					//     throw new ExcuteError();
  628. 					// offset = result.getOffset();
  629. 					// strvars.put(name, result.getStrValue());
  630. 				}
  631. 			} else {
  632. 				if (numarrs.containsKey(name)) {
  633. 					if (TokenType.OP_BRKT.equals(tokens.get(index).getType()) == false) {
  634. 						throw new SyntaxError(tokens, index);
  635. 					}
  636. 				} else  {
  637. 					if ("=".equals(tokens.get(index).getToken()) == false) {
  638. 						throw new SyntaxError(tokens ,index);
  639. 					}
  640. 					// Result result = calc(tokens, index);
  641. 					// if (result.getType() != "NUMBER")
  642. 					//     throw new ExcuteError();
  643. 					// offset = result.getOffset();
  644. 					// numvars.put(name, result.getNumValue());
  645. 				}
  646. 			}
  647. 			// return excute(tokens, index);
  648. 			return tokens.size();
  649. 		} catch (SyntaxError er) {
  650. 			throw er;
  651. 		} catch (Exception ex) {
  652. 			ex.printStackTrace();
  653. 			throw new ExcuteError(tokens.toString());
  654. 		}
  655.  
  656. 	}
  657.  
  658. }
Success #stdin #stdout 0.1s 380352KB
comments (?)
stdin 
00010 LET J4=1
00030 PRINT
00100 BASE 0
00110 LET X=0
00120 LET J=0
00130 LET K=0
00140 X1=0
00150 LET X3=0
00160 LET J9=RND(CLK(J9))
00170 DIM C(7),C$(7),W(100),D(50,50),P(100),I$(100),B(100,6),B$(100)
00180 DIM E(100),F(100),X5(100),X6(100),X2(100),X4(100)
00190 LET G=INT(RND(0)*24+2)
00200 LET H=INT(RND(0)*24+2)
00210 FILE #1="DNG1"
00220 FILE #2="DNG2",#3="DNG3",#4="DNG4",#5="DNG5",#6="DNG6"
00230 RESTORE #4
00240 FILE #7="GMSTR"
00245 RESTORE #7
00250 RESTORE #1
00260 RESTORE #2
00261 RESTORE #3
00262 RESTORE #4
00263 RESTORE #5
00264 RESTORE #6
00270 DATA "STR","DEX","CON","CHAR","WIS","INT","GOLD"
list 100-150
run
stdout 
00100 BASE 0
00110 LET X=0
00120 LET J=0
00130 LET K=0
00140 X1=0
00150 LET X3=0
Ok
Ok
https://ideone.com/tH2Jx7
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!