public object Execute(GOLD.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, (GOLD.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(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(Reduction node)
{
string DEBUG = "DEBUG - Items";
object _item = null, _operator = null;
object _items = null;
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, (Reduction)node[i].Data);
}
else if (_items == null)
{
_items = Context.NonTerminalContext.Execute(ntt, (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, (Reduction)node[0].Data);
return returnValue;
}
Console.WriteLine(DEBUG);
return DEBUG;
}
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)
{
string DEBUG = "DEBUG";
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
if (node[1].Data.ToString().Contains("\""))
{
string returnValue = Regex.Replace(node[1].Data.ToString(), "\"", "");
return returnValue;
}
else
{
int tmp;
if (int.TryParse(node[1].Data.ToString(), out tmp))
{
return tmp;
}
return node[1].Data.ToString();
}
}
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(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);
}
}
private LogicExpression ParseUnaryExpression(Reduction expression)
{
if (expression.Count() == 2)
{
return new UnaryLogicExpression(
(string)expression[0].Data,
this.ParseLookupExpression((Reduction)expression[1].Data));
}
return this.ParseLookupExpression((Reduction)expression[0].Data);
}
private List<LogicStatement> ParseStatements(Reduction inputStatements)
{
var statements = new List<LogicStatement>();
while (true)
{
var statement = (Reduction)inputStatements[0].Data;
statements.Add(this.ParseStatement(statement));
if (inputStatements.Count() == 1)
{
return statements;
}
inputStatements = (Reduction)inputStatements[1].Data;
}
}
private List<LogicExpression> ParseArguments(Reduction inputExpressions)
{
var expressions = new List<LogicExpression>();
if (inputExpressions.Count() == 0)
{
return expressions;
}
while (true)
{
var statement = (Reduction)inputExpressions[0].Data;
expressions.Add(this.ParseExpression(statement));
if (inputExpressions.Count() == 1)
{
return expressions;
}
inputExpressions = (Reduction)inputExpressions[2].Data;
}
}
private void TraverseNodes(Reduction root)
{
while (true)
{
var globalStatement = (Reduction)root[0].Data;
var declaration = (Reduction)globalStatement[0].Data;
switch (declaration.Parent.Head().Name())
{
case "StructureDeclaration":
this.TraverseStructureDeclaration(declaration);
break;
case "FunctionDeclaration":
this.TraverseFunctionDeclaration(declaration);
break;
}
if (root.Count() == 1)
{
return;
}
root = (Reduction)root[1].Data;
}
}
private LogicAssignmentTarget ParseAssignTarget(Reduction assignTarget)
{
if (assignTarget.Count() == 1)
{
return new IdentifierLogicAssignmentTarget((string)assignTarget[0].Data);
}
return new FieldLogicAssignmentTarget(
this.ParseLookupExpression((Reduction)assignTarget[0].Data),
(string)assignTarget[2].Data);
}
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 kell bontnai, 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, (GOLD.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, (GOLD.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, (GOLD.Reduction)node[0].Data);
Console.WriteLine("Expression value: " + returnValue + " type: " + returnValue.GetType());
return(returnValue);
}
}
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;
}
}
}
}
}
private LogicExpression ParseValueExpression(Reduction expression)
{
if (expression.Count() == 1)
{
switch (expression[0].Parent.Name())
{
case "Id":
return new IdentifierLogicExpression(
(string)expression[0].Data);
case "StringLiteral":
return new ConstantLogicExpression(
this.ParseString((string)expression[0].Data));
case "NumberLiteral":
return new ConstantLogicExpression(
float.Parse((string)expression[0].Data, CultureInfo.InvariantCulture.NumberFormat));
case "BooleanLiteral":
return new ConstantLogicExpression(
(string)((Reduction)expression[0].Data)[0].Data == "true");
}
}
if (expression.Count() == 3)
{
return this.ParseExpression((Reduction)expression[1].Data);
}
if (expression.Count() == 4)
{
return new FunctionCallLogicExpression(
(string)((Reduction)expression[0].Data)[0].Data,
this.ParseArguments((Reduction)expression[2].Data));
}
throw new InvalidOperationException();
}
private void TraverseFunctionDeclaration(Reduction functionDeclaration)
{
var returnType = (string)((Reduction)functionDeclaration[0].Data)[0].Data;
var name = (string)functionDeclaration[1].Data;
var parameterDeclarations = (Reduction)functionDeclaration[3].Data;
var optionalSemantic = (Reduction)functionDeclaration[5].Data;
var statements = functionDeclaration.Count() >= 9 ? (Reduction)functionDeclaration[7].Data : null;
this.Functions.Add(
new LogicFunction
{
Name = name,
ReturnSemantic = this.ParseOptionalSemantic(optionalSemantic),
ReturnType = returnType,
Parameters = this.ParseParameters(parameterDeclarations),
Statements = statements == null ? new List<LogicStatement>() : this.ParseStatements(statements)
});
}
private LogicStatement ParseBlockStatement(Reduction statement)
{
if (statement.Count() != 3)
{
return new BlockLogicStatement(new List<LogicStatement>());
}
return new BlockLogicStatement(this.ParseStatements((Reduction)statement[1].Data));
}
private LogicExpression ParseAddExpression(Reduction expression)
{
if (expression.Count() == 3)
{
return new AdditionLogicExpression(
this.ParseAddExpression((Reduction)expression[0].Data),
(string)expression[1].Data,
this.ParseMultiplyExpression((Reduction)expression[2].Data));
}
return this.ParseMultiplyExpression((Reduction)expression[0].Data);
}
private LogicStatement ParseIfStatement(Reduction statement)
{
if (statement.Count() == 7)
{
return new IfElseLogicStatement(
this.ParseExpression((Reduction)statement[2].Data),
this.ParseStatement((Reduction)statement[4].Data),
this.ParseStatement((Reduction)statement[6].Data));
}
return new IfLogicStatement(
this.ParseExpression((Reduction)statement[2].Data),
this.ParseStatement((Reduction)statement[4].Data));
}
public object Execute(GOLD.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, (GOLD.Reduction)node[i].Data);
}
else
{
_operand2 = Context.NonTerminalContext.Execute(ntt, (GOLD.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, (GOLD.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);
}
}
}
}
}
private LogicExpression ParseLookupExpression(Reduction expression)
{
if (expression.Count() == 3)
{
return new LookupLogicExpression(
this.ParseLookupExpression((Reduction)expression[0].Data),
(string)expression[2].Data);
}
return this.ParseValueExpression((Reduction)expression[0].Data);
}
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;
}
}
private string ParseOptionalSemantic(Reduction optionalSemantic)
{
if (optionalSemantic.Count() == 0)
{
return null;
}
else
{
return (string)((Reduction)optionalSemantic[0].Data)[1].Data;
}
}
private void OnReduction(Reduction r, object newObj)
{
int count = r.Count();
string dataOutput = String.Empty;
for (int i = 0; i < count; i++)
{
dataOutput += r.get_Data(i).ToString();
}
Console.WriteLine(String.Format("R: {0}, C: {1}, D: {2}", r.Parent.Text(), count, dataOutput));
if (newObj is IASTNode)
{
((IASTNode)newObj).SourcePosition = parser.ParserPosition;
}
}
private List<LogicParameter> ParseParameters(Reduction parameterDeclarations)
{
var parameters = new List<LogicParameter>();
if (parameterDeclarations.Count() == 0)
{
return parameters;
}
while (true)
{
var parameter = (Reduction)parameterDeclarations[0].Data;
var type = (string)((Reduction)parameter[0].Data)[0].Data;
var name = (string)parameter[1].Data;
var optionalSemantic = this.ParseOptionalSemantic((Reduction)parameter[2].Data);
parameters.Add(new LogicParameter
{
Index = parameters.Count,
Type = type,
Name = name,
Semantic = optionalSemantic
});
if (parameterDeclarations.Count() == 1)
{
return parameters;
}
parameterDeclarations = (Reduction)parameterDeclarations[2].Data;
}
}