public object Execute(GOLD.Reduction node) { Console.WriteLine(Environment.NewLine + "(VVV) Program Line (VVV)" + Environment.NewLine); // Itt vagy Expression, vagy Statement, vagy CommentLine vagy semmi !!! try { string type = Regex.Replace(node[0].Parent.ToString(), "[^0-9a-zA-Z]+", ""); Enums.eNonTerminals ntt = (Enums.eNonTerminals)Enum.Parse(typeof(Enums.eNonTerminals), type); switch (ntt) { case Enums.eNonTerminals.Expression: var returnValue = Context.NonTerminalContext.Execute(ntt, (GOLD.Reduction)node[0].Data); Console.WriteLine("################################################################"); Console.WriteLine("# Programline value: " + returnValue + "\ttype: " + returnValue.GetType()); Console.WriteLine("################################################################" + Environment.NewLine); return(returnValue); default: throw new NotImplementedException(); } } catch (Exception) { string EMPTY = "Empty ProgramLine"; return(EMPTY); } }
public object Execute(Reduction node) { string DEBUG = "DEBUG - Container"; List <string> _operand = null; // lehet List, Set vagy ID switch (node[0].Type()) { case SymbolType.Nonterminal: // Nemterminálisok vizsgálata string type = Regex.Replace(node[0].Parent.ToString(), "[^0-9a-zA-Z]+", ""); Enums.eNonTerminals ntt = (Enums.eNonTerminals)Enum.Parse(typeof(Enums.eNonTerminals), type); _operand = (List <string>)Context.NonTerminalContext.Execute(ntt, (Reduction)node[0].Data); return(_operand); case SymbolType.Error: Console.WriteLine("ERROR in Logical_Engine.Classes.Processor.ProcessTree"); break; default: // Terminálisok vizsgálata - itt egy ID List <string> retVal = new List <string>(); retVal.Add(node[0].Data as string); return(retVal); } return(DEBUG); }
public object Execute(Reduction node) { List <string> container = null; string whereClosure = null; string orderByClosure = null; for (int i = 2; i < node.Count(); i++) { string type = Regex.Replace(node[i].Parent.ToString(), "[^0-9a-zA-Z]+", ""); Enums.eNonTerminals ntt = (Enums.eNonTerminals)Enum.Parse(typeof(Enums.eNonTerminals), type); if (container == null) { // egyelőre használaton kívül van, valamint ezt lehet, hogy projekt specifikusan át kell írni nyelvtan szinten is container = (List <string>)Context.NonTerminalContext.Execute(ntt, (Reduction)node[i].Data); } else if (whereClosure == null) { whereClosure = Context.NonTerminalContext.Execute(ntt, (Reduction)node[i].Data).ToString(); } else if (orderByClosure == null) { orderByClosure = Context.NonTerminalContext.Execute(ntt, (Reduction)node[i].Data).ToString(); } } var retVal = Operation(whereClosure, orderByClosure, null); string DEBUG = "DEBUG"; return(DEBUG); }
public object Execute(Reduction node) { if (node.Count() == 2) { // ID [szóköz] Indexer string _operator = null; object _operand = null; for (int i = 0; i < node.Count(); i++) { switch (node[i].Type()) { case SymbolType.Nonterminal: // Nemterminálisok vizsgálata string type = Regex.Replace(node[i].Parent.ToString(), "[^0-9a-zA-Z]+", ""); Enums.eNonTerminals ntt = (Enums.eNonTerminals)Enum.Parse(typeof(Enums.eNonTerminals), type); _operand = Context.NonTerminalContext.Execute(ntt, (Reduction)node[i].Data); break; case SymbolType.Error: Console.WriteLine("ERROR in Logical_Engine.Classes.Processor.ProcessTree"); break; default: // Terminálisok vizsgálata - itt maga az ID _operator = node[i].Data as string; break; } } string _path = _operator + ":" + _operand.ToString(); if (_operator != null) { _operand = Operation(_operand, _operator, null); } Console.WriteLine("Element value: " + _operand + "\ttype: " + _operand.GetType()); return(_path); } else { // egy nem terminális van, azt kell lebontani, majd // értékadás/másolás try { return(node[0].Data.ToString()); } catch (InvalidCastException ice) { Console.WriteLine(ice.Message); } catch (Exception exc) { Console.WriteLine(exc.Message); } } return(null); }
public object Execute(GOLD.Reduction node) { string DEBUG = "DEBUG - Items"; object _item = null, _operator = null; object _items = null; /// TODO: Meg kell oldani a lista kezelését, egyelőre még a lista is egy item jellegű objektum (akár listaelemek konkatenációjából álló string) if (node.Count() == 3) {// <Item> ',' <Items> for (int i = 0; i < node.Count(); i++) { switch (node[i].Type()) { case GOLD.SymbolType.Nonterminal: // Nemterminálisok vizsgálata string type = Regex.Replace(node[i].Parent.ToString(), "[^0-9a-zA-Z]+", ""); Enums.eNonTerminals ntt = (Enums.eNonTerminals)Enum.Parse(typeof(Enums.eNonTerminals), type); if (_item == null) { _item = Context.NonTerminalContext.Execute(ntt, (GOLD.Reduction)node[i].Data); } else if (_items == null) { _items = Context.NonTerminalContext.Execute(ntt, (GOLD.Reduction)node[i].Data); } break; case GOLD.SymbolType.Error: Console.WriteLine("ERROR in Logical_Engine.Classes.Processor.ProcessTree"); break; default: // Terminálisok vizsgálata - itt egy vessző _operator = node[i].Data as string; break; } } object returnValue = _item.ToString() + "," + _items.ToString(); return(returnValue); } else if (node.Count() == 1) {// <Item> string type = Regex.Replace(node[0].Parent.ToString(), "[^0-9a-zA-Z]+", ""); Enums.eNonTerminals ntt = (Enums.eNonTerminals)Enum.Parse(typeof(Enums.eNonTerminals), type); object returnValue = Context.NonTerminalContext.Execute(ntt, (GOLD.Reduction)node[0].Data); return(returnValue); } Console.WriteLine(DEBUG); return(DEBUG); }
public object Execute(Reduction node) { object _operand = null; string type = Regex.Replace(node[1].Parent.ToString(), "[^0-9a-zA-Z]+", ""); Enums.eNonTerminals ntt = (Enums.eNonTerminals)Enum.Parse(typeof(Enums.eNonTerminals), type); _operand = Context.NonTerminalContext.Execute(ntt, (Reduction)node[1].Data); List <string> returnValue = (List <string>)Operation(null, _operand.ToString(), null); return(returnValue); }
public object Execute(GOLD.Reduction node) { List <string> container = null; List <string> whereClosure = null; List <string> orderByClosure = null; List <string> retVal; for (int i = 2; i < node.Count(); i++) { string type = Regex.Replace(node[i].Parent.ToString(), "[^0-9a-zA-Z]+", ""); Enums.eNonTerminals ntt = (Enums.eNonTerminals)Enum.Parse(typeof(Enums.eNonTerminals), type); if (container == null) { // egyelőre használaton kívül van, valamint ezt lehet, hogy projekt specifikusan át kell írni nyelvtan szinten is container = (List <string>)Context.NonTerminalContext.Execute(ntt, (GOLD.Reduction)node[i].Data); } else if (whereClosure == null) { whereClosure = (List <string>)Context.NonTerminalContext.Execute(ntt, (GOLD.Reduction)node[i].Data); } else if (orderByClosure == null) { orderByClosure = (List <string>)Context.NonTerminalContext.Execute(ntt, (GOLD.Reduction)node[i].Data); } } ///Amennyiben a szervertől valamiért csak egy obj jönne vissza, azt is listába kell rakni, mert a GetExpression mindenképp listval tér vissza object SO = SpecialOperation(container, whereClosure, orderByClosure); if (SO is List <string> ) { retVal = (List <string>)SO; return(retVal); } else { retVal = new List <string>(); retVal.Add(SO as string); return(retVal); } }
public object Execute(GOLD.Reduction node) { List <string> _operand = null; try { // lehet List vagy ID switch (node[2].Type()) { case SymbolType.Nonterminal: // Nemterminálisok vizsgálata string type = Regex.Replace(node[2].Parent.ToString(), "[^0-9a-zA-Z]+", ""); Enums.eNonTerminals ntt = (Enums.eNonTerminals)Enum.Parse(typeof(Enums.eNonTerminals), type); _operand = (List <string>)Context.NonTerminalContext.Execute(ntt, (GOLD.Reduction)node[2].Data); return(_operand); case SymbolType.Error: break; default: // Terminálisok vizsgálata - itt egy StringLiteral vagy null try { List <string> retVal = new List <string>(); string returnValue = node[2].Data.ToString(); returnValue = Regex.Replace(returnValue, "\"", ""); retVal.Add(returnValue); return(retVal); } catch (Exception) { return(null); } } } catch (Exception) //nics order by feltétel megadva { return(null); } return(null); }
/// <summary> /// A megfelelő nemterminálishoz tartozó lefutási függvény hívását vezérlő eljárás /// </summary> /// <param name="type">Az eljárást végző nemterminális</param> /// <param name="node">Adott levél a parszolási fában</param> /// <returns>Az adott nemterminális által, az adott levélhez kiértékelt objektum</returns> public static object Execute(Enums.eNonTerminals type, GOLD.Reduction node) { return(_strategies[type].Execute(node)); }
public object Execute(GOLD.Reduction node) { if (node.Count() == 3) { // van operátor és két operandus, először a két nem terminálist bontom, majd a terminálisként adott operátorral // elvégzem a megfelelő műveletet és értéket adok/másolom string _operator = null; object _operand1 = null , _operand2 = null ; for (int i = 0; i < node.Count(); i++) { switch (node[i].Type()) { case GOLD.SymbolType.Nonterminal: // Nemterminálisok vizsgálata string type = Regex.Replace(node[i].Parent.ToString(), "[^0-9a-zA-Z]+", ""); Enums.eNonTerminals ntt = (Enums.eNonTerminals)Enum.Parse(typeof(Enums.eNonTerminals), type); if (_operand1 == null) { _operand1 = Context.NonTerminalContext.Execute(ntt, (GOLD.Reduction)node[i].Data); } else { _operand2 = Context.NonTerminalContext.Execute(ntt, (GOLD.Reduction)node[i].Data); } break; case GOLD.SymbolType.Error: Console.WriteLine("ERROR in Logical_Engine.Classes.Processor.ProcessTree"); break; default: // Terminálisok vizsgálata - itt operátor jel _operator = node[i].Data as string; break; } } if (_operator != null) { _operand1 = Operation(_operand1, _operator, _operand2); } Console.WriteLine("Simple Expression value: " + _operand1 + "\ttype: " + _operand1.GetType()); return(_operand1); } else { // egy nem terminális van, azt kell lebontani, majd // értékadás/másolás string type = Regex.Replace(node[0].Parent.ToString(), "[^0-9a-zA-Z]+", ""); Enums.eNonTerminals ntt = (Enums.eNonTerminals)Enum.Parse(typeof(Enums.eNonTerminals), type); object returnValue = Context.NonTerminalContext.Execute(ntt, (GOLD.Reduction)node[0].Data); Console.WriteLine("Simple Expression value: " + returnValue + "\ttype: " + returnValue.GetType()); return(returnValue); } }
public object Execute(GOLD.Reduction node) { if (node.Count() == 3) { // zárójel és benne egy expression van // az expressiont kiértékelem és azzal majd valamit kezdek string _operator1 = null , _operator2 = null ; object _operand = null; for (int i = 0; i < node.Count(); i++) { switch (node[i].Type()) { case GOLD.SymbolType.Nonterminal: // Nemterminálisok vizsgálata string type = Regex.Replace(node[i].Parent.ToString(), "[^0-9a-zA-Z]+", ""); Enums.eNonTerminals ntt = (Enums.eNonTerminals)Enum.Parse(typeof(Enums.eNonTerminals), type); _operand = Context.NonTerminalContext.Execute(ntt, (GOLD.Reduction)node[i].Data); break; case GOLD.SymbolType.Error: Console.WriteLine("ERROR in Logical_Engine.Classes.Processor.ProcessTree"); break; default: // Terminálisok vizsgálata - itt operátor jel if (_operator1 == null) { _operator1 = node[i].Data as string; } else { _operator2 = node[i].Data as string; } break; } } if (_operator1 == null && _operator2 == null) { throw new OperationCanceledException("Missing bracket(s)"); } Console.WriteLine("Factor value: " + _operand + "\ttype: " + _operand.GetType()); return(_operand); } else if (node.Count() == 2) { // valamilyen operátor és egy nem terminális // kiértékelem a nem terminálist, majd alkalmazom az operátor által megszabott műveletet string _operator = null; object _operand = null; for (int i = 0; i < node.Count(); i++) { switch (node[i].Type()) { case GOLD.SymbolType.Nonterminal: // Nemterminálisok vizsgálata string type = Regex.Replace(node[i].Parent.ToString(), "[^0-9a-zA-Z]+", ""); Enums.eNonTerminals ntt = (Enums.eNonTerminals)Enum.Parse(typeof(Enums.eNonTerminals), type); _operand = Context.NonTerminalContext.Execute(ntt, (GOLD.Reduction)node[i].Data); break; case GOLD.SymbolType.Error: Console.WriteLine("ERROR in Logical_Engine.Classes.Processor.ProcessTree"); break; default: // Terminálisok vizsgálata - itt operátor jel _operator = node[i].Data as string; break; } } if (_operator != null) { _operand = Operation(_operand, _operator, null); } Console.WriteLine("Factor value: " + _operand + "\ttype: " + _operand.GetType()); return(_operand); } else { // egy nem terminális van, azt kell lebontani, majd // értékadás/másolás object returnValue = null; try { if (node[0].Parent.ToString().Equals("NumberLiteral")) { returnValue = Int32.Parse(node[0].Data.ToString()); Console.WriteLine("Factor value: " + returnValue + "\ttype: " + returnValue.GetType()); return(Int32.Parse(node[0].Data.ToString())); } else if (node[0].Parent.ToString().Equals("RealLiteral")) { returnValue = float.Parse(node[0].Data.ToString()); Console.WriteLine("Factor value: " + returnValue + "\ttype: " + returnValue.GetType()); return(float.Parse(node[0].Data.ToString())); } else if (node[0].Parent.ToString().Equals("StringLiteral")) { returnValue = node[0].Data.ToString(); Console.WriteLine("Factor value: " + returnValue + "\ttype: " + returnValue.GetType()); return(node[0].Data.ToString()); } else if (node[0].Parent.ToString().Equals("BooleanLiteral")) { if (node[0].Data.ToString().Equals("true") || node[0].Data.ToString().Equals("yes")) { return(true); } else { return(false); } } else if (node[0].Parent.ToString().Equals("<Chain>")) { string type = Regex.Replace(node[0].Parent.ToString(), "[^0-9a-zA-Z]+", ""); Enums.eNonTerminals ntt = (Enums.eNonTerminals)Enum.Parse(typeof(Enums.eNonTerminals), type); try { returnValue = Context.NonTerminalContext.Execute(ntt, (GOLD.Reduction)node[0].Data); returnValue = ServiceHandler.ServiceHandler.getData(returnValue as string); int s; if (int.TryParse(returnValue.ToString(), out s)) { return(s); } float t; if (float.TryParse(returnValue.ToString(), out t)) { return(t); } if (returnValue.ToString().Contains(".")) { string[] u = returnValue.ToString().Split('.'); if (u.Length == 4) { try { return(new DateTime(Int32.Parse(u[0]), Int32.Parse(u[1]), Int32.Parse(u[2]))); } catch (Exception exc) { Console.WriteLine(exc.Message); string ERROR = "ERROR"; return(ERROR); } } } } catch (Exception exc) { Console.WriteLine(exc.Message); string ERROR = "ERROR"; return(ERROR); } Console.WriteLine("Factor value: " + returnValue + "\ttype: " + returnValue.GetType()); return(returnValue); } else if (node[0].Parent.ToString().Equals("<DateTimeLiteral>")) { string type = Regex.Replace(node[0].Parent.ToString(), "[^0-9a-zA-Z]+", ""); Enums.eNonTerminals ntt = (Enums.eNonTerminals)Enum.Parse(typeof(Enums.eNonTerminals), type); try { returnValue = Context.NonTerminalContext.Execute(ntt, (GOLD.Reduction)node[0].Data); } catch (Exception Exc) { Console.WriteLine(Exc.Message); string ERROR = "ERROR"; return(ERROR); } return(returnValue); } else { throw new Exception("Literal define error - Luna_interpreter.Model.Structure.Classes.Factor.Execute"); } } catch (InvalidCastException ice) { Console.WriteLine(ice.Message); } catch (Exception exc) { Console.WriteLine(exc.Message); } } Console.WriteLine(Environment.NewLine + "(AAA) Factor (AAA)" + Environment.NewLine); return(null); }
public object Execute(Reduction node) { if (node.Count() == 2) { // Date Time object _operand1 = null, _operand2 = null; for (int i = 0; i < node.Count(); i++) { string type = Regex.Replace(node[i].Parent.ToString(), "[^0-9a-zA-Z]+", ""); Enums.eNonTerminals ntt = (Enums.eNonTerminals)Enum.Parse(typeof(Enums.eNonTerminals), type); if (_operand1 == null) { _operand1 = Context.NonTerminalContext.Execute(ntt, (Reduction)node[i].Data); } else { _operand2 = Context.NonTerminalContext.Execute(ntt, (Reduction)node[i].Data); } } // a visszatérési értéknek szabvány dátum formának kell lennie a megfelelő módon string[] _op1 = _operand1.ToString().Split('.'); string[] _op2 = _operand2.ToString().Split(':'); if (_op2.Length == 3) { try { return(new DateTime(Int32.Parse(_op1[0]), Int32.Parse(_op1[1]), Int32.Parse(_op1[2]), Int32.Parse(_op2[0]), Int32.Parse(_op2[1]), Int32.Parse(_op2[2]))); } catch (Exception exc) { Console.WriteLine(exc.Message); string ERROR = "ERROR"; return(ERROR); } } else { try { return(new DateTime(Int32.Parse(_op1[0]), Int32.Parse(_op1[1]), Int32.Parse(_op1[2]), Int32.Parse(_op2[0]), Int32.Parse(_op2[1]), 0)); } catch (Exception exc) { Console.WriteLine(exc.Message); string ERROR = "ERROR"; return(ERROR); } } } else { // vagy Date, vagy Time string type = Regex.Replace(node[0].Parent.ToString(), "[^0-9a-zA-Z]+", ""); Enums.eNonTerminals ntt = (Enums.eNonTerminals)Enum.Parse(typeof(Enums.eNonTerminals), type); object _operand1 = Context.NonTerminalContext.Execute(ntt, (Reduction)node[0].Data); // szabvány Date, vagy Time objektum visszaadása if (ntt == Enums.eNonTerminals.Date) { //Date string[] _op1 = _operand1.ToString().Split('.'); try { return(new DateTime(Int32.Parse(_op1[0]), Int32.Parse(_op1[1]), Int32.Parse(_op1[2]))); } catch (Exception exc) { Console.WriteLine(exc.Message); string ERROR = "ERROR"; return(ERROR); } } else { //Time string[] _op2 = _operand1.ToString().Split(':'); if (_op2.Length == 3) { try { return(new TimeSpan(Int32.Parse(_op2[0]), Int32.Parse(_op2[1]), Int32.Parse(_op2[2]))); } catch (Exception exc) { Console.WriteLine(exc.Message); string ERROR = "ERROR"; return(ERROR); } } else { try { return(new TimeSpan(Int32.Parse(_op2[0]), Int32.Parse(_op2[1]), 0)); } catch (Exception exc) { Console.WriteLine(exc.Message); string ERROR = "ERROR"; return(ERROR); } } } } }
public object Execute(Reduction node) { if (node.Count() == 3) { // van operátor és két operandus, először a két nem terminálist bontom, majd a terminálisként adott operátorral // elvégzem a megfelelő műveletet és értéket adok/másolom string _operator = null; object _operand1 = null , _operand2 = null ; for (int i = 0; i < node.Count(); i++) { switch (node[i].Type()) { case SymbolType.Nonterminal: // Nemterminálisok vizsgálata string type = Regex.Replace(node[i].Parent.ToString(), "[^0-9a-zA-Z]+", ""); Enums.eNonTerminals ntt = (Enums.eNonTerminals)Enum.Parse(typeof(Enums.eNonTerminals), type); if (_operand1 == null) { /* * Elsőként meg kell nézni, hogy a keresett objektum Document, vagy Resource * A második lépés, hogy az ennek megfelelő objektumot az arra létrehozott service-től lekérjük * Az objektum lekérése után a lebontás kicsit másképp néz ki majd az eddigiekhez képes, ugyanis * objektumon belüli elérési vizsgálatokkal folytatódik */ // Element lekérés, majd ID -> megkapom a hivatkozandó neveket, ezeket pedig feldolgozom _operand1 = Context.NonTerminalContext.Execute(ntt, (Reduction)node[i].Data); } else { /* * Amennyiben az objektum lekérése sikeresen megtörtént, a lebontás itt folytatódik az objektumon belüli * hivatkozás kiértékelésével (létezik-e, ha igen, akkor mi az, stb...) */ // belső hivatkozott név, csupán a továbbbontáshoz kell _operand2 = Context.NonTerminalContext.Execute(ntt, (Reduction)node[i].Data); } break; case SymbolType.Error: Console.WriteLine("ERROR in Logical_Engine.Classes.Processor.ProcessTree"); break; default: // Terminálisok vizsgálata - itt operátor jel _operator = node[i].Data as string; break; } } if (_operator != null) { _operand1 = Operation(_operand1, _operator, _operand2); } Console.WriteLine("Chain value: " + _operand1 + " type: " + _operand1.GetType()); return(_operand1); } else { // egy nem terminális van, azt kell lebontani, majd // értékadás/másolás string type = Regex.Replace(node[0].Parent.ToString(), "[^0-9a-zA-Z]+", ""); Enums.eNonTerminals ntt = (Enums.eNonTerminals)Enum.Parse(typeof(Enums.eNonTerminals), type); object returnValue = Context.NonTerminalContext.Execute(ntt, (Reduction)node[0].Data); Console.WriteLine("Expression value: " + returnValue + " type: " + returnValue.GetType()); return(returnValue); } }