protected override Variable Evaluate(ParsingScript script)
{
// Value to be added to the variable:
Variable right = Utils.GetItem(script);
List <Variable> arrayIndices = Utils.GetArrayIndices(ref m_name);
ParserFunction func = ParserFunction.GetFunction(m_name);
Utils.CheckNotNull(m_name, func);
Variable currentValue = func.GetValue(script);
Variable left = currentValue;
if (arrayIndices.Count > 0)// array element
{
left = Utils.ExtractArrayElement(currentValue, arrayIndices);
script.MoveForwardIf(Constants.END_ARRAY);
}
if (left.Type == Variable.VarType.NUMBER)
{
NumberOperator(left, right, m_action);
}
else
{
StringOperator(left, right, m_action);
}
if (arrayIndices.Count > 0)// array element
{
AssignFunction.ExtendArray(currentValue, arrayIndices, 0, left);
ParserFunction.AddGlobalOrLocalVariable(m_name,
new GetVarFunction(currentValue));
}
else
{
ParserFunction.AddGlobalOrLocalVariable(m_name,
new GetVarFunction(left));
}
return(left);
}
protected override Variable Evaluate(ParsingScript script)
{
List <Variable> args = script.GetFunctionArgs();
Utils.CheckArgs(args.Count, 3, m_name);
string varName = Utils.GetSafeString(args, 0);
Variable lines = Utils.GetSafeVariable(args, 1);
int fromLine = Utils.GetSafeInt(args, 2);
string hash2 = Utils.GetSafeString(args, 3);
string sepStr = Utils.GetSafeString(args, 4, "\t");
if (sepStr == "\\t")
{
sepStr = "\t";
}
char[] sep = sepStr.ToCharArray();
var function = ParserFunction.GetFunction(varName);
Variable mapVar = function != null?function.GetValue(script) :
new Variable(Variable.VarType.ARRAY);
for (int counter = fromLine; counter < lines.Tuple.Count; counter++)
{
Variable lineVar = lines.Tuple[counter];
Variable toAdd = new Variable(counter - fromLine);
string line = lineVar.AsString();
var tokens = line.Split(sep);
string hash = tokens[0];
mapVar.AddVariableToHash(hash, toAdd);
if (!string.IsNullOrWhiteSpace(hash2) &&
!hash2.Equals(hash, StringComparison.OrdinalIgnoreCase))
{
mapVar.AddVariableToHash(hash2, toAdd);
}
}
ParserFunction.AddGlobalOrLocalVariable(varName,
new GetVarFunction(mapVar));
return(Variable.EmptyInstance);
}
void ProcessArrayFor(ParsingScript script,string forString)
{
int index = forString.IndexOf(Constants.FOR_EACH);
if (index <= 0 || index == forString.Length - 1)
{
throw new ArgumentException("Expecting: for(item : array)");
}
string varName = forString.Substring(0,index);
ParsingScript forScript = new ParsingScript(forString);
Variable arrayValue = forScript.ExecuteFrom(index + 1);
int cycles = arrayValue.TotalElements();
if (cycles == 0)
{
SkipBlock(script);
return;
}
int startForCondition = script.Pointer;
for (int i = 0; i < cycles; i++)
{
script.Pointer = startForCondition;
Variable current = arrayValue.GetValue(i);
ParserFunction.AddGlobalOrLocalVariable(varName,
new GetVarFunction(current));
Variable result = ProcessBlock(script);
if (result.IsReturn || result.Type == Variable.VarType.BREAK)
{
//script.Pointer = startForCondition;
//SkipBlock(script);
//return;
break;
}
}
script.Pointer = startForCondition;
SkipBlock(script);
}
protected override Variable Evaluate(ParsingScript script)
{
bool isList = false;
List <Variable> args = Utils.GetArgs(script,
Constants.START_ARG, Constants.END_ARG, out isList);
Utils.CheckArgs(args.Count, 3, m_name);
string varName = Utils.GetSafeString(args, 0);
Variable lines = Utils.GetSafeVariable(args, 1);
int fromLine = Utils.GetSafeInt(args, 2);
string sepStr = Utils.GetSafeString(args, 3, "\t");
if (sepStr == "\\t")
{
sepStr = "\t";
}
char[] sep = sepStr.ToCharArray();
var function = ParserFunction.GetFunction(varName);
Variable allTokensVar = new Variable(Variable.VarType.ARRAY);
for (int counter = fromLine; counter < lines.Tuple.Count; counter++)
{
Variable lineVar = lines.Tuple[counter];
Variable toAdd = new Variable(counter - fromLine);
string line = lineVar.AsString();
var tokens = line.Split(sep);
Variable tokensVar = new Variable(Variable.VarType.ARRAY);
foreach (string token in tokens)
{
tokensVar.Tuple.Add(new Variable(token));
}
allTokensVar.Tuple.Add(tokensVar);
}
ParserFunction.AddGlobalOrLocalVariable(varName,
new GetVarFunction(allTokensVar));
return(Variable.EmptyInstance);
}
protected override Variable Evaluate(ParsingScript script)
{
// 1. Get the name of the variable.
string varName = Utils.GetToken(script, Constants.NEXT_OR_END_ARRAY);
Utils.CheckNotEnd(script, Constants.CONTAINS);
// 2. Get the current value of the variable.
ParserFunction func = ParserFunction.GetFunction(varName);
Utils.CheckNotNull(varName, func);
Variable currentValue = func.GetValue(script);
// 3. Get the variable to add.
Variable item = Utils.GetItem(script);
// 4. Add it to the tuple.
currentValue.AddVariable(item);
ParserFunction.AddGlobalOrLocalVariable(varName,
new GetVarFunction(currentValue));
return(currentValue);
}
protected override Variable Evaluate(ParsingScript script)
{
// 1. Get the name of the variable.
string varName = Utils.GetToken(script, Constants.NEXT_OR_END_ARRAY);
Utils.CheckNotEnd(script, m_name);
// 2. Get the current value of the variable.
ParserFunction func = ParserFunction.GetFunction(varName);
Utils.CheckNotNull(varName, func);
Variable currentValue = func.GetValue(script);
Utils.CheckArray(currentValue, varName);
// 3. Get the variable to remove.
Variable item = Utils.GetItem(script);
bool removed = currentValue.Tuple.Remove(item);
ParserFunction.AddGlobalOrLocalVariable(varName,
new GetVarFunction(currentValue));
return(new Variable(removed));
}
internal async Task <Variable> ProcessTryAsync(ParsingScript script)
{
int startTryCondition = script.Pointer - 1;
int currentStackLevel = ParserFunction.GetCurrentStackLevel();
Exception exception = null;
Variable result = null;
bool alreadyInTryBlock = script.InTryBlock;
script.InTryBlock = true;
try
{
result = await ProcessBlockAsync(script);
}
catch (Exception exc)
{
exception = exc;
}
finally
{
script.InTryBlock = alreadyInTryBlock;
}
if (exception != null || result.IsReturn ||
result.Type == Variable.VarType.BREAK ||
result.Type == Variable.VarType.CONTINUE)
{
// We are here from the middle of the try-block either because
// an exception was thrown or because of a Break/Continue. Skip it.
script.Pointer = startTryCondition;
SkipBlock(script);
}
string catchToken = Utils.GetNextToken(script);
script.Forward(); // skip opening parenthesis
// The next token after the try block must be a catch.
if (Constants.CATCH != catchToken)
{
throw new ArgumentException("Expecting a 'catch()' but got [" +
catchToken + "]");
}
string exceptionName = Utils.GetNextToken(script);
script.Forward(); // skip closing parenthesis
if (exception != null)
{
string excStack = CreateExceptionStack(exceptionName, currentStackLevel);
ParserFunction.InvalidateStacksAfterLevel(currentStackLevel);
GetVarFunction excMsgFunc = new GetVarFunction(new Variable(exception.Message));
ParserFunction.AddGlobalOrLocalVariable(exceptionName, excMsgFunc);
GetVarFunction excStackFunc = new GetVarFunction(new Variable(excStack));
ParserFunction.AddGlobalOrLocalVariable(exceptionName + ".Stack", excStackFunc);
result = await ProcessBlockAsync(script);
ParserFunction.PopLocalVariable(exceptionName);
}
else
{
SkipBlock(script);
}
SkipRestBlocks(script);
return(result);
}
