private SObject ExecuteLink(ScriptStatement statement)
{
if (Context.HasCallback(CallbackType.ScriptPipeline))
{
var exp = statement.Code;
exp = exp.Remove(0, "link ".Length).Trim();
var callback = (DScriptPipeline)Context.GetCallback(CallbackType.ScriptPipeline);
var task = Task <string> .Factory.StartNew(() => callback(this, exp));
task.Wait();
var code = task.Result;
var statements = StatementProcessor.GetStatements(this, code);
// Convert the current statements into a list, so we can modify them.
var tempStatements = _statements.ToList();
// Remove the "link" statement, because we don't want to step into it again if we are in a loop.
tempStatements.RemoveAt(_index);
// Insert class, using and link statements right after the current statement.
var insertIndex = _index;
for (var i = 0; i < statements.Length; i++)
{
if (statements[i].StatementType == StatementType.Class)
{
// The class statement needs its body, so we add the class statement and the one afterwards:
if (statements.Length > i + 1)
{
tempStatements.Insert(insertIndex, statements[i]);
tempStatements.Insert(insertIndex + 1, statements[i + 1]);
insertIndex += 2;
}
else
{
ErrorHandler.ThrowError(ErrorType.SyntaxError, ErrorHandler.MessageSyntaxExpectedExpression, "end of script");
}
}
else if (statements[i].StatementType == StatementType.Import || statements[i].StatementType == StatementType.Link)
{
tempStatements.Insert(insertIndex, statements[i]);
insertIndex += 1;
}
}
// Convert the temp statement list back and reduce the index by one, because we deleted the current statement.
_statements = tempStatements.ToArray();
_index--;
return(Undefined);
}
else
{
return(ErrorHandler.ThrowError(ErrorType.ApiError, ErrorHandler.MessageApiNotSupported));
}
}
private SObject ProcessStatements()
{
var returnObject = Undefined;
_statements = StatementProcessor.GetStatements(this, _source);
_index = 0;
while (_index < _statements.Length)
{
returnObject = ExecuteStatement(_statements[_index]);
if (_continueIssued || _breakIssued || _returnIssued)
{
returnObject = SObject.Unbox(returnObject);
return(returnObject);
}
_index++;
}
return(SObject.Unbox(returnObject));
}
private SObject ExecuteFor(ScriptStatement statement)
{
var exp = statement.Code;
var forCode = exp.Remove(0, exp.IndexOf("for", StringComparison.Ordinal) + "for".Length).Trim().Remove(0, 1); // Remove "for" and "(".
forCode = forCode.Remove(forCode.Length - 1, 1); // Remove ")".
var forStatements = StatementProcessor.GetStatements(this, forCode);
if (forStatements.Length == 0)
{
return(ErrorHandler.ThrowError(ErrorType.SyntaxError, ErrorHandler.MessageSyntaxExpectedExpression, ")"));
}
if (forStatements.Length == 1)
{
return(ErrorHandler.ThrowError(ErrorType.SyntaxError, ErrorHandler.MessageSyntaxMissingForInitializer));
}
if (forStatements.Length == 2)
{
return(ErrorHandler.ThrowError(ErrorType.SyntaxError, ErrorHandler.MessageSyntaxMissingForCondition));
}
if (forStatements.Length > 3)
{
return(ErrorHandler.ThrowError(ErrorType.SyntaxError, ErrorHandler.MessageSyntaxMissingForControl));
}
var processor = new ScriptProcessor(Context, GetLineNumber());
var forInitializer = forStatements[0];
var forCondition = forStatements[1];
var forControl = forStatements[2];
if (forInitializer.Code.Length > 0)
{
processor.ExecuteStatement(forInitializer);
}
_index++;
if (_statements.Length > _index)
{
var stayInFor = true;
var executeStatement = _statements[_index];
var returnObject = Undefined;
while (stayInFor)
{
if (forCondition.Code.Length > 0)
{
var conditionResult = processor.ExecuteStatement(forCondition);
var conditionAsBool = conditionResult as SBool;
stayInFor = conditionAsBool?.Value ?? conditionResult.ToBool(this).Value;
}
if (stayInFor)
{
returnObject = processor.ExecuteStatement(executeStatement);
if (processor._returnIssued || processor._breakIssued)
{
_breakIssued = false;
_returnIssued = processor._returnIssued;
stayInFor = false;
}
else if (forControl.Code.Length > 0)
{
processor.ExecuteStatement(forControl);
}
}
}
return(returnObject);
}
else
{
return(ErrorHandler.ThrowError(ErrorType.SyntaxError, ErrorHandler.MessageSyntaxExpectedExpression, "end of script"));
}
}
internal ScriptStatement(string code)
{
Code = code.Trim();
StatementType = StatementProcessor.GetStatementType(Code, false);
}