public EvalResult RunEval(string code)
{
var sw = Stopwatch.StartNew();
var eval = CompileAndEval(code);
sw.Stop();
var compileTime = sw.Elapsed;
var evalResult = new EvalResult(null, eval, sw.Elapsed, compileTime);
//this hack is to test if we're about to send an object that can't be serialized back to the caller.
//if the object can't be serialized, return a failure instead.
try
{
JsonConvert.SerializeObject(evalResult);
}
catch (Exception ex)
{
evalResult = new EvalResult
{
Code = code,
CompileTime = compileTime,
ConsoleOut = eval,
ExecutionTime = sw.Elapsed,
ReturnTypeName = "Brainfk Type",
ReturnValue = $"An exception occurred when serializing the response: {ex.GetType().Name}: {ex.Message}"
};
}
return(evalResult);
}
public static bool Step(Expression criteria, IList <Variable> variables, IList <VariableLimitation> limitations, double absoluteStep, double relativeStep, int cacheGeneration = 0)
{
if (cacheGeneration == 0)
{
cacheGeneration = Expression.NextAutoIncrementId;
}
var variablesCount = variables.Count;
var derivatives = new Expression[variablesCount];
for (var variableIndex = 0; variableIndex < variablesCount; variableIndex++)
{
derivatives[variableIndex] = criteria.Derivate(variables[variableIndex]);
}
return(Step(
() =>
{
var result = new EvalResult()
{
Value = criteria.Evaluate(cacheGeneration),
Derivatives = new double[variablesCount]
};
for (var variableIndex = 0; variableIndex < variablesCount; variableIndex++)
{
result.Derivatives[variableIndex] = derivatives[variableIndex].Evaluate(cacheGeneration);
}
cacheGeneration = Expression.NextAutoIncrementId;
return result;
},
variables, limitations, absoluteStep, relativeStep
));
}
public async Task <IActionResult> GetAsync(int id, String username, String pw)
{
HttpClient client = new HttpClient();
HttpResponseMessage _responseToken = client.GetAsync("http://iwi-mostwanted-secret.azurewebsites.net/api/secret/token?username="******"&pw=" + pw).Result;
if (!_responseToken.StatusCode.ToString().Equals("OK"))
{
return(BadRequest("Username/PW falsch"));
}
String token = _responseToken.Content.ReadAsStringAsync().Result;
client.DefaultRequestHeaders.Add("Authorization", token);
HttpResponseMessage _response = client.GetAsync("http://iwi-mostwanted-evaluation.azurewebsites.net/api/eval/" + id).Result;
String ResponseCode = _response.StatusCode.ToString();
if (ResponseCode.Equals("NotFound"))
{
return(BadRequest("Auswertung nicht gefunden"));
}
else if (ResponseCode.Equals("BadRequest"))
{
return(BadRequest("Keine Berechtigung"));
}
else
{
EvalResult _erg = JsonConvert.DeserializeObject <EvalResult>(_response.Content.ReadAsStringAsync().Result);
return(Ok(_erg));
}
}
public Task <bool> EvaluateExpression(string expression, string code, EvalResult result)
{
EnsureConfigured();
try
{
object retResult;
bool hasResult;
printer.Reset();
if (!String.IsNullOrEmpty(code))
{
var ret = eval.Evaluate(code, out retResult, out hasResult);
}
result.Result = eval.Evaluate(expression);
return(Task.FromResult(true));
}
catch (Exception ex)
{
Log.Error($"Error creating a new instance of {expression}");
if (printer.Messages.Count != 0)
{
result.Messages = printer.Messages.ToArray();
}
else
{
result.Messages = new EvalMessage[] { new EvalMessage("error", ex.ToString()) };
}
if (!result.HasResult && result.Messages.Length == 0)
{
result.Messages = new EvalMessage[] { new EvalMessage("error", "Internal Error") };
}
eval = null;
}
return(Task.FromResult(false));
}
public CorDebugEval (CorDebugThread thread)
{
m_appDomain = thread.Chain.ActiveFrame.AppDomain;
m_threadReal = thread;
m_resultType = EvalResult.NotFinished;
ResetScratchPadLocation ();
}
public static DerivResult central_derivative(DerivFunction f, double x, double h)
{
double r_0;
EvalResult res = central_deriv(f, x, h);
double error = res.abserr_round + res.abserr_trunc;
r_0 = res.result;
if (res.abserr_round < res.abserr_trunc && (res.abserr_round > 0 && res.abserr_trunc > 0))
{
double error_opt;
/* Compute an optimised stepsize to minimize the total error,
* using the scaling of the truncation error (O(h^2)) and
* rounding error (O(1/h)). */
double h_opt = h * Math.Pow(res.abserr_round / (2.0 * res.abserr_trunc), 1.0 / 3.0);
res = central_deriv(f, x, h_opt);
error_opt = res.abserr_round + res.abserr_trunc;
/* Check that the new error is smaller, and that the new derivative
* is consistent with the error bounds of the original estimate. */
if (error_opt < error && Math.Abs(res.result - r_0) < 4.0 * error)
{
r_0 = res.result;
error = error_opt;
}
}
return(new DerivResult(r_0, error));
}
private void MangleAllLine(int total_anys,
int cur_anys, List <string> ret,
List <Expression.EvalResult> args_in)
{
if (cur_anys == total_anys)
{
var m = Mangle(target, args_in);
if (!ret.Contains(m))
{
ret.Add(m);
}
}
else
{
for (int i = 0; i < args_in.Count; i++)
{
if (args_in[i].Type == EvalResult.ResultType.Any)
{
continue;
}
List <EvalResult> new_args_in = new List <EvalResult>(args_in);
new_args_in[i] = new EvalResult {
Type = EvalResult.ResultType.Any
};
MangleAllLine(total_anys, cur_anys + 1, ret, new_args_in);
}
}
}
public static void TrackResult(this EvalResult result, TelemetryClient telemetryClient, ILogger logger)
{
try
{
var evt = new EventTelemetry("eval")
{
Timestamp = DateTimeOffset.UtcNow
};
evt.Metrics.Add("CompileTime", result.CompileTime.TotalMilliseconds);
evt.Metrics.Add("ExecutionTime", result.ExecutionTime.TotalMilliseconds);
evt.Properties.Add("Code", result.Code);
evt.Properties.Add("ConsoleOut", result.ConsoleOut);
evt.Properties.Add("ReturnValue", JsonConvert.SerializeObject(result.ReturnValue, Formatting.Indented));
evt.Properties.Add("ExceptionType", result.ExceptionType);
evt.Properties.Add("Exception", result.Exception);
telemetryClient.TrackEvent(evt);
}
catch (Exception ex)
{
logger.LogWarning($"Failed to record telemetry event: {ex}");
}
}
public override EvalResult Evaluate(MakeState s)
{
EvalResult elabel = label.Evaluate(s);
EvalResult eindex = index.Evaluate(s);
switch (elabel.Type)
{
case EvalResult.ResultType.String:
return(new EvalResult(new string(elabel.strval[(int)eindex.AsInt], 1)));
case EvalResult.ResultType.Array:
{
var idx = eindex.AsInt;
if (idx < 0 || idx >= elabel.arrval.Count)
{
return new EvalResult {
Type = EvalResult.ResultType.Null
}
}
;
else
{
return(elabel.arrval[(int)idx]);
}
}
case EvalResult.ResultType.Object:
return(elabel.objval[eindex.strval]);
default:
throw new Statement.SyntaxException("indexing cannot be applied to object of type: " + elabel.Type.ToString());
}
}
public void EvalTest()
{
EvalTest("LocalsTest4.py", 2, "g", 1, EvalResult.Value("baz", "int", "42"));
EvalTest("LocalsTest3.py", 2, "f", 0, EvalResult.Value("x", "int", "42"));
EvalTest("LocalsTest3.py", 2, "f", 0, EvalResult.Exception("not_defined", "name 'not_defined' is not defined"));
EvalTest("LocalsTest3.py", 2, "f", 0, EvalResult.ErrorExpression("/2", "unexpected token '/'\r\n"));
}
async Task <bool> Evaluate(string code, EvalResult result, string initCode, bool retryOnError)
{
try
{
printer.Reset();
if (initCode != null)
{
eval.Evaluate(initCode, out object retResult, out bool result_set);
}
result.Result = eval.Evaluate(code);
return(true);
}
catch (Exception ex)
{
if (retryOnError)
{
eval = null;
EnsureConfigured();
return(await Evaluate(code, result, initCode, false));
}
Log.Error($"Error evalutaing code");
eval = null;
if (printer.Messages.Count != 0)
{
result.Messages = printer.Messages.ToArray();
}
else
{
result.Messages = new[] { new EvalMessage("error", ex.ToString()) };
}
return(false);
}
}
async Task <EvalResult> EvalOnMainThread(EvalRequest code, CancellationToken token)
{
object result = null;
bool hasResult = false;
EvalResult evalResult = new EvalResult();
var sw = new System.Diagnostics.Stopwatch();
Log.Debug($"Evaluation request {code}");
sw.Start();
if (code.Xaml != null)
{
result = await LoadXAML(code.Xaml, code.XamlType, code.Declarations, evalResult);
hasResult = result != null;
}
else
{
throw new NotSupportedException();
}
sw.Stop();
Log.Debug($"Evaluation ended with result {result}");
evalResult.Duration = sw.Elapsed;
evalResult.Result = result;
evalResult.HasResult = hasResult;
return(evalResult);
}
public static double SurfaceEnergyChangerate(LevelSetTracker LsTrk, ConventionalDGField[] uI, double sigma, bool Norm, int momentFittingorder)
{
double Changerate_Surface = 0.0;
var SchemeHelper = LsTrk.GetXDGSpaceMetrics(new[] { LsTrk.GetSpeciesId("A") }, momentFittingorder, 1).XQuadSchemeHelper;
CellQuadratureScheme cqs = SchemeHelper.GetLevelSetquadScheme(0, LsTrk.Regions.GetCutCellMask());
ScalarFunctionEx SurfaceChangerate = GetInterfaceDivergenceFunc(LsTrk, uI, Norm);
CellQuadrature.GetQuadrature(new int[] { 1 }, LsTrk.GridDat,
cqs.Compile(LsTrk.GridDat, momentFittingorder),
delegate(int i0, int Length, QuadRule QR, MultidimensionalArray EvalResult) {
SurfaceChangerate(i0, Length, QR.Nodes, EvalResult.ExtractSubArrayShallow(-1, -1, 0));
},
delegate(int i0, int Length, MultidimensionalArray ResultsOfIntegration) {
for (int i = 0; i < Length; i++)
{
Changerate_Surface += ResultsOfIntegration[i, 0];
}
}
).Execute();
double Changerate_Esurf;
if (Norm)
{
Changerate_Esurf = sigma * Changerate_Surface.Sqrt();
}
else
{
Changerate_Esurf = sigma * Changerate_Surface;
}
return(Changerate_Esurf);
}
private EvalResult eval14(Tile lastTile, int depth, bool riichi = true, bool tsumo = false, bool isLastTile = false, EvalResult partialEvalResult = null)
{
var res = partialEvalResult;
if (res == null)
{
res = new EvalResult();
int normalDistance;
res.Distance = calcDistance(out normalDistance);
res.NormalDistance = normalDistance;
}
if (depth <= 1 || res.Distance == -1)
{
if (res.Distance == -1)
{
res.E_Point = calcPoint(lastTile, riichi, tsumo, isLastTile);
}
res.E_PromotionCount = new List <double>();
return(res);
}
else
{
EvalResult tmpResult;
chooseDiscardForAtk(out tmpResult, calcOptimization: false, depth: depth - 1);
return(tmpResult);
}
}
public static double EnergyBalanceNormAtInterface(XDGField P, VectorField <XDGField> U, ConventionalDGField[] Umean, SinglePhaseField C, double muA, double muB, double sigma, int momentFittingOrder)
{
LevelSetTracker LsTrk = P.Basis.Tracker;
double energyBal_Norm = 0.0;
ScalarFunctionEx energyBalFunc = GetEnergyBalanceFunc(P, U, Umean, C, muA, muB, sigma, true);
var SchemeHelper = LsTrk.GetXDGSpaceMetrics(new[] { LsTrk.GetSpeciesId("A") }, momentFittingOrder, 1).XQuadSchemeHelper;
CellQuadratureScheme cqs = SchemeHelper.GetLevelSetquadScheme(0, LsTrk.Regions.GetCutCellMask());
CellQuadrature.GetQuadrature(new int[] { 1 }, LsTrk.GridDat,
cqs.Compile(LsTrk.GridDat, momentFittingOrder),
delegate(int i0, int Length, QuadRule QR, MultidimensionalArray EvalResult) {
energyBalFunc(i0, Length, QR.Nodes, EvalResult.ExtractSubArrayShallow(-1, -1, 0));
},
delegate(int i0, int Length, MultidimensionalArray ResultsOfIntegration) {
for (int i = 0; i < Length; i++)
{
energyBal_Norm += ResultsOfIntegration[i, 0];
}
}
).Execute();
return(energyBal_Norm.Sqrt());
}
public async Task <bool> EvaluateCode(string code, EvalResult result, string initCode = null)
{
if (string.IsNullOrEmpty(code))
{
return(false);
}
EnsureConfigured();
try
{
ScriptState state;
if (initCode != null)
{
state = await CSharpScript.RunAsync(initCode);
await state.ContinueWithAsync(code);
}
else
{
state = await CSharpScript.RunAsync(code);
}
result.Result = state.ReturnValue;
}
catch (CompilationErrorException ex)
{
Log.Error($"Error evaluating code");
result.Messages = new EvalMessage[] { new EvalMessage("error", ex.ToString()) };
return(false);
}
return(true);
}
public override EvalResult Eval(RunePhrase sn)
{
var arg = sn._children?.First();
if (arg == null)
{
return(EvalResult.Fail());
}
var argtype = arg._rune.ResultType();
if (argtype == RuneType.Effect)
{
return(arg.Eval());
}
if (argtype == RuneType.Reference)
{
// TODO: for now we use BEH, which points to ITargetable.
// other runes could refer by different means, for example:
// ZU WATHIJDOET, referring to the spell cast by your target
Inscription?target = null;
this.caster.Target?.ReferenceWhenTargeted.TryPickT2(out target, out _);
if (target == null)
{
return(EvalResult.Fail());
}
return(target.InscribedSpell.Eval());
}
return(EvalResult.Fail());
}
public CorDebugEval(CorDebugThread thread)
{
m_appDomain = thread.Chain.ActiveFrame.AppDomain;
m_threadReal = thread;
m_resultType = EvalResult.NotFinished;
ResetScratchPadLocation();
}
internal EvalResult Evaluate(User user, IFeatureStore featureStore, EventFactory eventFactory)
{
IList <FeatureRequestEvent> prereqEvents = new List <FeatureRequestEvent>();
EvalResult evalResult = new EvalResult(null, null, prereqEvents);
if (user == null || user.Key == null)
{
Log.WarnFormat("User or user key is null when evaluating flag: {0} returning null",
Key);
return(evalResult);
}
if (On)
{
evalResult = Evaluate(user, featureStore, prereqEvents, eventFactory);
if (evalResult.Result != null)
{
return(evalResult);
}
}
evalResult.Variation = OffVariation;
evalResult.Result = OffVariationValue;
return(evalResult);
}
/// <summary>
/// Preview the specified evaluation result.
/// </summary>
/// <param name="res">Res.</param>
public virtual async Task Preview(EvalResult res)
{
Log.Information($"Visualizing result {res.ResultType}");
var result = TypeActivator(res.ResultType);
Page page = result as Page;
if (page == null && result is View view)
{
page = new ContentPage {
Content = view
};
}
if (page != null)
{
if (viewModelsMapping.TryGetValue(res.ResultType, out object viewModel))
{
page.BindingContext = viewModel;
}
await EnsurePresented();
NavigationPage.SetHasNavigationBar(previewPage, true);
previewPage.ChangePage(page);
}
}
public async Task <bool> CreateTypeInstance(string typeName, EvalResult result)
{
EnsureConfigured();
try
{
using (var loader = new InteractiveAssemblyLoader())
{
var script = CSharpScript.Create($"new {typeName} ()", options, assemblyLoader: loader);
var state = await script.RunAsync();
result.Result = state.ReturnValue;
}
}
catch (CompilationErrorException ex)
{
Log.Exception(ex);
Log.Error($"Error evaluating new instance of {typeName}");
result.Messages = new EvalMessage[] { new EvalMessage {
MessageType = "error", Text = ex.ToString()
} };
}
catch (Exception ex)
{
Log.Exception(ex);
Log.Error($"Unhandled rrror creating new instance of {typeName}");
result.Messages = new EvalMessage[] { new EvalMessage {
MessageType = "error", Text = ex.ToString()
} };
}
return(false);
}
private bool shouldReach(Tile discardTile, EvalResult evalResult)
{
if (player.reached || player.fuuro.VisibleCount != 0 || evalResult.Distance > 0)
{
return(false);
}
bool changeRanking = false;
int rankingWithReach = 0;
int rankingWithoutReach = 0;
player.hand.Remove(discardTile);
player.graveyard.Add(discardTile);
EvalResult evalResultWithoutReach = eval13(1, false);
if (isAllLast())
{
rankingWithReach = expectedRankingWhenAgari(riichi: true);
rankingWithoutReach = expectedRankingWhenAgari(riichi: false);
changeRanking = rankingWithReach < rankingWithoutReach;
Trace.WriteLine(string.Format("Expected Ranking: w/ reach {0}, w/o reach {1}", rankingWithReach, rankingWithoutReach));
}
player.graveyard.Remove(discardTile);
player.hand.Add(discardTile);
return(gameData.remainingTile >= 4 && // 牌山还有枚数
(evalResultWithoutReach.E_Point < 3500 + evalResult.E_PromotionCount[0] * 500 || gameData.players.Count(p => p.reached) >= 2) && // 期望得点越小或听牌枚数越多，越应该立直 或 立直人数 >=2
!shouldDef(evalResult) && // 没有在防守状态
!(isAllLast() && !changeRanking && !(player.direction == Direction.E && rankingWithoutReach > 1) && evalResultWithoutReach.E_Point > 0) && // 如果All last且立直不改变顺位，除非是尾亲且和了也不是top，否则不立直
evalResult.E_PromotionCount[0] > 1 && // 没有空听或听枚数只剩1张的牌
evalResult.OptimizationCount < evalResult.E_PromotionCount[0] * 3); // 改良数量不是特别多
}
public static double EnergyJumpAtInterface(LevelSetTracker LsTrk, VectorField <XDGField> Velocity, XDGField Pressure, double muA, double muB, bool Norm, int momentFittingorder)
{
double EnergyJump = 0.0;
ScalarFunctionEx EnergyJumpFunc = GetEnergyJumpFunc(LsTrk, Velocity, Pressure, muA, muB, Norm);
var SchemeHelper = LsTrk.GetXDGSpaceMetrics(new[] { LsTrk.GetSpeciesId("A") }, momentFittingorder, 1).XQuadSchemeHelper;
CellQuadratureScheme cqs = SchemeHelper.GetLevelSetquadScheme(0, LsTrk.Regions.GetCutCellMask());
CellQuadrature.GetQuadrature(new int[] { 1 }, LsTrk.GridDat,
cqs.Compile(LsTrk.GridDat, momentFittingorder),
delegate(int i0, int Length, QuadRule QR, MultidimensionalArray EvalResult) {
EnergyJumpFunc(i0, Length, QR.Nodes, EvalResult.ExtractSubArrayShallow(-1, -1, 0));
},
delegate(int i0, int Length, MultidimensionalArray ResultsOfIntegration) {
for (int i = 0; i < Length; i++)
{
EnergyJump += ResultsOfIntegration[i, 0];
}
}
).Execute();
if (Norm)
{
EnergyJump.Sqrt();
}
return(EnergyJump);
}
private void check_null(EvalResult ea)
{
if (ea.Type == EvalResult.ResultType.Null)
{
throw new Exception("null not allowed in expression");
}
}
Tuple <UIViewController, bool> GetViewer(EvalResult resp)
{
var vc = resp.Result as UIViewController;
if (vc != null)
{
return(Tuple.Create(vc, true));
}
var sv = GetSpecialView(resp.Result);
vc = sv as UIViewController;
if (vc != null)
{
return(Tuple.Create(vc, false));
}
var v = sv as UIView;
if (v != null)
{
vc = new UIViewController();
vc.View = v;
return(Tuple.Create(vc, false));
}
vc = new ObjectInspector(resp.Result);
return(Tuple.Create(vc, true));
}
public static double CurvatureEnergy(LevelSetTracker LsTrk, SinglePhaseField Curvature, double sigma, ConventionalDGField[] uI, bool ExtVel, bool Norm, int momentFittingorder)
{
double EnergyCurv = 0.0;
var SchemeHelper = LsTrk.GetXDGSpaceMetrics(new[] { LsTrk.GetSpeciesId("A") }, momentFittingorder, 1).XQuadSchemeHelper;
CellQuadratureScheme cqs = SchemeHelper.GetLevelSetquadScheme(0, LsTrk.Regions.GetCutCellMask());
ScalarFunctionEx CurvEnergyFunc = GetCurvatureEnergyFunc(LsTrk, Curvature, sigma, uI, ExtVel, Norm);
CellQuadrature.GetQuadrature(new int[] { 1 }, LsTrk.GridDat,
cqs.Compile(LsTrk.GridDat, momentFittingorder),
delegate(int i0, int Length, QuadRule QR, MultidimensionalArray EvalResult) {
CurvEnergyFunc(i0, Length, QR.Nodes, EvalResult.ExtractSubArrayShallow(-1, -1, 0));
},
delegate(int i0, int Length, MultidimensionalArray ResultsOfIntegration) {
for (int i = 0; i < Length; i++)
{
EnergyCurv += ResultsOfIntegration[i, 0];
}
}
).Execute();
if (Norm)
{
EnergyCurv.Sqrt();
}
return(EnergyCurv);
}
private MultidimensionalArray EdgeQuadrature2CellBoundary(ICompositeQuadRule <QuadRule> surfRule)
{
int J = this.GridData.iLogicalCells.NoOfLocalUpdatedCells;
var ret = MultidimensionalArray.Create(J);
var E2C = this.GridData.iLogicalEdges.CellIndices;
BoSSS.Foundation.Quadrature.EdgeQuadrature.GetQuadrature(
new int[] { 1 }, this.GridData,
surfRule,
delegate(int i0, int Length, QuadRule Qr, MultidimensionalArray EvalResult) { // Evaluate
EvalResult.SetAll(1.0);
},
delegate(int i0, int Length, MultidimensionalArray ResultsOfIntegration) { // SaveIntegrationResults
for (int i = 0; i < Length; i++)
{
int iEdge = i0 + i;
int jCell0 = E2C[iEdge, 0];
int jCell1 = E2C[iEdge, 1];
ret[jCell0] += ResultsOfIntegration[i, 0];
if (jCell1 >= 0)
{
ret[jCell1] += ResultsOfIntegration[i, 0];
}
}
}).Execute();
return(ret);
}
public Task <bool> EvaluateCode(string code, EvalResult result)
{
if (string.IsNullOrEmpty(code))
{
return(Task.FromResult(false));
}
EnsureConfigured();
try
{
printer.Reset();
eval.Evaluate(code, out object retResult, out bool result_set);
result.Result = retResult;
return(Task.FromResult(true));
}
catch (Exception ex)
{
Log.Error($"Error evalutaing code");
eval = null;
if (printer.Messages.Count != 0)
{
result.Messages = printer.Messages.ToArray();
}
else
{
result.Messages = new[] { new EvalMessage("error", ex.ToString()) };
}
return(Task.FromResult(false));
}
}
async Task <EvalResult> EvalOnMainThread(EvalRequest code, CancellationToken token)
{
EvalResult evalResult = new EvalResult();
var sw = new System.Diagnostics.Stopwatch();
Log.Debug($"Evaluation request {code}");
sw.Start();
currentEvalRequest = code;
await evaluator.EvaluateExpression(code.NewTypeExpression,
code.NeedsRebuild?code.Declarations : null,
evalResult);
if (evalResult.Result != null)
{
LoadXAML(evalResult.Result, code.Xaml, evalResult);
}
sw.Stop();
Log.Debug($"Evaluation ended with result {evalResult.Result}");
evalResult.Duration = sw.Elapsed;
return(evalResult);
}
protected virtual Page CreateViewFromResult(EvalResult res)
{
Page page;
if (!res.HasResult)
{
res.Result = TypeActivator(res.ResultType);
}
if (res.Result is View view)
{
page = new ContentPage {
Content = view
};
}
else
{
page = res.Result as Page;
}
if (page != null)
{
if (viewModelsMapping.TryGetValue(res.ResultType, out object viewModel))
{
page.BindingContext = viewModel;
}
}
return(page);
}
public override Task Preview(EvalResult res)
{
State = PreviewState.Preview;
ErrorViewModel = null;
EvalResult = res;
return(base.Preview(res));
}
public EvalResult Eval(EvalRequest code, TaskScheduler mainScheduler, CancellationToken token)
{
var r = new EvalResult ();
Task.Factory.StartNew (() =>
{
r = EvalOnMainThread (code, token);
}, token, TaskCreationOptions.None, mainScheduler).Wait ();
return r;
}
partial void PlatformVisualize (EvalResult resp)
{
var val = resp.Result;
var ty = val != null ? val.GetType () : typeof(object);
Log ("{0} value = {1}", ty.FullName, val);
ShowViewer (GetViewer (resp));
}
partial void PlatformVisualize (EvalResult res)
{
var val = res.Result;
var ty = val != null ? val.GetType () : typeof(object);
Log ("{0} value = {1}", ty.FullName, val);
ShowViewerAsync (GetViewer (res.Result, true)).ContinueWith (t => {
if (t.IsFaulted) {
Log ("ShowViewer ERROR {0}", t.Exception);
}
});
}
public EvalResult Eval(EvalRequest code, TaskScheduler mainScheduler, CancellationToken token)
{
var t = Task.Factory.StartNew(() => {
var r = new EvalResult();
r.HasResult = true;
r.Result = new UILabel
{
BackgroundColor = UIColor.Red,
Text = "Hello at " + DateTime.Now,
};
return r;
}, token, TaskCreationOptions.None, mainScheduler);
return t.Result;
}
Tuple<UIViewController, bool> GetViewer (EvalResult resp)
{
var vc = resp.Result as UIViewController;
if (vc != null)
return Tuple.Create (vc, true);
var sv = GetSpecialView (resp.Result);
vc = sv as UIViewController;
if (vc != null)
return Tuple.Create (vc, false);
var v = sv as UIView;
if (v != null) {
vc = new UIViewController ();
vc.View = v;
return Tuple.Create (vc, false);
}
vc = new ObjectInspector (resp.Result);
return Tuple.Create (vc, true);
}
void Visualize (EvalResult res)
{
if (!res.HasResult) {
return;
}
try {
Console.WriteLine ("LiveCode.Visualize: {0}", res.Result);
// Analysis disable once EmptyGeneralCatchClause
} catch (Exception) {
}
visualizer.Visualize (res);
}
public void EndEval (EvalResult resultType, bool fSynchronousEval)
{
try
{
//This is used to avoid deadlock. Suspend commands synchronizes on this.Process
Process.SuspendCommands(true);
Debug.Assert(Utility.FImplies(fSynchronousEval, !m_fActive));
if (fSynchronousEval || m_fActive) //what to do if the eval isn't active anymore??
{
bool fKillThread = false;
if (m_threadVirtual != null)
{
if (m_threadReal.GetLastCorDebugThread() != m_threadVirtual)
throw new ArgumentException();
m_threadReal.RemoveVirtualThread(m_threadVirtual);
}
//Stack frames don't appear if they are not refreshed
if (fSynchronousEval)
{
for (CorDebugThread thread = this.m_threadReal; thread != null; thread = thread.NextThread)
{
thread.RefreshChain();
}
}
if(m_fException)
{
resultType = EvalResult.Exception;
}
//Check to see if we are able to EndEval -- is this the last virtual thread?
m_fActive = false;
m_resultType = resultType;
switch (resultType)
{
case EvalResult.Complete:
Process.EnqueueEvent(new ManagedCallbacks.ManagedCallbackEval(m_threadReal, this, ManagedCallbacks.ManagedCallbackEval.EventType.EvalComplete));
break;
case EvalResult.Exception:
Process.EnqueueEvent(new ManagedCallbacks.ManagedCallbackEval(m_threadReal, this, ManagedCallbacks.ManagedCallbackEval.EventType.EvalException));
break;
case EvalResult.Abort:
fKillThread = true;
/* WARNING!!!!
* If we do not give VS a EvalComplete message within 3 seconds of them calling ICorDebugEval::Abort then VS will attempt a RudeAbort
* and will display a scary error message about a serious internal debugger error and ignore all future debugging requests, among other bad things.
*/
Process.EnqueueEvent(new ManagedCallbacks.ManagedCallbackEval(m_threadReal, this, ManagedCallbacks.ManagedCallbackEval.EventType.EvalComplete));
break;
}
if (fKillThread && m_threadVirtual != null)
{
Engine.KillThread(m_threadVirtual.ID);
}
if (resultType == EvalResult.Abort)
{
Process.PauseExecution();
}
}
}
finally
{
Process.SuspendCommands(false);
}
}
object GetViewer (EvalResult resp)
{
return resp.Result;
}
void Visualize (EvalResult res)
{
if (!res.HasResult) {
return;
}
try {
Log ("Continuous.Visualize: {0}", res.Result);
// Analysis disable once EmptyGeneralCatchClause
} catch (Exception) {
}
visualizer.Visualize (res);
}
public override EvalResult Evaluate(MakeState s)
{
// Is it a register?
if(Program.regs.ContainsKey(val.ToUpper()))
{
var e = new EvalResult();
e.strval = val.ToUpper();
e.intval = Program.regs[e.strval];
e.Type = EvalResult.ResultType.Register;
return e;
}
string full_name = val;
// If defined in the current file, say so
if (s.lo.ContainsKey(val))
{
// Yes - emit a relocation to the label
Relocation r = new Relocation();
r.TargetName = val;
r.TargetSection = s.lo[val].Section;
r.Addend = addend;
r.SourceSection = s.cs;
r.IsPCRel = is_pcrel;
return new EvalResult(r);
}
else
{
// ld defines all unknown symbols as externals
Relocation r = new Relocation();
r.TargetName = val;
r.TargetSection = null;
r.Addend = addend;
r.SourceSection = s.cs;
r.IsPCRel = is_pcrel;
return new EvalResult(r);
}
/*if (s.IsDefined(val) == true)
return s.GetDefine(val);
{
// Not defined in the current section. Is it
// in another?
if (s.lo.ContainsKey(val))
{
// Yes - emit a relocation to the label
Relocation r = new Relocation();
r.TargetName = val;
r.TargetSection = s.lo[val].Section;
r.Addend = addend;
r.SourceSection = s.cs;
r.IsPCRel = is_pcrel;
return new EvalResult(r);
}
// ld defines all unknown symbols as externals
Relocation rext = new Relocation();
rext.TargetName = val;
rext.TargetSection = null;
rext.Addend = addend;
rext.SourceSection = s.cs;
rext.IsPCRel = is_pcrel;
return new EvalResult(rext);
}*/
}
private void EvalTest(string filename, int lineNo, string frameName, int frameIndex, PythonEvaluationResultReprKind reprKind, EvalResult eval) {
var debugger = new PythonDebugger();
PythonThread thread = null;
var process = DebugProcess(debugger, DebuggerTestPath + filename, (newproc, newthread) => {
var breakPoint = newproc.AddBreakPoint(filename, lineNo);
breakPoint.Add();
thread = newthread;
});
AutoResetEvent brkHit = new AutoResetEvent(false);
process.BreakpointHit += (sender, args) => {
brkHit.Set();
};
try {
process.Start();
AssertWaited(brkHit);
var frames = thread.Frames;
PythonEvaluationResult obj = null;
string errorMsg;
if (eval.IsError) {
Assert.IsFalse(frames[frameIndex].TryParseText(eval.Expression, out errorMsg), "should not have been able to parse expression");
Assert.AreEqual(eval.ExceptionText, errorMsg);
} else {
Assert.IsTrue(frames[frameIndex].TryParseText(eval.Expression, out errorMsg), "failed to parse expression");
Assert.IsNull(errorMsg);
Assert.AreEqual(frameName, frames[frameIndex].FunctionName);
var timeoutToken = new CancellationTokenSource(10000).Token;
obj = frames[frameIndex].ExecuteTextAsync(eval.Expression, reprKind)
.ContinueWith(t => t.Result, timeoutToken, TaskContinuationOptions.OnlyOnRanToCompletion, TaskScheduler.Current)
.GetAwaiter().GetResult();
eval.Validate(obj);
}
process.Continue();
WaitForExit(process);
process = null;
} finally {
if (process != null) {
process.Terminate();
WaitForExit(process, assert: false);
}
}
}
private void EvalTest(string filename, int lineNo, string frameName, int frameIndex, EvalResult eval) {
EvalTest(filename, lineNo, frameName, frameIndex, PythonEvaluationResultReprKind.Normal, eval);
}
async void HandleRequest (HttpListenerContext c)
{
try {
var path = c.Request.Url.AbsolutePath;
var resString = "";
Log ("REQ ON THREAD {0} {1}", Thread.CurrentThread.ManagedThreadId, path);
if (path == "/watchChanges") {
try {
var reqStr = await new StreamReader (c.Request.InputStream, Encoding.UTF8).ReadToEndAsync ().ConfigureAwait (false);
var req = JsonConvert.DeserializeObject<WatchChangesRequest> (reqStr);
resString = JsonConvert.SerializeObject (await GetWatchChangesAsync (req));
} catch (Exception ex) {
Log (ex, "/watchChanges");
}
} else if (path == "/stopVisualizing") {
try {
resString = await Task.Factory.StartNew (() => {
visualizer.StopVisualizing ();
return "";
}, CancellationToken.None, TaskCreationOptions.None, mainScheduler);
} catch (Exception ex) {
Log (ex, "/stopVisualizing");
}
}
else {
var reqStr = await new StreamReader (c.Request.InputStream, Encoding.UTF8).ReadToEndAsync ().ConfigureAwait (false);
// Log (reqStr);
var req = JsonConvert.DeserializeObject<EvalRequest> (reqStr);
var token = CancellationToken.None;
var resp = await Task.Factory.StartNew (() => {
WatchStore.Clear ();
var r = new EvalResult ();
try {
r = vm.Eval (req, mainScheduler, token);
}
catch (Exception ex) {
Log (ex, "vm.Eval");
}
try {
Task.Factory.StartNew (() =>
{
Visualize (r);
}, token, TaskCreationOptions.None, mainScheduler).Wait ();
}
catch (Exception ex) {
Log (ex, "Visualize");
}
var response = new EvalResponse {
Messages = r.Messages,
WatchValues = WatchStore.Values,
Duration = r.Duration,
};
return Tuple.Create (r, JsonConvert.SerializeObject (response));
}, token);
Log (resp.Item2);
resString = resp.Item2;
}
var bytes = Encoding.UTF8.GetBytes (resString);
c.Response.StatusCode = 200;
c.Response.ContentLength64 = bytes.LongLength;
await c.Response.OutputStream.WriteAsync (bytes, 0, bytes.Length).ConfigureAwait (false);
} catch (Exception ex) {
Log (ex, "HandleRequest");
c.Response.StatusCode = 500;
} finally {
c.Response.Close ();
}
}
partial void PlatformVisualize (EvalResult res);
public void Visualize (EvalResult res)
{
PlatformVisualize (res);
}
