internal bool EvalCondition(Parser.Result arg1, string comparison, Parser.Result arg2)
{
bool compare = arg1.String != null?CompareStrings(arg1.String, comparison, arg2.String) :
CompareNumbers(arg1.Value, comparison, arg2.Value);
return(compare);
}
protected override Parser.Result Evaluate(string data, ref int from)
{
// 1. Get the name of the variable.
string varName = Utils.GetToken(data, ref from, Constants.END_ARG_ARRAY);
if (from >= data.Length)
{
throw new ArgumentException("Couldn't get variable");
}
// 2. Get the current value of the variable.
ParserFunction func = ParserFunction.GetFunction(varName);
Parser.Result currentValue = func.GetValue(data, ref from);
// 3. Take either the length of the underlying tuple or
// string part if it is defined,
// or the numerical part converted to a string otherwise.
int size = currentValue.Tuple != null ? currentValue.Tuple.Count :
currentValue.String != null ? currentValue.String.Length :
currentValue.Value.ToString().Length;
Parser.Result newValue = new Parser.Result(size);
return(newValue);
}
internal Parser.Result ProcessBlock()
{
int blockStart = m_currentChar;
Parser.Result result = null;
while (true)
{
int endGroupRead = Utils.GoToNextStatement(m_data, ref m_currentChar);
if (endGroupRead > 0)
{
return(result != null ? result : new Parser.Result());
}
if (m_currentChar >= m_data.Length)
{
throw new ArgumentException("Couldn't process block [" +
m_data.Substring(blockStart) + "]");
}
result = Parser.LoadAndCalculate(m_data, ref m_currentChar, Constants.END_PARSE_ARRAY);
if (result is Continue || result is Break)
{
return(result);
}
}
}
public static int ExtractArrayElement(ref string varName)
{
int argStart = varName.IndexOf(Constants.START_ARG);
if (argStart <= 0)
{
return(-1);
}
int argEnd = varName.IndexOf(Constants.END_ARG, argStart + 1);
if (argEnd <= argStart + 1)
{
return(-1);
}
int getIndexFrom = argStart;
Parser.Result existing = Parser.LoadAndCalculate(varName, ref getIndexFrom,
Constants.NEXT_OR_END_ARRAY);
if (!Double.IsNaN(existing.Value) && existing.Value >= 0)
{
varName = varName.Substring(0, argStart);
return((int)existing.Value);
}
return(-1);
}
protected override Parser.Result Evaluate(string data, ref int from)
{
// 1. Get the name of the variable.
string varName = Utils.GetToken(data, ref from, Constants.NEXT_ARG_ARRAY);
if (from >= data.Length)
{
throw new ArgumentException("Couldn't append variable");
}
// 2. Get the current value of the variable.
ParserFunction func = ParserFunction.GetFunction(varName);
Parser.Result currentValue = func.GetValue(data, ref from);
// 3. Get the value to be looked for.
Parser.Result searchValue = Utils.GetItem(data, ref from);
// 4. Take either the string part if it is defined,
// or the numerical part converted to a string otherwise.
string basePart = currentValue.String != null ? currentValue.String :
currentValue.Value.ToString();
string search = searchValue.String != null ? searchValue.String :
searchValue.Value.ToString();
int result = basePart.IndexOf(search);
return(new Parser.Result(result, null));
}
protected override Parser.Result Evaluate(string data, ref int from)
{
// 1. Get the name of the variable.
string varName = Utils.GetToken(data, ref from, Constants.NEXT_ARG_ARRAY);
if (from >= data.Length)
{
throw new ArgumentException("Couldn't append variable");
}
// 2. Get the current value of the variable.
ParserFunction func = ParserFunction.GetFunction(varName);
Parser.Result currentValue = func.GetValue(data, ref from);
// 3. Get the value to be added or appended.
Parser.Result newValue = Utils.GetItem(data, ref from);
// 4. Take either the string part if it is defined,
// or the numerical part converted to a string otherwise.
string arg1 = currentValue.String != null ? currentValue.String :
currentValue.Value.ToString();
string arg2 = newValue.String != null ? newValue.String :
newValue.Value.ToString();
// 5. The variable becomes a string after adding a string to it.
newValue.Reset();
newValue.String = arg1 + arg2;
ParserFunction.AddFunction(varName, new GetVarFunction(newValue));
return(newValue);
}
protected override Parser.Result Evaluate(string data, ref int from)
{
Interpreter.Instance.CurrentChar = from;
Parser.Result result = Interpreter.Instance.ProcessIf();
return(result);
}
protected override Parser.Result Evaluate(string data, ref int from)
{
Parser.Result arg1 = Parser.LoadAndCalculate(data, ref from, Constants.NEXT_ARG_ARRAY);
from++; // eat separation
Parser.Result arg2 = Parser.LoadAndCalculate(data, ref from, Constants.END_ARG_ARRAY);
arg1.Value = Math.Pow(arg1.Value, arg2.Value);
return(arg1);
}
internal void ProcessWhile()
{
int startWhileCondition = m_currentChar;
// A heuristic check against an infinite loop.
int cycles = 0;
int START_CHECK_INF_LOOP = CHECK_AFTER_LOOPS / 2;
Parser.Result argCache1 = null;
Parser.Result argCache2 = null;
bool stillValid = true;
while (stillValid)
{
m_currentChar = startWhileCondition;
Parser.Result arg1 = GetNextIfToken();
string comparison = Utils.GetComparison(m_data, ref m_currentChar);
Parser.Result arg2 = GetNextIfToken();
stillValid = EvalCondition(arg1, comparison, arg2);
int startSkipOnBreakChar = m_currentChar;
if (!stillValid)
{
break;
}
// Check for an infinite loop if we are comparing same values:
if (++cycles % START_CHECK_INF_LOOP == 0)
{
if (cycles >= MAX_LOOPS || (arg1.IsEqual(argCache1) && arg2.IsEqual(argCache2)))
{
throw new ArgumentException("Looks like an infinite loop after " +
cycles + " cycles.");
}
argCache1 = arg1;
argCache2 = arg2;
}
Parser.Result result = ProcessBlock();
if (result is Break)
{
m_currentChar = startSkipOnBreakChar;
break;
}
}
// The while condition is not true anymore: must skip the whole while
// block before continuing with next statements.
SkipBlock();
}
public bool Process(string script, string filename = null)
{
if (script == null || script == "")
{
throw new ArgumentException("The script is invalid.");
}
m_data = Utils.ConvertToScript(script);
m_currentChar = 0;
bool?bRet = null;
while (m_currentChar < m_data.Length)
{
try
{
Parser.Result Rst = Parser.LoadAndCalculate(m_data, ref m_currentChar, Constants.END_PARSE_ARRAY);
Utils.GoToNextStatement(m_data, ref m_currentChar);
}
catch (Exception e)
{
if (e.Message == Constants.RETURN)
{
bRet = false;
}
else if (e.Message == Constants.END)
{
bRet = true;
}
else
{
throw new ArgumentException(e.Message);
}
if (!Constants.CHECK && !bRet.HasValue)
{
break; //return bRet.Value;
}
}
}
//if (bRet.HasValue && filename != null && s_Script.TryGetValue(filename, out string svalue))
//{
// ParserFunction.AddFunction(filename, new GetVarFunction(new Parser.Result(bRet == true ? 1 : 0 )));
//}
if (bRet.HasValue)
{
return(bRet.Value);
}
else
{
return(true);
}
}
internal Parser.Result ProcessIf()
{
int startIfCondition = m_currentChar;
Parser.Result result = null;
Parser.Result arg1 = GetNextIfToken();
string comparison = Utils.GetComparison(m_data, ref m_currentChar);
Parser.Result arg2 = GetNextIfToken();
bool isTrue = EvalCondition(arg1, comparison, arg2);
if (isTrue)
{
result = ProcessBlock();
if (result is Continue || result is Break)
{
// Got here from the middle of the if-block. Skip it.
m_currentChar = startIfCondition;
SkipBlock();
}
SkipRestBlocks();
return(result);
}
// We are in Else. Skip everything in the If statement.
SkipBlock();
int endOfToken = m_currentChar;
string nextToken = Utils.GetNextToken(m_data, ref endOfToken);
if (ELSE_IF_LIST.Contains(nextToken))
{
m_currentChar = endOfToken + 1;
result = ProcessIf();
}
else if (ELSE_LIST.Contains(nextToken))
{
m_currentChar = endOfToken + 1;
result = ProcessBlock();
}
return(new Parser.Result());
}
protected override Parser.Result Evaluate(string data, ref int from)
{
string varName = Utils.GetToken(data, ref from, Constants.NEXT_ARG_ARRAY);
if (from >= data.Length)
{
throw new ArgumentException("Couldn't set env variable");
}
Parser.Result varValue = Utils.GetItem(data, ref from);
string strValue = varValue.String != null ? varValue.String :
varValue.Value.ToString();
Environment.SetEnvironmentVariable(varName, strValue);
return(new Parser.Result(Double.NaN, varName));
}
protected override Parser.Result Evaluate(string data, ref int from)
{
string substring;
// 1. Get the name of the variable.
string varName = Utils.GetToken(data, ref from, Constants.NEXT_ARG_ARRAY);
if (from >= data.Length)
{
throw new ArgumentException("Couldn't get variable");
}
// 2. Get the current value of the variable.
ParserFunction func = ParserFunction.GetFunction(varName);
Parser.Result currentValue = func.GetValue(data, ref from);
// 3. Take either the string part if it is defined,
// or the numerical part converted to a string otherwise.
string arg = currentValue.String != null ? currentValue.String :
currentValue.Value.ToString();
// 4. Get the initial index of the substring.
bool lengthAvailable = Utils.SeparatorExists(data, from);
Parser.Result init = Utils.GetItem(data, ref from, true /* expectInt */);
// 5. Get the length of the substring if available.
if (lengthAvailable)
{
Parser.Result length = Utils.GetItem(data, ref from, true /* expectInt */);
if (init.Value + length.Value > arg.Length)
{
throw new ArgumentException("The total substring length is larger than [" +
arg + "]");
}
substring = arg.Substring((int)init.Value, (int)length.Value);
}
else
{
substring = arg.Substring((int)init.Value);
}
Parser.Result newValue = new Parser.Result(Double.NaN, substring);
return(newValue);
}
protected override Parser.Result Evaluate(string data, ref int from)
{
string varName = Utils.GetToken(data, ref from, Constants.NEXT_ARG_ARRAY);
if (from >= data.Length)
{
throw new ArgumentException("Couldn't set variable before end of line");
}
Parser.Result varValue = Utils.GetItem(data, ref from);
// Check if the variable to be set has the form of x(0),
// meaning that this is an array element.
int arrayIndex = Utils.ExtractArrayElement(ref varName);
if (arrayIndex >= 0)
{
bool exists = ParserFunction.FunctionExists(varName);
Parser.Result currentValue = exists ?
ParserFunction.GetFunction(varName).GetValue(data, ref from) :
new Parser.Result();
List <Parser.Result> tuple = currentValue.Tuple == null ?
new List <Parser.Result>() :
currentValue.Tuple;
if (tuple.Count > arrayIndex)
{
tuple[arrayIndex] = varValue;
}
else
{
for (int i = tuple.Count; i < arrayIndex; i++)
{
tuple.Add(new Parser.Result(Double.NaN, string.Empty));
}
tuple.Add(varValue);
}
varValue = new Parser.Result(Double.NaN, null, tuple);
}
ParserFunction.AddFunction(varName, new GetVarFunction(varValue));
return(new Parser.Result(Double.NaN, varName));
}
public static List <string> GetFunctionArgs(string data, ref int from, int count = 0)
{
List <string> args = new List <string>();
bool moreArgs = true;
while (moreArgs)
{
moreArgs = Utils.SeparatorExists(data, from);
Parser.Result item = Utils.GetItem(data, ref from);
// Separate treatment for an array.
// Only 1-dimensional arrays are supported at the moment.
if (item.Tuple != null && item.Tuple.Count > 0)
{
for (int i = 0; i < item.Tuple.Count; i++)
{
Parser.Result arg = item.Tuple[i];
args.Add((arg.String != null ? arg.String : arg.Value.ToString()) + '\n');
}
continue;
}
if (item.String == null && Double.IsNaN(item.Value))
{
break;
}
args.Add(item.String != null ? item.String : item.Value.ToString());
}
if (count > 0)
{
if (args.Count != count)
{
string sMsg = "(";
foreach (string msg in args)
{
sMsg += " " + msg;
}
throw new ArgumentException("The number of argument is different" + sMsg + " )");
}
}
return(args);
}
public static Parser.Result GetItem(string data, ref int from, bool expectInt = false)
{
Parser.Result value = new Parser.Result();
if (data.Length <= from)
{
throw new ArgumentException("Incomplete function definition");
}
if (data[from] == Constants.NEXT_ARG)
{
from++;
}
// Utils.GoToNextStatement(data, ref from);
if (from < data.Length && data[from] == Constants.QUOTE)
{
from++; // skip first quote
if (from < data.Length && data[from] == Constants.QUOTE)
{ // the argument is ""
value.String = "";
}
else
{
value.String = Utils.GetToken(data, ref from, Constants.QUOTE_ARRAY);
}
from++; // skip next separation char
}
else
{
Parser.Result existing = Parser.LoadAndCalculate(data, ref from, Constants.NEXT_OR_END_ARRAY);
value.Copy(existing);
}
if (expectInt && Double.IsNaN(value.Value))
{
throw new ArgumentException("Integer expected instead of [" + value.String + "]");
}
if (from < data.Length && data[from] == Constants.END_ARG)
{
from++;
}
return(value);
}
protected override Parser.Result Evaluate(string data, ref int from)
{
Parser.Result id = Utils.GetItem(data, ref from, true /* expectInt */);
int processId = (int)id.Value;
try
{
Process process = Process.GetProcessById(processId);
process.Kill();
Interpreter.Instance.AppendOutput("Process " + processId + " killed");
}
catch (Exception exc)
{
throw new ArgumentException("Couldn't kill process " + processId +
" (" + exc.Message + ")");
}
return(new Parser.Result());
}
protected override Parser.Result Evaluate(string data, ref int from)
{
// First check if this element is part of an array:
if (from < data.Length && data[from - 1] == Constants.START_ARG)
{
// There is an index given - it may be for an element of the tuple.
if (m_value.Tuple == null || m_value.Tuple.Count == 0)
{
throw new ArgumentException("No tuple exists for the index");
}
Parser.Result index = Utils.GetItem(data, ref from, true /* expectInt */);
if (index.Value < 0 || index.Value >= m_value.Tuple.Count)
{
throw new ArgumentException("Incorrect index [" + index.Value +
"] for tuple of size " + m_value.Tuple.Count);
}
return(m_value.Tuple[(int)index.Value]);
}
return(m_value);
}
protected override Parser.Result Evaluate(string data, ref int from)
{
Parser.Result arg = Parser.LoadAndCalculate(data, ref from, Constants.END_ARG_ARRAY);
arg.Value = Math.Abs(arg.Value);
return(arg);
}
internal GetVarFunction(Parser.Result value)
{
m_value = value;
}
protected override Parser.Result Evaluate(string data, ref int from)
{
Parser.Result result = Parser.LoadAndCalculate(data, ref from, Constants.END_ARG_ARRAY);
result.Value = Math.Exp(result.Value);
return(result);
}