static void NormalizeValue(ParserFunction function)
{
GetVarFunction gvf = function as GetVarFunction;
if (gvf != null)
{
gvf.Value.CurrentAssign = "";
}
}
static ParserFunction GetObjectFunction(string name, ParsingScript script)
{
if (script.CurrentClass != null && script.CurrentClass.Name == name)
{
script.Backward(name.Length + 1);
return(new FunctionCreator());
}
if (script.ClassInstance != null &&
(script.ClassInstance.PropertyExists(name) || script.ClassInstance.FunctionExists(name)))
{
name = script.ClassInstance.InstanceName + "." + name;
}
//int ind = name.LastIndexOf('.');
int ind = name.IndexOf('.');
if (ind <= 0)
{
return(null);
}
string baseName = name.Substring(0, ind);
if (s_namespaces.ContainsKey(baseName))
{
int ind2 = name.IndexOf('.', ind + 1);
if (ind2 > 0)
{
ind = ind2;
baseName = name.Substring(0, ind);
}
}
string prop = name.Substring(ind + 1);
ParserFunction pf = ParserFunction.GetFromNamespace(prop, baseName, script);
if (pf != null)
{
return(pf);
}
pf = ParserFunction.GetVariable(baseName, script, true);
if (pf == null || !(pf is GetVarFunction))
{
pf = ParserFunction.GetFunction(baseName, script);
}
GetVarFunction varFunc = pf as GetVarFunction;
if (varFunc == null)
{
return(null);
}
varFunc.PropertyName = prop;
return(varFunc);
}
static string CreateVariableEntry(ParserFunction variable, bool isLocal = false)
{
if (!(variable is GetVarFunction) || string.IsNullOrWhiteSpace(variable.Name))
{
return(null);
}
GetVarFunction gvf = variable as GetVarFunction;
return(CreateVariableEntry(gvf.Value, variable.Name, isLocal));
}
public void RegisterArguments(List <Variable> args)
{
StackLevel stackLevel = new StackLevel(m_name);
for (int i = 0; i < m_args.Length; i++)
{
var arg = new GetVarFunction(args[i]);
arg.Name = m_args[i];
stackLevel.Variables[m_args[i]] = arg;
}
ParserFunction.AddLocalVariables(stackLevel);
}
static string CreateVariableEntry(ParserFunction variable, bool isLocal = false)
{
if (!(variable is GetVarFunction) || string.IsNullOrWhiteSpace(variable.Name))
{
return(null);
}
GetVarFunction gvf = variable as GetVarFunction;
string value = gvf.Value.AsString(true, true, 16);
string localGlobal = isLocal ? "0" : "1";
string varData = variable.Name + ":" + localGlobal + ":" +
Constants.TypeToString(gvf.Value.Type).ToLower() + ":" + value;
return(varData.Trim());
}
public static bool TryAddToNamespace(string name, string nameSpace, Variable varValue)
{
StackLevel level;
if (string.IsNullOrWhiteSpace(nameSpace) ||
!s_namespaces.TryGetValue(nameSpace, out level))
{
return(false);
}
var vars = level.Variables;
vars[name] = new GetVarFunction(varValue);
return(true);
}
static ParserFunction GetArrayFunction(string name, ParsingScript script, string action)
{
int arrayStart = name.IndexOf(Constants.START_ARRAY);
if (arrayStart < 0)
{
return(null);
}
if (arrayStart == 0)
{
Variable arr = Utils.ProcessArrayMap(new ParsingScript(name));
return(new GetVarFunction(arr));
}
string arrayName = name;
int delta = 0;
List <Variable> arrayIndices = Utils.GetArrayIndices(script, arrayName, delta, (string arr, int del) => { arrayName = arr; delta = del; });
if (arrayIndices.Count == 0)
{
return(null);
}
ParserFunction pf = ParserFunction.GetVariable(arrayName, script);
GetVarFunction varFunc = pf as GetVarFunction;
if (varFunc == null)
{
return(null);
}
// we temporarily backtrack for the processing
script.Backward(name.Length - arrayStart - 1);
script.Backward(action != null ? action.Length : 0);
// delta shows us how manxy chars we need to advance forward in GetVarFunction()
delta -= arrayName.Length;
delta += action != null ? action.Length : 0;
varFunc.Indices = arrayIndices;
varFunc.Delta = delta;
return(varFunc);
}
public static void AddGlobalOrLocalVariable(string name, GetVarFunction function)
{
name = Constants.ConvertName(name);
Dictionary <string, ParserFunction> lastLevel = GetLastLevel();
if (lastLevel != null && s_locals.Peek().IsNamespace&& !string.IsNullOrWhiteSpace(s_namespace))
{
name = s_namespacePrefix + name;
}
function.Name = Constants.GetRealName(name);
if (s_locals.Count > StackLevelDelta && (LocalNameExists(name) || !GlobalNameExists(name)))
{
AddLocalVariable(function);
}
else
{
AddGlobal(name, function, false /* not native */);
}
}
public static void AddGlobalOrLocalVariable(string name, GetVarFunction function,
ParsingScript script = null, bool localIfPossible = false)
{
name = Constants.ConvertName(name);
if (Constants.CheckReserved(name))
{
Utils.ThrowErrorMsg(name + " is a reserved name.", script, name);
}
bool globalOnly = !localIfPossible && !LocalNameExists(name);
Dictionary <string, ParserFunction> lastLevel = GetLastLevel();
if (!globalOnly && lastLevel != null && s_lastExecutionLevel.IsNamespace && !string.IsNullOrWhiteSpace(s_namespace))
{
name = s_namespacePrefix + name;
}
function.Name = Constants.GetRealName(name);
function.Value.ParamName = function.Name;
if (!globalOnly && !localIfPossible && script != null && script.StackLevel != null && !GlobalNameExists(name))
{
script.StackLevel.Variables[name] = function;
var handle = OnVariableChange;
if (handle != null)
{
handle.Invoke(function.Name, function.Value, false);
}
}
if (!globalOnly && s_locals.Count > StackLevelDelta &&
(localIfPossible || LocalNameExists(name) || !GlobalNameExists(name)))
{
AddLocalVariable(function);
}
else
{
AddGlobal(name, function, false /* not native */);
}
}
static ParserFunction GetObjectFunction(string name, ParsingScript script)
{
if (script.CurrentClass != null && script.CurrentClass.Name == name)
{
script.Backward(name.Length + 1);
return(new FunctionCreator());
}
if (script.ClassInstance != null &&
(script.ClassInstance.PropertyExists(name) || script.ClassInstance.FunctionExists(name)))
{
name = script.ClassInstance.InstanceName + "." + name;
}
int ind = name.IndexOf(".");
if (ind <= 0)
{
return(null);
}
string baseName = name.Substring(0, ind);
string prop = name.Substring(ind + 1);
ParserFunction pf = ParserFunction.GetFunctionNamespace(prop, baseName, script);
if (pf != null)
{
return(pf);
}
pf = ParserFunction.GetFunction(baseName, script);
GetVarFunction varFunc = pf as GetVarFunction;
if (varFunc == null)
{
return(null);
}
varFunc.PropertyName = prop;
return(varFunc);
}
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);
}
