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);
}
}
