fork download
copy 
  1. import java.io.*;
  2. import java.util.*;
  3.  
  4. class Command
  5. {
  6.     private static boolean lastReadNumber = false;
  7.     private static boolean byteLeftOver = false;
  8.     private static int leftOverByte = 0;
  9.     public boolean available = true;
  10.     private static final String PRINT = "print";
  11.     private String deferString = null; // the defer clause, without enclosing parentheses
  12.     private String againString = null; // the again clause, without enclosing parentheses
  13.     private String actionString = null; // the command to be executed, without terminating semi-colon
  14.     public int numToDo = 1;
  15.  
  16.     public void setDeferString(String s)
  17.     {
  18. 	deferString = s;
  19.     }
  20.  
  21.     public void setAgainString(String s)
  22.     {
  23. 	againString = s;
  24.     }
  25.  
  26.     public void setActionString(String s)
  27.     {
  28. 	actionString = s;
  29.     }
  30.  
  31.     public boolean execute(Integer lineNumber)
  32.     {
  33. 	try
  34. 	    {
  35. 		if (this.evaluateBoolean(deferString))
  36. 		    return false;
  37. 		this.action();
  38. 		if (!this.evaluateBoolean(againString))
  39. 		    WheneverCode.code.changeNumToDo(lineNumber, -1);
  40. 	    }
  41. 	catch (SyntaxException e)
  42. 	    {
  43. 		System.out.println("Syntax error detected at runtime in line numbered " + lineNumber.toString());
  44. 		System.out.println(e.getMessage() + "\n");
  45. 		System.exit(0);
  46. 	    }
  47. 	return true;
  48.     }
  49.  
  50.     /*
  51.      * Evaluates the argument string as a boolean expression.
  52.      */
  53.     private boolean evaluateBoolean(String s) throws SyntaxException
  54.     // ******** HAVE TO IMPLEMENT UNARY NOT **********
  55.     {
  56. 	if (s == null || s.equals("false"))
  57. 	    return false;
  58. 	if (s.equals("true"))
  59. 	    return true;
  60. 	if (WheneverCode.traceLevel > 3)
  61. 	    System.out.println("[Boolean eval: " + s + " ]");
  62. 	// check for numerical comparisons
  63. 	int less = s.indexOf("<");
  64. 	int greater = s.indexOf(">");
  65. 	int equals = s.indexOf("==");
  66. 	int notequals = s.indexOf("!=");
  67. 	int i = -1;
  68. 	if (less >= 0 && (i < 0 || less < i))
  69. 	    i = less;
  70. 	if (greater >= 0 && (i < 0 || greater < i))
  71. 	    i = greater;
  72. 	if (equals >= 0 && (i < 0 || equals < i))
  73. 	    i = equals;
  74. 	if (notequals >= 0 && (i < 0 || notequals < i))
  75. 	    i = notequals;
  76. 	if (i >= 0) // we have a numerical comparison - evaluate it and substitute it into the string
  77. 	    {
  78. 		int lside = Math.max(s.substring(0,i).lastIndexOf("&&"), s.substring(0,i).lastIndexOf("||"));
  79. 		int rside1 = s.indexOf("&&", i);
  80. 		int rside2 = s.indexOf("||", i);
  81. 		int rside = -1;
  82. 		if (rside1 >= 0 && rside2 >= 0)
  83. 		    rside = Math.min(rside1, rside2);
  84. 		if (rside1 >= 0 && rside2 < 0)
  85. 		    rside = rside1;
  86. 		if (rside1 < 0 && rside2 >= 0)
  87. 		    rside = rside2;
  88. 		String lstring = "";
  89. 		String rstring = "";
  90. 		String lcomp;
  91. 		String rcomp;
  92. 		String op = s.substring(i,i+2);
  93. 		// extract left comparison operand and left boolean leftover string if necessary
  94. 		if (lside >= 0)
  95. 		    {
  96. 			lside += 2;
  97. 			lstring = s.substring(0,lside);
  98. 			lcomp = s.substring(lside,i).trim();
  99. 		    }
  100. 		else
  101. 		    lcomp = s.substring(0,i).trim();
  102. 		// add different amount to index to extract right operand for different length operators
  103. 		if (op.equals("<=") || op.equals(">=") || op.equals("==") || op.equals("!="))
  104. 		    i += 2;
  105. 		else // simple < or >
  106. 		    i++;
  107. 		// extract right comparison operand and right boolean leftover string if necessary
  108. 		if (rside >= 0)
  109. 		    {
  110. 			rstring = s.substring(rside);
  111. 			rcomp = s.substring(i,rside).trim();
  112. 		    }
  113. 		else
  114. 		    rcomp = s.substring(i).trim();
  115. 		boolean comp;
  116. 		if (op.equals("<="))
  117. 		    comp = evaluateInteger(lcomp) <= evaluateInteger(rcomp);
  118. 		else if (op.equals(">="))
  119. 		    comp = evaluateInteger(lcomp) >= evaluateInteger(rcomp);
  120. 		else if (op.equals("=="))
  121. 		    comp = evaluateInteger(lcomp) == evaluateInteger(rcomp);
  122. 		else if (op.equals("!="))
  123. 		    comp = evaluateInteger(lcomp) != evaluateInteger(rcomp);
  124. 		else if (op.charAt(0) == '<')
  125. 		    comp = evaluateInteger(lcomp) < evaluateInteger(rcomp);
  126. 		else // >
  127. 		    comp = evaluateInteger(lcomp) > evaluateInteger(rcomp);
  128. 		return evaluateBoolean(lstring + String.valueOf(comp) + rstring);
  129. 	    }
  130. 	// check for or operator
  131. 	i = s.indexOf("||");
  132. 	if (i >= 0)
  133. 	    return evaluateBoolean(s.substring(0,i).trim()) || evaluateBoolean(s.substring(i+2).trim());
  134. 	// we must have an and operator
  135. 	i = s.indexOf("&&");
  136. 	if (i >= 0)
  137. 	    return evaluateBoolean(s.substring(0,i).trim()) && evaluateBoolean(s.substring(i+2).trim());
  138. 	// exhausted all boolean operations, must have an integer expression which is evaluated according to to-do list
  139. 	return WheneverCode.code.getN(evaluateInteger(s));
  140.     }
  141.  
  142.     /*
  143.      * Performs the action expression in the actionString.
  144.      */
  145.     private void action() throws SyntaxException
  146.     {
  147. 	if (actionString.indexOf(PRINT) == 0)
  148. 	    doPrint(actionString.substring(PRINT.length()).trim());
  149. 	else
  150. 	    doLines(actionString);
  151. 	return;
  152.     }
  153.  
  154.     /*
  155.      * Adds or subtracts lots of lines from the to-do list according to the specifications in the argument.
  156.      */
  157.     private void doLines(String s) throws SyntaxException
  158.     {
  159. 	StringTokenizer tok = new StringTokenizer(s, ",");
  160. 	while (tok.hasMoreTokens())
  161. 	    doLine(tok.nextToken());
  162.     }
  163.  
  164.     /*
  165.      * Adds or subtracts a line from the to-do list according to the specifications in the argument.
  166.      */
  167.     private void doLine(String s) throws SyntaxException
  168.     {
  169. 	int numTimes = 1;
  170. 	int lineNumber = 0;
  171. 	int i;
  172. 	if ((i = s.indexOf("#")) >= 0)
  173. 	    {
  174. 		numTimes = evaluateInteger(s.substring(i+1));
  175. 		lineNumber = evaluateInteger(s.substring(0,i));
  176. 	    }
  177. 	else
  178. 	    lineNumber = evaluateInteger(s);
  179. 	if (WheneverCode.traceLevel >= 2)
  180. 	    System.out.println("[Adding line " + String.valueOf(lineNumber) + ", " + String.valueOf(numTimes) + " times]");
  181. 	WheneverCode.code.changeNumToDo(lineNumber, numTimes);
  182.     }
  183.  
  184.     /*
  185.      * Evaluates the argument string as an integer expression.
  186.      */
  187.     private int evaluateInteger(String s) throws SyntaxException
  188.     {
  189. 	try
  190. 	    {
  191. 		return Integer.parseInt(s);
  192. 	    }
  193. 	catch (NumberFormatException e)
  194. 	    {
  195. 		if (WheneverCode.traceLevel > 4)
  196. 		    {
  197. 			System.out.println("[passed in: " + s + "]");
  198. 		    }
  199. 		int i, j;
  200. 		if ((i = s.indexOf("read()")) >= 0)
  201. 		    {
  202. 			Integer readNumber = 0;
  203. 			try {
  204. 			    int readByte = (byteLeftOver) ? leftOverByte : System.in.read();
  205. 			    byteLeftOver = false;
  206. 			    if (lastReadNumber)
  207. 				{
  208. 				    // skip whitespace after a number
  209. 				    while ((readByte == 10) || (readByte == 32) || (readByte == 13))
  210. 					{
  211. 					    readByte = System.in.read();
  212. 					}
  213. 				}
  214. 			    if (readByte >= 48 && readByte < 58)
  215. 				{
  216. 				    // Are reading a number
  217. 				    while (readByte >= 48 && readByte < 58)
  218. 					{
  219. 					    readNumber = 10 * readNumber + (readByte - 48);
  220. 					    readByte = System.in.read();
  221. 					}
  222. 				    byteLeftOver = true;
  223. 				    leftOverByte = readByte;
  224. 				    lastReadNumber = true;
  225. 				}
  226. 			    else
  227. 				{
  228. 				    readNumber = readByte;
  229. 				    lastReadNumber = false;
  230. 				}
  231. 			}
  232. 			catch (IOException ioe)
  233. 			    {
  234. 			    }
  235. 			return evaluateInteger(s.substring(0,i) + String.valueOf(readNumber) + s.substring(i + 6));
  236. 		    }
  237. 		else if ((i = s.indexOf("N(")) >= 0)
  238. 		    {
  239. 			j = i + 1;
  240. 			int depth = 1;
  241. 			try
  242. 			    {
  243. 				while (depth > 0)
  244. 				    {
  245. 					j++;
  246. 					if (s.charAt(j) == '(')
  247. 					    depth++;
  248. 					if (s.charAt(j) == ')')
  249. 					    depth--;
  250. 				    }
  251. 			    }
  252. 			catch (StringIndexOutOfBoundsException ex)
  253. 			    {
  254. 				throw new SyntaxException("Mismatched parentheses in arithmetic expression function call");
  255. 			    }
  256. 			if (WheneverCode.traceLevel > 3)
  257. 			    {
  258. 				System.out.println("[N() argument: " + s.substring(i+2,j) + "]");
  259. 				System.out.println("[N() substituted: " + s.substring(0,i) + String.valueOf(WheneverCode.code.getNumToDo(evaluateInteger(s.substring(i+2,j)))) + s.substring(j+1) + "]");
  260. 			    }
  261. 			return evaluateInteger(s.substring(0,i) + String.valueOf(WheneverCode.code.getNumToDo(evaluateInteger(s.substring(i+2,j)))) + s.substring(j+1));
  262. 		    }
  263. 		else if ((i = s.indexOf("(")) >= 0)
  264. 		    {
  265. 			j = i;
  266. 			int depth = 1;
  267. 			try
  268. 			    {
  269. 				while (depth > 0)
  270. 				    {
  271. 					j++;
  272. 					if (s.charAt(j) == '(')
  273. 					    depth++;
  274. 					if (s.charAt(j) == ')')
  275. 					    depth--;
  276. 				    }
  277. 			    }
  278. 			catch (StringIndexOutOfBoundsException ex)
  279. 			    {
  280. 				throw new SyntaxException("Mismatched parentheses in arithmetic expression");
  281. 			    }
  282. 			if (WheneverCode.traceLevel > 3)
  283. 			    {
  284. 				System.out.println("[() argument: " + s.substring(i+1,j) + "]");
  285. 				System.out.println("[() substituted: " + s.substring(0,i) + String.valueOf(evaluateInteger(s.substring(i+1,j))) + s.substring(j+1) + "]");
  286. 			    }
  287. 			return evaluateInteger(s.substring(0,i) + String.valueOf(evaluateInteger(s.substring(i+1,j))) + s.substring(j+1));
  288. 		    }
  289. 		else if ((s.indexOf('+') >= 0) || (s.indexOf('_') >= 0)) // we have + and/or - signs
  290. 		    {
  291. 			try
  292. 			    {
  293. 				StreamTokenizer tok = new StreamTokenizer(new StringReader(s));
  294. 				if (tok.nextToken() != StreamTokenizer.TT_NUMBER)
  295. 				    throw new SyntaxException("Bad arithmetic expression (1)");
  296. 				String start = String.valueOf((int)tok.nval);
  297. 				tok.nextToken();
  298. 				while (((char)tok.ttype != '+') && ((char)tok.ttype != '_'))
  299. 				    {
  300. 					if (tok.ttype == StreamTokenizer.TT_NUMBER)
  301. 					    start += String.valueOf((int)tok.nval);
  302. 					else
  303. 					    start += String.valueOf((char)tok.ttype);
  304. 					tok.nextToken();
  305. 					if (tok.ttype == StreamTokenizer.TT_EOF) // only unary minuses!
  306. 					    return multiply(s);
  307. 				    }
  308. 				int op = tok.ttype;
  309. 				String remainder = "";
  310. 				while (tok.nextToken() != StreamTokenizer.TT_EOF)
  311. 				    {
  312. 					if (tok.ttype == StreamTokenizer.TT_NUMBER)
  313. 					    remainder += String.valueOf((int)tok.nval);
  314. 					else if (tok.ttype > 0)
  315. 					    remainder += String.valueOf((char)tok.ttype);
  316. 					else
  317. 					    throw new SyntaxException("Bad arithmetic expression (3)");
  318. 				    }
  319. 				if (WheneverCode.traceLevel > 3)
  320. 				    System.out.println("[arguments: (" + start + ") " + String.valueOf((char)op) + " (" + remainder + ") ]");
  321. 				if ((char)op == '+')
  322. 				    return evaluateInteger(start) + evaluateInteger(remainder);
  323. 				else
  324. 				    return evaluateInteger(start) - evaluateInteger(remainder);
  325. 			    }
  326. 			catch (IOException exc)
  327. 			    {
  328. 				throw new SyntaxException("I/O exception reading arithmetic expression");
  329. 			    }
  330. 		    }
  331. 		else // we have * and/or / signs
  332. 		    return multiply(s);
  333. 	    }
  334.     }
  335.  
  336.     /*
  337.      * Evaluates the argument string as an integer expression.
  338.      * Argument string may only contain * and / binary operators and unary minuses.
  339.      */
  340.     private int multiply(String s) throws SyntaxException
  341.     {
  342. 	int i = s.indexOf("*");
  343. 	int j = s.indexOf("/");
  344. 	if (i >= 0 && (j < 0 || i < j))
  345. 	    {
  346. 		if (WheneverCode.traceLevel > 3)
  347. 		    System.out.println("[* arguments: " + s.substring(0,i).trim() + ", " + s.substring(i+1).trim() + "]");
  348. 		return evaluateInteger(s.substring(0,i).trim()) * evaluateInteger(s.substring(i+1).trim());
  349. 	    }
  350. 	else
  351. 	    {
  352. 		if (WheneverCode.traceLevel > 3)
  353. 		    System.out.println("[/ arguments: " + s.substring(0,j).trim() + ", " + s.substring(j+1).trim() + "]");
  354. 		return (int)(evaluateInteger(s.substring(0,j).trim()) / evaluateInteger(s.substring(j+1).trim()));
  355. 	    }
  356.     }
  357.  
  358.     /*
  359.      * Prints the String expression specified by the argument.
  360.      */
  361.     private void doPrint(String s) throws SyntaxException
  362.     {
  363. 	if (s.charAt(0) != '(' || s.charAt(s.length()-1) != ')')
  364. 	    throw new SyntaxException("Print statement must be enclosed in parentheses");
  365. 	s = s.substring(1, s.length()-1).trim();
  366. 	//System.out.println(s);
  367. 	// construct the output string by concatenating items
  368. 	String out = "";
  369. 	while (s.length() > 0)
  370. 	    {
  371. 		// if item begins with a string literal it begins with a double quote
  372. 		if (s.charAt(0) == '"')
  373. 		    {
  374. 			// get index of closing double quote
  375. 			int i = s.indexOf('"', 1);
  376. 			if (i < 0) // make sure quote is closed
  377. 			    throw new SyntaxException("String must be delimited by double quotes");
  378. 			// add string literal to output
  379. 			out += s.substring(1, i);
  380. 			// check if any more stuff needs to be added
  381. 			if (i+1 == s.length())
  382. 			    s = ""; // entire output string is processed
  383. 			else
  384. 			    { // there is more to be concatenated
  385. 				s = s.substring(i+1).trim();
  386. 				// check for concatenation operator
  387. 				if (s.charAt(0) != '+')
  388. 				    throw new SyntaxException("Illegal string concatenation, + expected");
  389. 				// remove + sign
  390. 				s = s.substring(1).trim();
  391. 			    }
  392. 		    }
  393. 		else // item does not begin with a string literal
  394. 		    {
  395. 			// get index of opening double quote
  396. 			int i = s.indexOf('"');
  397. 			if (i < 0)
  398. 			    { // there are no more string literals - all stuff is an integer expression
  399. 				out += String.valueOf(evaluateInteger(s));
  400. 				s = "";
  401. 			    }
  402. 			else
  403. 			    { // there is a concatenated string literal
  404. 				// check for concatenation operator
  405. 				if (s.charAt(s.substring(0,i).trim().length()-1) != '+')
  406. 				    throw new SyntaxException("Illegal string concatenation, + expected");
  407. 				out += evaluateInteger(s.substring(0,s.substring(0,i).trim().length()-1).trim());
  408. 				s = s.substring(i);
  409. 			    }
  410. 		    }
  411. 	    }
  412. 	// print the output!
  413. 	System.out.println(out);
  414.     }
  415. }
  416.  
Not running #stdin #stdout 0s 0KB
comments (?)
stdin
copy 
Standard input is empty
stdout
copy 
Standard output is empty
https://ideone.com/lR0H7
language:
Java (HotSpot 12)
created:
12 years ago
visibility:
secret

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!