fork download 
  1. /* package whatever; // don't place package name! */
  2.  
  3. import java.util.*;
  4. import java.lang.*;
  5. import java.io.*;
  6.  
  7. /* Name of the class has to be "Main" only if the class is public. */
  8. class Ideone
  9. {
  10. 	static interface BASICCommand
  11. 	{
  12. 		int excute(String[] args, int index) throws java.lang.Exception;
  13. 	}
  14.  
  15. 	static interface BASICFunction
  16. 	{
  17. 		ExpreResult excute(String[] args, int index) throws java.lang.Exception;
  18. 	}
  19.  
  20. 	static class BASICSyntaxError extends java.lang.Exception
  21. 	{
  22. 		BASICSyntaxError(String[] tokens)
  23. 		{
  24. 			super("Syntax Error: " + Arrays.toString(tokens));
  25. 		}
  26. 	}
  27.  
  28. 	static enum BASICVarType
  29. 	{
  30. 		INT, DBL, STR
  31. 	}
  32.  
  33. 	static HashMap<String, BASICCommand> commands = new HashMap<String, BASICCommand>(); 
  34. 	static HashMap<String, BASICFunction> functions = new HashMap<String, BASICFunction>(); 
  35. 	static HashMap<String, BASICVarType> varident =	new HashMap<String, BASICVarType>();
  36. 	static HashMap<String, Integer> intvars = new HashMap<String, Integer>();
  37. 	static HashMap<String, Double> dblvars = new HashMap<String, Double>();
  38. 	static HashMap<String, String> strvars = new HashMap<String, String>();
  39.  
  40. 	public static void main (String[] args) throws java.lang.Exception
  41. 	{
  42. 		// your code goes here
  43. 		BufferedReader in = new BufferedReader(
  44. 			new InputStreamReader(System.in));
  45. 		String line;
  46. 		initCommands();
  47. 		while ((line = in.readLine()) != null)
  48. 		{
  49. 			String[] tokens = line.split(" ");
  50. 			try
  51. 			{
  52. 				if (line.trim().length() > 0)
  53. 				{
  54. 					doCommand(tokens, 0);
  55. 				}
  56. 			}
  57. 			catch (BASICSyntaxError ex)
  58. 			{
  59. 				System.out.println(ex.getMessage());
  60. 			}
  61. 		}
  62. 	}
  63.  
  64. 	static void doCommand(String[] tokens, int index) throws java.lang.Exception
  65. 	{
  66. 		if (index >= tokens.length)
  67. 		{
  68. 			return;
  69. 		}
  70. 		BASICCommand command;
  71. 		while ((command = commands.get(tokens[index].toUpperCase())) != null)
  72. 		{
  73. 			index = command.excute(tokens, index);
  74. 			if (index >= tokens.length)
  75. 			{
  76. 				return;
  77. 			}
  78. 			if (":".equals(tokens[index]) == false)
  79. 			{
  80. 				break;
  81. 			}
  82. 			index++;
  83. 			if (index >= tokens.length)
  84. 			{
  85. 				return;
  86. 			}
  87. 		}
  88. 		throw new BASICSyntaxError(tokens);
  89. 	}
  90.  
  91. 	static void initCommands()
  92. 	{
  93. 		commands.put("LET", new BCLet());
  94. 		commands.put("PRINT", new BCPrint());
  95. 		commands.put("REM", new BCRem());
  96. 	}
  97.  
  98. 	static BASICVarType varname(String var)
  99. 	{
  100. 		if (var.matches("^[A-Z]+$"))
  101. 		{
  102. 			return BASICVarType.INT;
  103. 		}
  104. 		if (var.matches("^[A-Z]+#$"))
  105. 		{
  106. 			return BASICVarType.DBL;
  107. 		}
  108. 		if (var.matches("^[A-Z]+[$]$"))		
  109. 		{
  110. 			return BASICVarType.STR;
  111. 		}
  112. 		return null;
  113. 	}
  114.  
  115. 	static class ExpreResult
  116. 	{
  117. 		int end;
  118. 		BASICVarType type;
  119. 		String strret;
  120. 		int intret;
  121. 		double dblret;
  122. 	}
  123.  
  124. 	static ExpreResult expression(String[] tokens, int index) throws java.lang.Exception
  125. 	{
  126. 		String first = tokens[index];
  127. 		if (first.matches("^[0-9]+$"))
  128. 		{
  129. 			System.out.println("int");
  130. 		}
  131. 		else if (first.matches("^([0-9]+)?[.][0-9]+$"))
  132. 		{
  133. 			System.out.println("dbl");
  134. 		}
  135. 		else if (first.matches("^\"[^\"]+\"$"))
  136. 		{
  137. 			System.out.println("str");
  138. 		}
  139. 		else if ("(".equals(first) == true)
  140. 		{
  141. 			System.out.println("(");
  142. 		}
  143. 		else
  144. 		{
  145. 			first = first.toUpperCase();
  146. 			BASICFunction function = null;
  147. 			if ((function = functions.get(first)) != null)
  148. 			{
  149. 				function.excute(tokens, index + 1);
  150. 			}
  151. 			else if (commands.containsKey(first))
  152. 			{
  153. 				throw new BASICSyntaxError(tokens);
  154. 			}
  155. 			else 
  156. 			{
  157. 				BASICVarType type = varname(first);
  158. 				if (BASICVarType.INT.equals(type))
  159. 				{
  160.  
  161. 				}
  162. 				else if (BASICVarType.DBL.equals(type))
  163. 				{
  164.  
  165. 				}
  166. 			}
  167. 		}
  168. 		throw new BASICSyntaxError(tokens);
  169. 	}
  170.  
  171. 	static class BCLet implements BASICCommand
  172. 	{
  173. 		@Override public int excute(String[] args, int index) throws java.lang.Exception
  174. 		{
  175. 			int end = index;
  176. 			if (args.length - index < 4)
  177. 			{
  178. 				throw new BASICSyntaxError(args);
  179. 			}
  180. 			if ("=".equals(args[index + 2]) == false)
  181. 			{
  182. 				throw new BASICSyntaxError(args);
  183. 			}
  184. 			String var = args[index + 1].toUpperCase();
  185. 			if (commands.containsKey(var))
  186. 			{
  187. 				throw new BASICSyntaxError(args);
  188. 			}
  189. 			if (functions.containsKey(var))
  190. 			{
  191. 				throw new BASICSyntaxError(args);
  192. 			}
  193. 			BASICVarType type = varname(var);
  194. 			if (BASICVarType.INT.equals(type))
  195. 			{
  196. 				System.out.println("Integer: " + var);
  197. 				expression(args, index + 3);
  198. 			}
  199. 			else if (BASICVarType.DBL.equals(type))
  200. 			{
  201. 				var = var.substring(0, var.length() - 1);
  202. 				System.out.println("Double: " + var);
  203. 				expression(args, index + 3);
  204. 			}
  205. 			else if (BASICVarType.STR.equals(type))
  206. 			{
  207. 				var = var.substring(0, var.length() - 1);
  208. 				System.out.println("String: " + var);
  209. 				expression(args, index + 3);
  210. 			}
  211. 			else
  212. 			{
  213. 				throw new BASICSyntaxError(args);
  214. 			}
  215. 			return args.length;
  216. 		}
  217. 	}
  218.  
  219. 	static class BCPrint implements BASICCommand
  220. 	{
  221. 		@Override public int excute(String[] args, int index) throws java.lang.Exception
  222. 		{
  223. 			String msg = "";
  224. 			int end = index;
  225. 			if (args.length - index > 1)
  226. 			{
  227. 				expression(args, index + 1);
  228. 			}
  229. 			System.out.print(msg);
  230. 			if (";".equals(args[end]) == false)
  231. 			{
  232. 				System.out.println();
  233. 			}
  234. 			return args.length;
  235. 		}
  236. 	}
  237.  
  238. 	static class BCRem implements BASICCommand
  239. 	{
  240. 		@Override public int excute(String[] args, int index) throws java.lang.Exception
  241. 		{
  242. 			return args.length;
  243. 		}
  244. 	}
  245. }
Success #stdin #stdout 0.08s 380160KB
comments (?)
stdin 
REM 半角スペースを空けることが前提
REM 例
REM LET ABC# = 2.0 * COS ( 60 / PI# ) * SIN ( 60 / PI# )

LET A = 10
LET B# = 12.3
LET C$ = "100"

PRINT A
PRINT B#
PRINT C$
stdout 
Integer: A
int
Syntax Error: [LET, A, =, 10]
Double: B
dbl
Syntax Error: [LET, B#, =, 12.3]
String: C
str
Syntax Error: [LET, C$, =, "100"]
Syntax Error: [PRINT, A]
Syntax Error: [PRINT, B#]
Syntax Error: [PRINT, C$]
https://ideone.com/nkfk72
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!