static async Task <bool> UpdateIfTernaryAsync(ParsingScript script, string token, char ch, List <Variable> listInput, Action <List <Variable> > listToMerge)
{
if (listInput.Count < 1 || ch != Constants.TERNARY_OPERATOR || token.Length > 0)
{
return(false);
}
Variable arg1 = MergeList(listInput);
script.MoveForwardIf(Constants.TERNARY_OPERATOR);
Variable arg2 = await script.ExecuteAsync(Constants.TERNARY_SEPARATOR);
script.MoveForwardIf(Constants.TERNARY_SEPARATOR);
Variable arg3 = await script.ExecuteAsync(Constants.NEXT_OR_END_ARRAY);
script.MoveForwardIf(Constants.NEXT_OR_END_ARRAY);
double condition = arg1.AsDouble();
Variable result = condition != 0 ? arg2 : arg3;
listInput.Clear();
listInput.Add(result);
listToMerge(listInput);
return(true);
}
static bool UpdateIfTernary(ParsingScript script, string token, char ch, List <Variable> listInput, Action <List <Variable> > listToMerge)
{
if (listInput.Count < 1 || ch != Constants.TERNARY_OPERATOR || token.Length > 0)
{
return(false);
}
Variable result;
Variable arg1 = MergeList(listInput, script);
script.MoveForwardIf(Constants.TERNARY_OPERATOR);
double condition = arg1.AsDouble();
if (condition != 0)
{
result = script.Execute(Constants.TERNARY_SEPARATOR);
script.MoveForwardIf(Constants.TERNARY_SEPARATOR);
Utils.SkipRestExpr(script, Constants.END_STATEMENT);
}
else
{
Utils.SkipRestExpr(script, Constants.TERNARY_SEPARATOR[0]);
script.MoveForwardIf(Constants.TERNARY_SEPARATOR);
result = script.Execute(Constants.NEXT_OR_END_ARRAY);
}
listInput.Clear();
listInput.Add(result);
listToMerge(listInput);
return(true);
}
static bool UpdateIfTernary(ParsingScript script, string token, char ch, ref List <Variable> listToMerge)
{
if (listToMerge.Count < 1 || ch != Constants.TERNARY_OPERATOR || token.Length > 0)
{
return(false);
}
Variable arg1 = MergeList(listToMerge);
script.MoveForwardIf(Constants.TERNARY_OPERATOR);
Variable arg2 = script.Execute(Constants.TERNARY_SEPARATOR);
script.MoveForwardIf(Constants.TERNARY_SEPARATOR);
Variable arg3 = script.Execute(Constants.NEXT_OR_END_ARRAY);
script.MoveForwardIf(Constants.NEXT_OR_END_ARRAY);
double condition = arg1.AsDouble();
Variable result = condition != 0 ? arg2 : arg3;
listToMerge.Clear();
listToMerge.Add(result);
return(true);
}
protected override Variable Evaluate(ParsingScript script)
{
// 1. Get the name of the variable.
string varName = Utils.GetToken(script, Constants.END_ARG_ARRAY);
Utils.CheckNotEnd(script, m_name);
List <Variable> arrayIndices = Utils.GetArrayIndices(ref varName);
// 2. Get the current value of the variable.
ParserFunction func = ParserFunction.GetFunction(varName);
Utils.CheckNotNull(varName, func);
Variable currentValue = func.GetValue(script);
Variable element = currentValue;
// 2b. Special case for an array.
if (arrayIndices.Count > 0)// array element
{
element = Utils.ExtractArrayElement(currentValue, arrayIndices);
script.MoveForwardIf(Constants.END_ARRAY);
}
// 3. Convert type to string.
string type = Constants.TypeToString(element.Type);
script.MoveForwardIf(Constants.END_ARG, Constants.SPACE);
Variable newValue = new Variable(type);
return(newValue);
}
public static Variable GetItem(ParsingScript script, bool eatLast = true)
{
script.MoveForwardIf(Constants.NEXT_ARG, Constants.SPACE);
Utils.CheckNotEnd(script);
bool inQuotes = script.Current == Constants.QUOTE;
if (script.Current == Constants.START_GROUP)
{
// We are extracting a list between curly braces.
script.Forward(); // Skip the first brace.
bool isList = true;
Variable value = new Variable();
value.Tuple = GetArgs(script,
Constants.START_GROUP, Constants.END_GROUP, out isList);
return(value);
}
// A variable, a function, or a number.
Variable var = script.Execute(Constants.NEXT_OR_END_ARRAY);
//value = var.Clone();
if (inQuotes)
{
script.MoveForwardIf(Constants.QUOTE);
}
if (eatLast)
{
script.MoveForwardIf(Constants.END_ARG, Constants.SPACE);
}
return(var);
}
public static async Task <List <Variable> > GetArgsAsync(ParsingScript script,
char start, char end, Action <bool> outList)
{
List <Variable> args = new List <Variable>();
bool isList = script.StillValid() && script.Current == Constants.START_GROUP;
if (!script.StillValid() || script.Current == Constants.END_STATEMENT)
{
return(args);
}
ParsingScript tempScript = script.GetTempScript(script.String, script.Pointer);
/*ParsingScript tempScript = new ParsingScript(script.String, script.Pointer);
* tempScript.ParentScript = script;
* tempScript.InTryBlock = script.InTryBlock;*/
if (script.Current != start && script.TryPrev() != start &&
(script.Current == ' ' || script.TryPrev() == ' '))
{ // Allow functions with space separated arguments
start = ' ';
end = Constants.END_STATEMENT;
}
// ScriptingEngine - body is unsed (used in Debugging) but GetBodyBetween has sideeffects
#pragma warning disable 219
string body = Utils.GetBodyBetween(tempScript, start, end);
#pragma warning restore 219
// After the statement above tempScript.Parent will point to the last
// character belonging to the body between start and end characters.
while (script.Pointer < tempScript.Pointer)
{
Variable item = await Utils.GetItemAsync(script, false);
args.Add(item);
if (script.Pointer < tempScript.Pointer)
{
script.MoveForwardIf(Constants.END_GROUP);
script.MoveForwardIf(Constants.NEXT_ARG);
}
if (script.Pointer == tempScript.Pointer - 1)
{
script.MoveForwardIf(Constants.END_ARG, Constants.END_GROUP);
}
}
if (script.Pointer <= tempScript.Pointer)
{
// Eat closing parenthesis, if there is one, but only if it closes
// the current argument list, not one after it.
script.MoveForwardIf(Constants.END_ARG, end);
}
script.MoveForwardIf(Constants.SPACE);
//script.MoveForwardIf(Constants.SPACE, Constants.END_STATEMENT);
outList(isList);
return(args);
}
public static List <string> ExtractTokens(ParsingScript script)
{
List <string> tokens = new List <string>();
script.MoveForwardIf(Constants.START_ARG);
while (script.TryCurrent() != Constants.END_GROUP)
{
string propName = Utils.GetToken(script, Constants.TOKEN_SEPARATION);
script.MoveForwardIf(Constants.NEXT_ARG);
tokens.Add(propName);
}
return(tokens);
}
protected override Variable Evaluate(ParsingScript script)
{
// First check if this element is part of an array:
if (script.TryPrev() == Constants.START_ARRAY)
{
// There is an index given - it must 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");
}
if (m_arrayIndices == null)
{
string startName = script.Substr(script.Pointer - 1);
m_arrayIndices = Utils.GetArrayIndices(ref startName, ref m_delta);
}
script.Forward(m_delta);
while (script.MoveForwardIf(Constants.END_ARRAY))
{
}
Variable result = Utils.ExtractArrayElement(m_value, m_arrayIndices);
return(result);
}
// Otherwise just return the stored value.
return(m_value);
}
public static string[] GetCompiledFunctionSignature(ParsingScript script, out Dictionary <string, Variable> dict)
{
script.MoveForwardIf(Constants.START_ARG, Constants.SPACE);
int endArgs = script.FindFirstOf(Constants.END_ARG.ToString());
if (endArgs < 0)
{
throw new ArgumentException("Couldn't extract function signature");
}
string argStr = script.Substr(script.Pointer, endArgs - script.Pointer);
List <string> args = GetCompiledArgs(argStr);
//string[] args = argStr.Split(Constants.NEXT_ARG_ARRAY, StringSplitOptions.RemoveEmptyEntries);
dict = new Dictionary <string, Variable>(args.Count);
var sep = new char [] { ' ' };
for (int i = 0; i < args.Count; i++)
{
string[] pair = args[i].Trim().Split(sep, StringSplitOptions.RemoveEmptyEntries);
Variable.VarType type = pair.Length > 1 ? Constants.StringToType(pair[0]) : Variable.VarType.STRING;
dict.Add(pair[pair.Length - 1], new Variable(type));
args[i] = pair[pair.Length - 1];
}
string[] result = args.Select(element => element.Trim()).ToArray();
script.Pointer = endArgs + 1;
return(result);
}
protected override Variable Evaluate(ParsingScript script)
{
string funcName = Utils.GetToken(script, Constants.TOKEN_SEPARATION);
//Interpreter.Instance.AppendOutput("Registering function [" + funcName + "] ...");
string[] args = Utils.GetFunctionSignature(script);
if (args.Length == 1 && string.IsNullOrWhiteSpace(args[0]))
{
args = new string[0];
}
script.MoveForwardIf(Constants.START_GROUP, Constants.SPACE);
int parentOffset = script.Pointer;
string body = Utils.GetBodyBetween(script, Constants.START_GROUP, Constants.END_GROUP);
CustomFunction customFunc = new CustomFunction(funcName, body, args);
customFunc.ParentScript = script;
customFunc.ParentOffset = parentOffset;
ParserFunction.RegisterFunction(funcName, customFunc, false /* not native */);
return(new Variable(funcName));
}
protected override Variable Evaluate(ParsingScript script)
{
string funcReturn, funcName;
Utils.GetCompiledArgs(script, out funcReturn, out funcName);
#if __ANDROID__ == false && __IOS__ == false
Precompiler.RegisterReturnType(funcName, funcReturn);
Dictionary <string, Variable> argsMap;
string[] args = Utils.GetCompiledFunctionSignature(script, out argsMap);
script.MoveForwardIf(Constants.START_GROUP, Constants.SPACE);
int parentOffset = script.Pointer;
string body = Utils.GetBodyBetween(script, Constants.START_GROUP, Constants.END_GROUP);
Precompiler precompiler = new Precompiler(funcName, args, argsMap, body, script);
precompiler.Compile();
CustomCompiledFunction customFunc = new CustomCompiledFunction(funcName, body, args, precompiler, argsMap, script);
customFunc.ParentScript = script;
customFunc.ParentOffset = parentOffset;
ParserFunction.RegisterFunction(funcName, customFunc, false /* not native */);
#endif
return(new Variable(funcName));
}
public static List <Variable> GetArgs(ParsingScript script,
char start, char end, out bool isList)
{
List <Variable> args = new List <Variable>();
isList = script.StillValid() && script.Current == Constants.START_GROUP;
if (!script.StillValid() || script.Current == Constants.END_STATEMENT)
{
return(args);
}
ParsingScript tempScript = new ParsingScript(script.String, script.Pointer);
tempScript.ParentScript = script;
tempScript.InTryBlock = script.InTryBlock;
string body = Utils.GetBodyBetween(tempScript, start, end);
// After the statement above tempScript.Parent will point to the last
// character belonging to the body between start and end characters.
while (script.Pointer < tempScript.Pointer)
{
Variable item = Utils.GetItem(script, false);
args.Add(item);
if (script.Pointer < tempScript.Pointer)
{
script.MoveForwardIf(Constants.NEXT_ARG);
}
if (script.Pointer == tempScript.Pointer - 1)
{
script.MoveForwardIf(Constants.END_ARG);
}
}
if (script.Pointer <= tempScript.Pointer)
{
// Eat closing parenthesis, if there is one, but only if it closes
// the current argument list, not one after it.
script.MoveForwardIf(Constants.END_ARG);
}
script.MoveForwardIf(Constants.SPACE);
//script.MoveForwardIf(Constants.SPACE, Constants.END_STATEMENT);
return(args);
}
static Variable ExtractObject(ParsingScript script)
{
Variable newValue = new Variable(Variable.VarType.ARRAY);
while (script.StillValid() && (newValue.Count == 0 || script.Current == ','))
{
script.Forward();
string key = Utils.GetToken(script, SEP);
script.MoveForwardIf(':');
Variable valueVar = ExtractValue(script);
newValue.SetHashVariable(key, valueVar);
}
script.MoveForwardIf('}');
return(newValue);
}
protected override Variable Evaluate(ParsingScript script)
{
string methodName = Utils.GetItem(script).AsString();
Utils.CheckNotEmpty(script, methodName, m_name);
script.MoveForwardIf(Constants.NEXT_ARG);
string paramName = Utils.GetToken(script, Constants.NEXT_ARG_ARRAY);
Utils.CheckNotEmpty(script, paramName, m_name);
script.MoveForwardIf(Constants.NEXT_ARG);
Variable paramValueVar = Utils.GetItem(script);
string paramValue = paramValueVar.AsString();
var result = Statics.InvokeCall(typeof(Statics),
methodName, paramName, paramValue);
return(result);
}
internal Variable ProcessCase(ParsingScript script, string reason)
{
if (reason == Constants.CASE)
{
/*var token = */ Utils.GetToken(script, Constants.TOKEN_SEPARATION);
}
script.MoveForwardIf(':');
Variable result = ProcessBlock(script);
return(result);
}
protected override Variable Evaluate(ParsingScript script)
{
script.MoveForwardIf(Constants.SPACE);
Variable result = Utils.GetItem(script);
// If we are in Return, we are done:
script.SetDone();
result.IsReturn = true;
return(result);
}
static Variable ExtractArray(ParsingScript script)
{
Variable newValue = new Variable(Variable.VarType.ARRAY);
while (script.StillValid() && (newValue.Count == 0 || script.Current == ','))
{
script.Forward();
Variable addVariable = ExtractValue(script);
newValue.AddVariable(addVariable);
}
script.MoveForwardIf(']');
return(newValue);
}
protected override Variable Evaluate(ParsingScript script)
{
bool prefix = string.IsNullOrWhiteSpace(m_name);
if (prefix)// If it is a prefix we do not have the variable name yet.
{
m_name = Utils.GetToken(script, Constants.TOKEN_SEPARATION);
}
// Value to be added to the variable:
int valueDelta = m_action == Constants.INCREMENT ? 1 : -1;
int returnDelta = prefix ? valueDelta : 0;
// Check if the variable to be set has the form of x[a][b],
// meaning that this is an array element.
double newValue = 0;
List <Variable> arrayIndices = Utils.GetArrayIndices(ref m_name);
ParserFunction func = ParserFunction.GetFunction(m_name);
Utils.CheckNotNull(m_name, func);
Variable currentValue = func.GetValue(script);
if (arrayIndices.Count > 0 || script.TryCurrent() == Constants.START_ARRAY)
{
if (prefix)
{
string tmpName = m_name + script.Rest;
int delta = 0;
arrayIndices = Utils.GetArrayIndices(ref tmpName, ref delta);
script.Forward(Math.Max(0, delta - tmpName.Length));
}
Variable element = Utils.ExtractArrayElement(currentValue, arrayIndices);
script.MoveForwardIf(Constants.END_ARRAY);
newValue = element.Value + returnDelta;
element.Value += valueDelta;
}
else // A normal variable.
{
newValue = currentValue.Value + returnDelta;
currentValue.Value += valueDelta;
}
ParserFunction.AddGlobalOrLocalVariable(m_name,
new GetVarFunction(currentValue));
return(new Variable(newValue));
}
protected override Variable Evaluate(ParsingScript script)
{
// 1. Get the name of the variable.
string varName = Utils.GetToken(script, Constants.END_ARG_ARRAY);
Utils.CheckNotEnd(script, m_name);
List <Variable> arrayIndices = Utils.GetArrayIndices(ref varName);
// 2. Get the current value of the variable.
ParserFunction func = ParserFunction.GetFunction(varName);
Utils.CheckNotNull(varName, func);
Variable currentValue = func.GetValue(script);
Variable element = currentValue;
// 2b. Special case for an array.
if (arrayIndices.Count > 0)// array element
{
element = Utils.ExtractArrayElement(currentValue, arrayIndices);
script.MoveForwardIf(Constants.END_ARRAY);
}
// 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 = element.Type == Variable.VarType.ARRAY ?
element.Tuple.Count :
element.AsString().Length;
script.MoveForwardIf(Constants.END_ARG, Constants.SPACE);
Variable newValue = new Variable(size);
return(newValue);
}
protected override Variable Evaluate(ParsingScript script)
{
script.MoveForwardIf(Constants.SPACE);
if (!script.FromPrev(Constants.RETURN.Length).Contains(Constants.RETURN))
{
script.Backward();
}
Variable result = Utils.GetItem(script);
// If we are in Return, we are done:
script.SetDone();
result.IsReturn = true;
return(result);
}
public static async Task <List <Variable> > GetArrayIndicesAsync(ParsingScript script, string varName, int end, Action <string, int> updateVals)
{
List <Variable> indices = new List <Variable>();
int argStart = varName.IndexOf(Constants.START_ARRAY);
if (argStart < 0)
{
return(indices);
}
int firstIndexStart = argStart;
while (argStart < varName.Length &&
varName[argStart] == Constants.START_ARRAY)
{
int argEnd = varName.IndexOf(Constants.END_ARRAY, argStart + 1);
if (argEnd == -1 || argEnd <= argStart + 1)
{
break;
}
ParsingScript tempScript = script.GetTempScript(varName, argStart);
/*ParsingScript tempScript = new ParsingScript(varName, argStart);
* tempScript.ParentScript = script;
* tempScript.Char2Line = script.Char2Line;
* tempScript.Filename = script.Filename;
* tempScript.OriginalScript = script.OriginalScript;
* tempScript.InTryBlock = script.InTryBlock;*/
tempScript.MoveForwardIf(Constants.START_ARG, Constants.START_ARRAY);
Variable index = await tempScript.ExecuteAsync(Constants.END_ARRAY_ARRAY);
indices.Add(index);
argStart = argEnd + 1;
}
if (indices.Count > 0)
{
varName = varName.Substring(0, firstIndexStart);
end = argStart - 1;
}
updateVals(varName, end);
return(indices);
}
static List <Variable> Split(ParsingScript script, char[] to)
{
List <Variable> listToMerge = new List <Variable>(16);
if (!script.StillValid() || to.Contains(script.Current))
{
listToMerge.Add(Variable.EmptyInstance);
script.Forward();
return(listToMerge);
}
int arrayIndexDepth = 0;
bool inQuotes = false;
int negated = 0;
char ch;
string action;
do
{ // Main processing cycle of the first part.
string token = ExtractNextToken(script, to, ref inQuotes, ref arrayIndexDepth, ref negated, out ch, out action);
bool ternary = UpdateIfTernary(script, token, ch, listToMerge, (List <Variable> newList) => { listToMerge = newList; });
if (ternary)
{
return(listToMerge);
}
bool negSign = CheckConsistencyAndSign(script, listToMerge, action, ref token);
// We are done getting the next token. The GetValue() call below may
// recursively call SplitAndMerge(). This will happen if extracted
// item is a function or if the next item is starting with a START_ARG '('.
ParserFunction func = new ParserFunction(script, token, ch, ref action);
Variable current = func.GetValue(script);
if (UpdateResult(script, to, listToMerge, token, negSign, ref current, ref negated, ref action))
{
return(listToMerge);
}
} while (script.StillValid() &&
(inQuotes || arrayIndexDepth > 0 || !to.Contains(script.Current)));
// This happens when called recursively inside of the math expression:
script.MoveForwardIf(Constants.END_ARG);
return(listToMerge);
}
static async Task <List <Variable> > SplitAsync(ParsingScript script, char[] to)
{
List <Variable> listToMerge = new List <Variable>(16);
if (!script.StillValid() || to.Contains(script.Current))
{
listToMerge.Add(Variable.EmptyInstance);
script.Forward();
return(listToMerge);
}
int arrayIndexDepth = 0;
bool inQuotes = false;
int negated = 0;
char ch;
string action;
do
{ // Main processing cycle of the first part.
string token = ExtractNextToken(script, to, ref inQuotes, ref arrayIndexDepth, ref negated, out ch, out action);
bool ternary = await UpdateIfTernaryAsync(script, token, ch, listToMerge, (List <Variable> newList) => { listToMerge = newList; });
if (ternary)
{
return(listToMerge);
}
bool negSign = CheckConsistencyAndSign(script, listToMerge, action, ref token);
ParserFunction func = new ParserFunction(script, token, ch, ref action);
Variable current = await func.GetValueAsync(script);
if (UpdateResult(script, to, listToMerge, token, negSign, ref current, ref negated, ref action))
{
return(listToMerge);
}
} while (script.StillValid() &&
(inQuotes || arrayIndexDepth > 0 || !to.Contains(script.Current)));
// This happens when called recursively inside of the math expression:
script.MoveForwardIf(Constants.END_ARG);
return(listToMerge);
}
public static List <Variable> GetArrayIndices(ParsingScript script, ref string varName, ref int end)
{
List <Variable> indices = new List <Variable>();
int argStart = varName.IndexOf(Constants.START_ARRAY);
if (argStart < 0)
{
return(indices);
}
int firstIndexStart = argStart;
while (argStart < varName.Length &&
varName[argStart] == Constants.START_ARRAY)
{
int argEnd = varName.IndexOf(Constants.END_ARRAY, argStart + 1);
if (argEnd == -1 || argEnd <= argStart + 1)
{
break;
}
ParsingScript tempScript = new ParsingScript(varName, argStart);
tempScript.ParentScript = script;
tempScript.Char2Line = script.Char2Line;
tempScript.Filename = script.Filename;
tempScript.OriginalScript = script.OriginalScript;
tempScript.InTryBlock = script.InTryBlock;
tempScript.MoveForwardIf(Constants.START_ARG, Constants.START_ARRAY);
Variable index = tempScript.ExecuteTo(Constants.END_ARRAY);
indices.Add(index);
argStart = argEnd + 1;
}
if (indices.Count > 0)
{
varName = varName.Substring(0, firstIndexStart);
end = argStart - 1;
}
return(indices);
}
protected override Variable Evaluate(ParsingScript script)
{
string source = Utils.GetItem(script).AsString();
script.MoveForwardIf(Constants.NEXT_ARG, Constants.SPACE);
string dest = Utils.GetItem(script).AsString();
string src = Path.GetFullPath(source);
string dst = Path.GetFullPath(dest);
bool isFile = File.Exists(src);
bool isDir = Directory.Exists(src);
if (!isFile && !isDir)
{
throw new ArgumentException("[" + src + "] doesn't exist");
}
if (isFile && Directory.Exists(dst))
{
// If filename is missing in the destination file,
// add it from the source.
dst = Path.Combine(dst, Path.GetFileName(src));
}
try
{
if (isFile)
{
File.Move(src, dst);
}
else
{
Directory.Move(src, dst);
}
}
catch (Exception exc)
{
throw new ArgumentException("Couldn't copy: " + exc.Message);
}
return(Variable.EmptyInstance);
}
public static string[] GetFunctionSignature(ParsingScript script)
{
script.MoveForwardIf(Constants.START_ARG, Constants.SPACE);
int endArgs = script.FindFirstOf(Constants.END_ARG.ToString());
if (endArgs < 0)
{
throw new ArgumentException("Couldn't extract function signature");
}
string argStr = script.Substr(script.Pointer, endArgs - script.Pointer);
string[] args = argStr.Split(Constants.NEXT_ARG_ARRAY);
script.Pointer = endArgs + 1;
return(args);
}
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);
}
public static string GetStringOrVarValue(ParsingScript script)
{
script.MoveForwardIf(Constants.SPACE);
// If this token starts with a quote then it is a string constant.
// Otherwide we treat it as a variable, but if the variable doesn't exist then it
// will be still treated as a string constant.
bool stringConstant = script.Rest.StartsWith(Constants.QUOTE.ToString());
string token = Utils.GetToken(script, Constants.NEXT_OR_END_ARRAY);
// Check if this is a variable definition:
stringConstant = stringConstant || !ParserFunction.FunctionExists(token);
if (!stringConstant)
{
Variable sourceValue = ParserFunction.GetFunction(token).GetValue(script);
token = sourceValue.String;
}
return(token);
}
public static List <Variable> GetArrayIndices(ParsingScript script, string varName, int end, Action <string, int> updateVals)
{
List <Variable> indices = new List <Variable>();
int argStart = varName.IndexOf(Constants.START_ARRAY);
if (argStart < 0)
{
return(indices);
}
int firstIndexStart = argStart;
while (argStart < varName.Length &&
varName[argStart] == Constants.START_ARRAY)
{
int argEnd = varName.IndexOf(Constants.END_ARRAY, argStart + 1);
if (argEnd == -1 || argEnd <= argStart + 1)
{
break;
}
ParsingScript tempScript = script.GetTempScript(varName, argStart);
tempScript.MoveForwardIf(Constants.START_ARG, Constants.START_ARRAY);
Variable index = tempScript.Execute(Constants.END_ARRAY_ARRAY);
indices.Add(index);
argStart = argEnd + 1;
}
if (indices.Count > 0)
{
varName = varName.Substring(0, firstIndexStart);
end = argStart - 1;
}
updateVals(varName, end);
return(indices);
}
protected override Variable Evaluate(ParsingScript script)
{
string source = Utils.GetItem(script).AsString();
script.MoveForwardIf(Constants.NEXT_ARG, Constants.SPACE);
string dest = Utils.GetItem(script).AsString();
string src = Path.GetFullPath(source);
string dst = Path.GetFullPath(dest);
List <Variable> srcPaths = Utils.GetPathnames(src);
bool multipleFiles = srcPaths.Count > 1;
if (dst.EndsWith("*"))
{
dst = dst.Remove(dst.Count() - 1);
}
if ((multipleFiles || Directory.Exists(src)) &&
!Directory.Exists(dst))
{
try
{
Directory.CreateDirectory(dst);
}
catch (Exception exc)
{
throw new ArgumentException("Couldn't create [" + dst + "] :" + exc.Message);
}
}
foreach (Variable srcPath in srcPaths)
{
string filename = Path.GetFileName(srcPath.String);
//string dstPath = Path.Combine(dst, filename);
Utils.Copy(srcPath.String, dst);
}
return(Variable.EmptyInstance);
}
