using System; using System.Text.RegularExpressions; using System.Collections.Generic; using System.Globalization; namespace SoloLearn { public class Compiler { public static Compiler compiler; static void Main() { // TO WORK WITH THIS CODE YOU CAN // 1) WRITE Math expression // Example: 5.5 * 5 / (7.3 - 1.8) // // 2) WRITE IN CONSOLE YOUR FUNCTION: // Example: [ x y ] 3*x - 2*y // Where words inside brackets([]) are parameters // and expression after them - body of function // THEN on the next row you will need to write your arguments // Example: 10 11 // // After exection you will get assemly code for your expression // And the result of computations // // Supported operations: // addition(+), subtraction(-), multiplication(*), division(/) // // To start try to input next values: // [func] > [ moneys cost count ] moneys - cost * count // [args] > 100 3.99 15 // It should return result '40.15' as the result // // // I hope you will enjoy playing around with // functions and parameters :~) Please leave a like compiler = new Compiler(); string command = ""; Console.Write(" [func] > "); command = Console.ReadLine().Trim(); // Delete next line if you want to run it on your own PC Console.WriteLine(command); if (!command.StartsWith("[")) { Console.WriteLine( "\n Result << {0}", Simulator.Simulate(compiler.Compile(compiler.Parse("[ ] " + command)), new decimal[0]) ); return; } Console.Write(" [args] > "); string argsStr = Console.ReadLine().Trim(); // Delete next line if you want to run it on your own PC Console.WriteLine(argsStr); string[] rawArgs = argsStr.Split(' '); decimal[] args = new decimal[rawArgs.Length]; if (rawArgs[0] != "") for (int now = 0; now < rawArgs.Length; ++now) args[now] = decimal.Parse(rawArgs[now], CultureInfo.InvariantCulture); Console.WriteLine( "\n Result << {0}", Simulator.Simulate(compiler.Compile(compiler.Optimize(compiler.Parse(command))), args) ); } class Token { public enum Type { Number, Variable, Operator, Block } public Type type; public List tokens; public string value; public Token(Type type, string value) { this.type = type; this.value = value; } public static bool IsOperator(char smb) { return smb == '+' || smb == '-' || smb == '*' || smb == '/'; } public static bool IsOperator(string smb) { return smb == "+" || smb == "-" || smb == "*" || smb == "/"; } public static bool IsNumber(string val) { decimal tmp; return decimal.TryParse(val, NumberStyles.Any, CultureInfo.InvariantCulture, out tmp); } } class Block { public static bool IsSimple(Ast ast) { return !Token.IsOperator(ast.left.op); } public static bool IsComplex(Ast ast) { return Token.IsOperator(ast.left.op) && Token.IsOperator(ast.right.op); } public static bool NeedInversion(string op) { return op == "/" || op == "-"; } public static string TokenToASM(Ast ast) { if (ast.op == "arg") return "AR " + ast.value; return "IM " + ast.value; } public static string OperatorToASM(string op) { switch (op) { case "+": return "AD"; case "-": return "SU"; case "*": return "MU"; case "/": return "DI"; } return null; } } private string[] arguments; private Token expression; private List ExpASM; private int GetVariableIndex(string name) { for (int now = 0; now < arguments.Length; ++now) if (arguments[now] == name) return now; return -1; } public string GetVariableName(int index) { if (index < 0) return "Undefined"; if (index >= arguments.Length) return "Undefined"; return arguments[index]; } public Ast Parse(string prog) { Match match = Regex.Match(prog, "^\\[\\s*(?[a-zA-Z ]+)\\s*\\]\\s*(?.*)$", RegexOptions.IgnoreCase); arguments = match.Groups["arguments"].Value.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries); string exp = match.Groups["expression"].Value; expression = new Token(Token.Type.Block, null); expression.tokens = GenerateTokens(exp + ' '); GenerateActionTree(expression); return GenAst(expression); } private Ast GenAst(Token ex) { Ast left, right; if (ex.tokens[0].type == Token.Type.Block) left = GenAst(ex.tokens[0]); else if (ex.tokens[0].type == Token.Type.Variable) left = new UnOp("arg", decimal.Parse(ex.tokens[0].value, CultureInfo.InvariantCulture)); else left = new UnOp("imm", decimal.Parse(ex.tokens[0].value, CultureInfo.InvariantCulture)); if (ex.tokens.Count == 1) return left; if (ex.tokens[2].type == Token.Type.Block) right = GenAst(ex.tokens[2]); else if (ex.tokens[2].type == Token.Type.Variable) right = new UnOp("arg", decimal.Parse(ex.tokens[2].value, CultureInfo.InvariantCulture)); else right = new UnOp("imm", decimal.Parse(ex.tokens[2].value, CultureInfo.InvariantCulture)); return new BinaryOp(ex.tokens[1].value, left, right); } private void GenerateActionTree(Token token) { for (int now = 0; now < token.tokens.Count; ++now) if (token.tokens[now].type == Token.Type.Block) GenerateActionTree(token.tokens[now]); for (int now = 1; now < token.tokens.Count - 1;) { if (token.tokens.Count == 3) break; var val = token.tokens[now].value; if (val == "*" || val == "/") { var block = new Token(Token.Type.Block, null); block.tokens = new List(3); block.tokens.Add(token.tokens[now - 1]); block.tokens.Add(token.tokens[now]); block.tokens.Add(token.tokens[now + 1]); token.tokens[now - 1] = block; token.tokens.RemoveAt(now); token.tokens.RemoveAt(now); } else now += 2; } for (int now = 1; now < token.tokens.Count - 1;) { if (token.tokens.Count == 3) break; var val = token.tokens[now].value; if (val == "+" || val == "-") { var block = new Token(Token.Type.Block, null); block.tokens = new List(3); block.tokens.Add(token.tokens[now - 1]); block.tokens.Add(token.tokens[now]); block.tokens.Add(token.tokens[now + 1]); token.tokens[now - 1] = block; token.tokens.RemoveAt(now); token.tokens.RemoveAt(now); } else now += 2; } } public Ast Optimize(Ast ast) { if (!Token.IsOperator(ast.op[0])) return ast; if (Token.IsOperator(ast.left.op)) ast.left = Optimize(ast.left); if (Token.IsOperator(ast.right.op)) ast.right = Optimize(ast.right); ast = new BinaryOp(ast.op, ast.left, ast.right); if (ast.left.op == "imm" && ast.right.op == "imm") { switch (ast.op) { case "+": ast = new UnOp("imm", ast.left.value + ast.right.value); break; case "-": ast = new UnOp("imm", ast.left.value - ast.right.value); break; case "*": ast = new UnOp("imm", ast.left.value * ast.right.value); break; case "/": ast = new UnOp("imm", ast.left.value / ast.right.value); break; } } return ast; } public List Compile(Ast ast) { this.ExpASM = new List(50); this.CompileTree(ast); return this.ExpASM; } private void CompileTree(Ast ast) { if (!Token.IsOperator(ast.op)) { this.ExpASM.Add(Block.TokenToASM(ast)); return; } if (Block.IsSimple(ast)) { if (Token.IsOperator(ast.right.op)) { CompileTree(ast.right); this.ExpASM.Add("SW"); CompileTree(ast.left); } else { CompileTree(ast.right); this.ExpASM.Add("SW"); CompileTree(ast.left); } } else if (Block.IsComplex(ast)) { CompileTree(ast.left); this.ExpASM.Add("PUSH"); CompileTree(ast.right); this.ExpASM.Add("SW"); this.ExpASM.Add("POP"); } else { CompileTree(ast.left); this.ExpASM.Add("SW"); CompileTree(ast.right); if (Block.NeedInversion(ast.op)) this.ExpASM.Add("SW"); } this.ExpASM.Add(Block.OperatorToASM(ast.op)); } private List GenerateTokens(string exp) { var list = new List(100); string buffer = ""; int level = 0; bool Parse; char smb, nextSmb; for (int now = 0; now < exp.Length - 1; ++now) { Parse = false; smb = exp[now]; nextSmb = now == exp.Length - 2 ? (char)0 : exp[now + 1]; if (smb == ' ' && level == 0) continue; buffer += smb; if (nextSmb == (char)0) Parse = true; if (nextSmb == '(' || nextSmb == ')') Parse = true; if (nextSmb == ' ') Parse = true; if (Token.IsOperator(nextSmb)) Parse = true; if (smb == '(') { if (level == 0) buffer = ""; ++level; } else if (smb == ')') { --level; if (level == -1) throw new Exception("Unexpected closing bracket ')'"); if (level == 0) { var token = new Token(Token.Type.Block, null); token.tokens = GenerateTokens(buffer); list.Add(token); buffer = ""; continue; } } if (level != 0) continue; if (Token.IsOperator(smb)) { list.Add(new Token(Token.Type.Operator, smb.ToString())); buffer = ""; continue; } if (Parse && buffer != "") { if (Token.IsNumber(buffer)) list.Add(new Token(Token.Type.Number, buffer)); else list.Add(new Token(Token.Type.Variable, GetVariableIndex(buffer).ToString())); buffer = ""; } } return list; } } internal class BinaryOp: Ast { public BinaryOp(string op, Ast left, Ast right) { this.op = op; this.left = left; this.right = right; } } internal class UnOp: Ast { public UnOp(string op, decimal num) { this.op = op; this.value = num; } } public class Ast { public Ast left; public Ast right; public decimal value; public string op; } public class Simulator { public static decimal Simulate(List asm, decimal[] argv) { Console.WriteLine("\n"); Console.WriteLine("ExpASM code:"); Console.WriteLine(String.Join("\n", asm)); Console.WriteLine(""); decimal r0 = 0; decimal r1 = 0; List stack = new List(); PrintData("", r0, r1, string.Join(", ", stack)); foreach (string ins in asm) { string code = ins.Substring(0,2); switch (code) { case "IM": r0 = decimal.Parse(ins.Substring(3).Trim(), CultureInfo.InvariantCulture); break; case "AR": r0 = argv[int.Parse(ins.Substring(3).Trim())]; break; case "SW": decimal tmp = r0; r0 = r1; r1 = tmp; break; case "PU": stack.Add(r0); break; case "PO": r0 = stack[stack.Count - 1]; stack.RemoveAt(stack.Count - 1); break; case "AD": r0 += r1; break; case "SU": r0 -= r1; break; case "MU": r0 *= r1; break; case "DI": if (r1 == 0) return ExecutionError("Zero division exception"); r0 /= r1; break; } PrintData(ins, r0, r1, string.Join(", ", stack)); } return r0; } public static void PrintData(string instruction, decimal r0, decimal r1, string stack) { Console.WriteLine( "Command: {0}; {4}\nRegisters: [{1,-10:0.####}] [{2,-10:0.####}]\nStack: [ {3} ]\n", instruction, r0, r1, stack, GetInstructionDescription(instruction) ); } public static decimal ExecutionError(string error) { Console.WriteLine("ERROR: " + error); return 0; } public static string GetInstructionDescription(string instruction) { if (instruction == "") return "Program entry point"; var cmd = instruction.Substring(0, 2); switch (cmd) { case "IM": return "Load constant to r1"; case "AR": return "Load " + Compiler.compiler.GetVariableName(int.Parse(instruction.Substring(3))); case "SW": return "Swap r1 and r2"; case "PU": return "Add value of r1 to stack"; case "PO": return "Pop stack top to r1"; case "AD": return "Add r2 to r1"; case "SU": return "Subtract r2 from r1"; case "MU": return "Multiply r1 by r2"; case "DI": return "Divide r1 by r2"; } return "Undefined instruction"; } } }

Calculator and ExpASM Compiler