public override object Process(TreeFunctional treeFunction) { MakeReversePolishNotation(); foreach (var token in reversePolishNotation) { switch (token.type) { case TokenType.NUMERIC_CONST: case TokenType.VARIABLE: stack.Push(token); break; case TokenType.PLUS: stack.Push(new TokenNumeric() { data = (double)((stack.Pop() as TokenNumeric).data) + (double)((stack.Pop() as TokenNumeric).data) }); break; case TokenType.MINUS: var right = (double)((stack.Pop() as TokenNumeric).data); var left = (double)((stack.Pop() as TokenNumeric).data); stack.Push(new TokenNumeric() { data = left - right }); break; case TokenType.MULTIPLICATION: stack.Push(new TokenNumeric() { data = (double)((stack.Pop() as TokenNumeric).data) * (double)((stack.Pop() as TokenNumeric).data) }); break; case TokenType.DIVIDE: right = (double)((stack.Pop() as TokenNumeric).data); left = (double)((stack.Pop() as TokenNumeric).data); stack.Push(new TokenNumeric() { data = left / right }); break; default: throw new Exception("something bad in get priority!"); } } object data = (stack.Pop() as TokenNumeric).data; if (tokenToChange != null && treeFunction != null) { treeFunction.UpdateVar(tokenToChange.name, data, VariableType.NUMERIC); } return(data); }
void FindMain() { int start = FindFunction("main"); while (this.text[++start] != '{') { ; } int end = start; this.mainTree = new TreeFunctional("main", TokenType.FUNCTION, start, EndBracket(start, "main")); }
public void UpdateValueInInfixNotation(TreeFunctional tree) { this.RemoveReverseNotations(); foreach (var token in this.infixNotation) { if (token.type == TokenType.VARIABLE) { var tokenVar = (token as TokenVariable); tokenVar.data = tree.GetVar(tokenVar.name).data; } } }
public override object Process(TreeFunctional treeFunction) { string str = ""; foreach (var token in strings) { str += (string)token.data; } if (treeFunction != null) { treeFunction.UpdateVar(tokenToChange.name, str, VariableType.STRING); } return(str); }
Token Process(TreeFunctional tree) { TokenLogic tokenHead = tree.head as TokenLogic; for (int i = tokenHead.startPos + 1; i < tokenHead.endPos;) { Token currentToken = GetNextToken(ref i, tree); if (currentToken == null) { break; } switch (currentToken.type) { case TokenType.VARIABLE: ProcessVariable(tree, ref i, ref currentToken); break; case TokenType.IF: var token = ProcessIfElseStatement(tree, ref i, ref currentToken); if (token != null) { return(token); } break; case TokenType.FOR: ProcessFor(tree, ref i, ref currentToken); break; case TokenType.FUNCTION: ProcessFunction(tree, ref i, ref currentToken); break; case TokenType.RETURN: currentToken = GetNextToken(ref i, tree); if (currentToken is TokenLogic) { return(ProcessFunction(tree, ref i, ref currentToken)); } return(currentToken); } if (tree.next != null) { tree.next.Process(tree); } tree.next = null; } return(null); }
public TreeIf(TokenIfElse ifToken, TreeFunctional tree) : base() { if (tree.head.type == TokenType.IF || tree.head.type == TokenType.FOR) { var tmp = tree as TreeIf; this.stackVariable = tmp.stackVariable; foreach (var item in tmp.stackVariableLocal) { this.stackVariable.Add(item.Key, item.Value); } } else { this.stackVariable = tree.stackVariable; } this.head = ifToken; this.arichmeticStatementTree = new ArichmetichTree(null); this.stackVariableLocal = new Dictionary <string, TokenVariable>(); }
public Token GetNextToken(ref int pos, TreeFunctional tree) { char tmp = text[pos]; while (this.text[pos] == ' ' || this.text[pos] == '\n' || this.text[pos] == '\t') { ++pos; } if (char.IsLetter(this.text[pos])) // is var { int start = pos; while (char.IsLetter(this.text[++pos]) || this.text[pos] == '_') { ; } string nameVar = this.text.Substring(start, pos - start); if (BuiltInFunction.IsBuiltIn(nameVar)) { --pos; while (this.text[++pos] != '(') { ; } return(new TokenFunction(nameVar, start, pos)); } switch (nameVar) { case "if": return(new TokenIfElse(pos, EndBracket(pos, "if"), TokenType.IF)); case "else": return(new TokenIfElse(pos, EndBracket(pos, "else"), TokenType.ELSE)); case "for": start = pos; while (this.text[++start] != '{') { ; } return(new TokenFor(start, EndBracket(start, "for"), TokenType.FOR)); case "AND": return(new Token() { type = TokenType.AND }); case "OR": return(new Token() { type = TokenType.OR }); case "MORE": return(new Token() { type = TokenType.MORE }); case "LESS": return(new Token() { type = TokenType.LESS }); case "EQ": return(new Token() { type = TokenType.EQUAL }); case "NEQ": return(new Token() { type = TokenType.NOT_EQUAL }); case "return": return(new Token() { type = TokenType.RETURN }); } int checkBarcket = pos - 1; while (this.text[++checkBarcket] == ' ') { ; } if (this.text[checkBarcket] == '(') { start = FindFunction(nameVar); return(new TokenFunction(nameVar, start, EndBracket(start, nameVar))); } if (tree == null) { TokenVariable var = new TokenVariable(nameVar); return(var); } else { if (tree.VariableExist(nameVar)) { return(tree.GetVar(nameVar)); } else { TokenVariable var = new TokenVariable(nameVar); tree.PutVariableinStack(var); return(var); } } } if (text[pos] == '=') { ++pos; return(new Token() { type = TokenType.ASSIGN }); } if (text[pos] == '+') { ++pos; return(new Token() { type = TokenType.PLUS }); } if (text[pos] == '-') { ++pos; return(new Token() { type = TokenType.MINUS }); } if (text[pos] == '*') { ++pos; return(new Token() { type = TokenType.MULTIPLICATION }); } if (text[pos] == '/') { ++pos; return(new Token() { type = TokenType.PLUS }); } if (text[pos] == '(') { ++pos; return(new Token() { type = TokenType.ARITHMETIC_BRACKET_OPEN }); } if (text[pos] == ')') { ++pos; return(new Token() { type = TokenType.ARITHMETIC_BRACKET_CLOSE }); } if (text[pos] == ',') { ++pos; return(new Token() { type = TokenType.COMA }); } if (text[pos] == '\"') { int start = pos; char c; while ((c = text[++pos]) != '\"') { if (c == '\n') { throw new Exception("Not close string in line: " + pos.ToString()); } } string str = this.text.Substring(start + 1, pos - start - 1); ++pos; return(new TokenVariable(null) { type = TokenType.VARIABLE, varType = VariableType.STRING, data = str }); } if (char.IsDigit(this.text[pos])) // is Const { int start = pos; while (char.IsDigit(this.text[++pos])) { ; } string str = this.text.Substring(start, pos - start); double value = Convert.ToDouble(str); return(new TokenConst() { type = TokenType.NUMERIC_CONST, data = value }); } if (this.text[pos] == ';') { ++pos; return(new Token() { type = TokenType.END_OP }); } return(null); }
private void ProcessVariable(TreeFunctional tree, ref int i, ref Token currentToken, bool withAssign = true) { Token nextToken = GetNextToken(ref i, tree); if (nextToken.type == TokenType.ASSIGN || !withAssign) { if (withAssign) { nextToken = GetNextToken(ref i, tree); } var type = nextToken.type; if (type == TokenType.FUNCTION) { nextToken = ProcessFunction(tree, ref i, ref nextToken); if (nextToken == null) { throw new Exception("Expected return value in function, Line:" + i); } (currentToken as TokenVariable).data = (nextToken as TokenVariable).data; (currentToken as TokenVariable).varType = (nextToken as TokenVariable).varType; nextToken = GetNextToken(ref i, tree); type = nextToken.type; } if (type == TokenType.NUMERIC_CONST || type == TokenType.ARITHMETIC_BRACKET_OPEN || (type == TokenType.VARIABLE && (nextToken as TokenVariable).varType != VariableType.STRING)) { ArichmetichTree arTree = new ArichmetichTree(currentToken as TokenVariable); tree.next = arTree; int numBracket = nextToken.type == TokenType.ARITHMETIC_BRACKET_OPEN ? 1 : 0; while (nextToken.type != TokenType.END_OP && nextToken.type != TokenType.COMA && (nextToken.type != TokenType.ARITHMETIC_BRACKET_CLOSE || numBracket == 0)) { arTree.PutToken(nextToken); nextToken = GetNextToken(ref i, tree); switch (nextToken.type) { case TokenType.ARITHMETIC_BRACKET_OPEN: numBracket++; break; case TokenType.ARITHMETIC_BRACKET_CLOSE: numBracket--; break; case TokenType.FUNCTION: nextToken = ProcessFunction(tree, ref i, ref nextToken); if (nextToken == null) { throw new Exception("Expected return value in function, Line:" + i); } break; } } } else if (type == TokenType.VARIABLE && (type == TokenType.VARIABLE && (nextToken as TokenVariable).varType != VariableType.NUMERIC)) { StringTree strTree = new StringTree(currentToken as TokenVariable); tree.next = strTree; while (nextToken.type != TokenType.END_OP && nextToken.type != TokenType.COMA && nextToken.type != TokenType.ARITHMETIC_BRACKET_CLOSE) { strTree.AddToken(nextToken as TokenVariable); nextToken = GetNextToken(ref i, tree); if (nextToken.type == TokenType.END_OP || nextToken.type == TokenType.ARITHMETIC_BRACKET_CLOSE) { break; } if (nextToken.type != TokenType.PLUS) { throw new Exception("Expect \'+\' in line:" + i.ToString()); } nextToken = GetNextToken(ref i, tree); if (nextToken.type == TokenType.FUNCTION) { nextToken = ProcessFunction(tree, ref i, ref nextToken); if (nextToken == null) { throw new Exception("Expected return value in function, Line:" + i); } } } } else if (type == TokenType.END_OP) { return; } else { throw new Exception("Somethin bad in Process"); } } }
private Token ProcessIfElseStatement(TreeFunctional tree, ref int i, ref Token currentToken) { TreeIf ifTree = new TreeIf(currentToken as TokenIfElse, tree); // process statement currentToken = GetNextToken(ref i, tree); int deep; if (currentToken.type == TokenType.ARITHMETIC_BRACKET_OPEN) { deep = 1; ifTree.PutTokenInStatement(currentToken, null, null, i); } else { throw new Exception("Expected open bracket in if statement line: " + i.ToString()); } while (deep != 0) { currentToken = GetNextToken(ref i, tree); if (currentToken.type == TokenType.ARITHMETIC_BRACKET_OPEN) { deep++; } else if (currentToken.type == TokenType.ARITHMETIC_BRACKET_CLOSE) { deep--; } if (currentToken.type == TokenType.VARIABLE || currentToken.type == TokenType.NUMERIC_CONST) { var tokenOperation = GetNextToken(ref i, tree); var rightVariable = GetNextToken(ref i, tree); ifTree.PutTokenInStatement(currentToken, tokenOperation, rightVariable, i); } else { ifTree.PutTokenInStatement(currentToken, null, null, i); } } --i; while (this.text[++i] != '{') { ; } (ifTree.head as TokenIfElse).startPos = i; i = (ifTree.head as TokenIfElse).endPos + 1; if (ifTree.ProcessStatement()) { var retToken = Process(ifTree); if (retToken != null) { return(retToken); } } else { int tmp = i; currentToken = GetNextToken(ref tmp, tree); if (currentToken != null && currentToken.type == TokenType.ELSE) { --i; while (this.text[++i] != '{') { ; } (currentToken as TokenIfElse).startPos = i; ifTree.head = currentToken; var retToken = Process(ifTree); if (retToken != null) { return(retToken); } i = (ifTree.head as TokenIfElse).endPos + 1; } } return(null); }
private void ProcessFor(TreeFunctional tree, ref int i, ref Token currentToken) { TokenFor forToken = currentToken as TokenFor; currentToken = GetNextToken(ref i, tree); if (currentToken.type != TokenType.ARITHMETIC_BRACKET_OPEN) { throw new Exception("Expected open bracket after for, Line: " + i.ToString()); } currentToken = GetNextToken(ref i, tree); TokenVariable forVar = null; if (currentToken.type == TokenType.VARIABLE) { forVar = currentToken as TokenVariable; } int endPos = i; if (forVar != null) { while (this.text[++endPos] != ';') { ; } TreeFunctional treeForInitForVar = new TreeFunctional(null, TokenType.FUNCTION, i - forVar.name.Length - 1, endPos); Process(treeForInitForVar); forVar.data = treeForInitForVar.stackVariable[forVar.name].data; i = endPos + 1; } List <Token> forStatement = new List <Token>(); currentToken = GetNextToken(ref i, tree); while (currentToken.type != TokenType.END_OP) { forStatement.Add(currentToken); currentToken = GetNextToken(ref i, tree); } currentToken = GetNextToken(ref i, tree); ArichmetichTree updateVarTree = null; if (currentToken.type != TokenType.ARITHMETIC_BRACKET_CLOSE) { if (currentToken.type != TokenType.VARIABLE) { throw new Exception("Expect var in update var posution in for, Line: " + i.ToString()); } updateVarTree = new ArichmetichTree(currentToken as TokenVariable); currentToken = GetNextToken(ref i, tree); if (currentToken.type != TokenType.ASSIGN) { throw new Exception("Expect assign in update pos in for, Line: " + i.ToString()); } currentToken = GetNextToken(ref i, tree); while (currentToken.type != TokenType.ARITHMETIC_BRACKET_CLOSE) { updateVarTree.PutToken(currentToken); currentToken = GetNextToken(ref i, tree); } } TreeFor forTree = new TreeFor(forToken, forVar, updateVarTree, tree); while (forTree.ProcessStatement(forStatement, i)) { Process(forTree); forTree.ProcessUpdateForVar(); } i = (forTree.head as TokenLogic).endPos + 1; }
private Token ProcessFunction(TreeFunctional tree, ref int i, ref Token currentToken) { TokenFunction funcToken = currentToken as TokenFunction; currentToken = GetNextToken(ref i, tree); if (BuiltInFunction.IsBuiltIn(funcToken.name)) { if (currentToken.type != TokenType.ARITHMETIC_BRACKET_OPEN) { throw new Exception("Expected open bracket after calling fuction!"); } List <TokenNumeric> paramets = new List <TokenNumeric>(); int currentPos = i; currentToken = GetNextToken(ref i, tree); while (currentToken.type != TokenType.ARITHMETIC_BRACKET_CLOSE && currentToken.type != TokenType.END_OP) { if (currentToken is TokenLogic) { currentToken = ProcessFunction(tree, ref i, ref currentToken); } Token nextToken = GetNextToken(ref i, tree); if (nextToken.type != TokenType.COMA && nextToken.type != TokenType.ARITHMETIC_BRACKET_CLOSE) { i = currentPos; ProcessVariable(tree, ref i, ref currentToken, false); (currentToken as TokenNumeric).data = tree.next.Process(null); tree.next = null; } if (currentToken.type != TokenType.COMA && currentToken.type != TokenType.ARITHMETIC_BRACKET_CLOSE) { paramets.Add(currentToken as TokenNumeric); } currentPos = i; if (nextToken.type != TokenType.ARITHMETIC_BRACKET_CLOSE) { currentToken = GetNextToken(ref i, tree); } else { currentToken = nextToken; } } return(BuiltInFunction.ProcessFunction(funcToken.name, paramets)); } TreeFunctional funcTree = new TreeFunctional(funcToken.name, TokenType.FUNCTION, funcToken.startPos, funcToken.endPos); var tokenInDefinition = GetNextToken(ref funcToken.startPos, null); if (tokenInDefinition.type != TokenType.ARITHMETIC_BRACKET_OPEN) { throw new Exception("Expected open bracket in callin function" + funcToken.name); } currentToken = GetNextToken(ref i, tree); tokenInDefinition = GetNextToken(ref funcToken.startPos, null); while (currentToken.type != TokenType.ARITHMETIC_BRACKET_CLOSE && tokenInDefinition.type != TokenType.ARITHMETIC_BRACKET_CLOSE) { if (currentToken.type == TokenType.NUMERIC_CONST) { currentToken = (currentToken as TokenConst).ConvertToTokenVariable((tokenInDefinition as TokenVariable).name); } else { (currentToken as TokenVariable).name = (tokenInDefinition as TokenVariable).name; } funcTree.PutVariableinStack(currentToken as TokenVariable); currentToken = GetNextToken(ref i, tree); tokenInDefinition = GetNextToken(ref funcToken.startPos, null); if (currentToken.type == TokenType.COMA && tokenInDefinition.type == TokenType.COMA) { currentToken = GetNextToken(ref i, tree); tokenInDefinition = GetNextToken(ref funcToken.startPos, null); } else if (currentToken.type != TokenType.ARITHMETIC_BRACKET_CLOSE && tokenInDefinition.type != TokenType.ARITHMETIC_BRACKET_CLOSE) { throw new Exception("Expect coma operator in functions paramets"); } } while (this.text[(funcTree.head as TokenLogic).startPos++] != '{') { ; } return(this.Process(funcTree)); }
public TreeFor(TokenFor forToken, TokenVariable forVar, ArichmetichTree updateForVar, TreeFunctional tree) : base() { if (tree.head.type == TokenType.IF || tree.head.type == TokenType.FOR) { var tmp = tree as TreeIf; this.stackVariable = tmp.stackVariable; foreach (var item in tmp.stackVariableLocal) { this.stackVariable.Add(item.Key, item.Value); } } else { this.stackVariable = tree.stackVariable; } this.head = forToken; this.forVar = forVar; this.updateForVar = updateForVar; }
abstract public object Process(TreeFunctional treeFunction);