public static void CheckNotEnd(ParsingScript script, string name)
{
if (!script.StillValid())
{
string realName = Constants.GetRealName(name);
ThrowErrorMsg("Incomplete arguments for [" + realName + "]", script, script.Prev.ToString());
}
}
public static void CheckNotEmpty(ParsingScript script, string varName, string name)
{
if (!script.StillValid() || string.IsNullOrWhiteSpace(varName))
{
string realName = Constants.GetRealName(name);
ThrowErrorMsg("Incomplete arguments for [" + realName + "].", script, name);
}
}
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 = UpdateIfTernary(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);
}
int GetCurrentLineNumber(ParsingScript script)
{
if (script == m_debugging && !m_debugging.StillValid())
{
#if UNITY_EDITOR == false && UNITY_STANDALONE == false && __ANDROID__ == false && __IOS__ == false
return(-1);
#else
return(-2);
#endif
}
return(script.GetOriginalLineNumber());
}
// A "virtual" Constructor
public ParserFunction(ParsingScript script, string item, char ch, ref string action)
{
if (item.Length == 0 && (ch == Constants.START_ARG || !script.StillValid()))
{
// There is no function, just an expression in parentheses
m_impl = s_idFunction;
return;
}
m_impl = CheckString(script, item, ch);
if (m_impl != null)
{
return;
}
item = Constants.ConvertName(item);
m_impl = GetRegisteredAction(item, script, ref action);
if (m_impl != null)
{
return;
}
m_impl = GetArrayFunction(item, script, action);
if (m_impl != null)
{
return;
}
m_impl = GetObjectFunction(item, script);
if (m_impl != null)
{
return;
}
m_impl = GetVariable(item, script);
if (m_impl != null)
{
return;
}
if (m_impl == s_strOrNumFunction && string.IsNullOrWhiteSpace(item))
{
string problem = (!string.IsNullOrWhiteSpace(action) ? action : ch.ToString());
string restData = ch.ToString() + script.Rest;
throw new ArgumentException("Couldn't parse [" + problem + "] in " + restData + "...");
}
// Function not found, will try to parse this as a string in quotes or a number.
s_strOrNumFunction.Item = item;
m_impl = s_strOrNumFunction;
}
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);
}
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);
}
private static string UpdateAction(ParsingScript script, char[] to)
{
// We search a valid action till we get to the End of Argument ')'
// or pass the end of string.
if (!script.StillValid() || script.Current == Constants.END_ARG ||
to.Contains(script.Current))
{
return(Constants.NULL_ACTION);
}
string action = Utils.ValidAction(script.Rest);
// We need to advance forward not only the action length but also all
// the characters we skipped before getting the action.
int advance = action == null ? 0 : action.Length;
script.Forward(advance);
return(action == null ? Constants.NULL_ACTION : action);
}
protected override Variable Evaluate(ParsingScript script)
{
string dirname = (!script.StillValid() || script.Current == Constants.END_STATEMENT) ?
Directory.GetCurrentDirectory() :
Utils.GetToken(script, Constants.NEXT_OR_END_ARRAY);
//List<Variable> results = Utils.GetPathnames(dirname);
List <Variable> results = new List <Variable>();
int index = dirname.IndexOf('*');
if (index < 0 && !Directory.Exists(dirname) && !File.Exists(dirname))
{
throw new ArgumentException("Directory [" + dirname + "] doesn't exist");
}
string pattern = Constants.ALL_FILES;
try
{
string dir = index < 0 ? Path.GetFullPath(dirname) : dirname;
if (File.Exists(dir))
{
FileInfo fi = new FileInfo(dir);
Interpreter.Instance.AppendOutput(Utils.GetPathDetails(fi, fi.Name), true);
results.Add(new Variable(fi.Name));
return(new Variable(results));
}
// Special dealing if there is a pattern (only * is supported at the moment)
if (index >= 0)
{
pattern = Path.GetFileName(dirname);
if (index > 0)
{
string prefix = dirname.Substring(0, index);
DirectoryInfo di = Directory.GetParent(prefix);
dirname = di.FullName;
}
else
{
dirname = ".";
}
}
dir = Path.GetFullPath(dirname);
// First get contents of the directory (unless there is a pattern)
DirectoryInfo dirInfo = new DirectoryInfo(dir);
if (pattern == Constants.ALL_FILES)
{
Interpreter.Instance.AppendOutput(Utils.GetPathDetails(dirInfo, "."), true);
if (dirInfo.Parent != null)
{
Interpreter.Instance.AppendOutput(Utils.GetPathDetails(dirInfo.Parent, ".."), true);
}
}
// Then get contents of all of the files in the directory
FileInfo[] fileNames = dirInfo.GetFiles(pattern);
foreach (FileInfo fi in fileNames)
{
try
{
Interpreter.Instance.AppendOutput(Utils.GetPathDetails(fi, fi.Name), true);
results.Add(new Variable(fi.Name));
}
catch (Exception)
{
continue;
}
}
// Then get contents of all of the subdirs in the directory
DirectoryInfo[] dirInfos = dirInfo.GetDirectories(pattern);
foreach (DirectoryInfo di in dirInfos)
{
try
{
Interpreter.Instance.AppendOutput(Utils.GetPathDetails(di, di.Name), true);
results.Add(new Variable(di.Name));
}
catch (Exception)
{
continue;
}
}
}
catch (Exception exc)
{
throw new ArgumentException("Couldn't list directory: " + exc.Message);
}
return(new Variable(results));
}
public static string ExtractNextToken(ParsingScript script, char[] to, ref bool inQuotes,
ref int arrayIndexDepth, ref int negated, out char ch, out string action, bool throwExc = true)
{
StringBuilder item = new StringBuilder();
ch = Constants.EMPTY;
action = null;
do
{
string negateSymbol = Utils.IsNotSign(script.Rest);
if (negateSymbol != null && !inQuotes)
{
negated++;
script.Forward(negateSymbol.Length);
continue;
}
ch = script.CurrentAndForward();
CheckQuotesIndices(script, ch, ref inQuotes, ref arrayIndexDepth);
bool keepCollecting = inQuotes || arrayIndexDepth > 0 ||
StillCollecting(item.ToString(), to, script, ref action);
if (keepCollecting)
{
// The char still belongs to the previous operand.
item.Append(ch);
bool goForMore = script.StillValid() &&
(inQuotes || arrayIndexDepth > 0 || !to.Contains(script.Current));
if (goForMore)
{
continue;
}
}
if (SkipOrAppendIfNecessary(item, ch, to))
{
continue;
}
break;
}while (true);
if (to.Contains(Constants.END_ARRAY) && ch == Constants.END_ARRAY &&
item[item.Length - 1] != Constants.END_ARRAY &&
item.ToString().Contains(Constants.START_ARRAY))
{
item.Append(ch);
}
string result = item.ToString();
result = result.Replace("\\\\", "\\");
result = result.Replace("\\\"", "\"");
result = result.Replace("\\'", "'");
if (throwExc && string.IsNullOrWhiteSpace(result) && action != "++" && action != "--" &&
Utils.IsAction(script.Prev) && Utils.IsAction(script.PrevPrev))
{
Utils.ThrowErrorMsg("Can't process token [" + script.PrevPrev + script.Prev + script.Current +
"].", script, script.Current.ToString());
}
return(result);
}
bool Completed(ParsingScript debugging)
{
return((LastResult != null && LastResult.IsReturn) ||
!debugging.StillValid());
}