/// <summary>Native method representing the match method</summary> /// <param name="ctx">Current interpreter</param> /// <param name="req">Request that obtained this method</param> public GraceObject Match(EvaluationContext ctx, MethodRequest req) { MethodHelper.CheckArity(ctx, req, 1); var target = req[0].Arguments[0]; if (Pattern == null) { var rrr = this.Apply(ctx, MethodRequest.Single("apply(_)", target)); return(Matching.SuccessfulMatch(ctx, rrr)); } var matchResult = Matching.Match(ctx, Pattern, target); if (!Matching.Succeeded(ctx, matchResult)) { return(Matching.FailedMatch(ctx, target)); } var result = matchResult.Request(ctx, MethodRequest.Nullary("result")); if (!explicitPattern) { var res = this.Apply(ctx, MethodRequest.Single("apply(_)", result)); return(Matching.SuccessfulMatch(ctx, res)); } var res2 = this.Apply(ctx, MethodRequest.Single("apply(_)", result)); return(Matching.SuccessfulMatch(ctx, res2)); }
private GraceObject mIfTrueIfFalse(EvaluationContext ctx, MethodRequest req) { if (Success) { return(req[0].Arguments[0].Request(ctx, MethodRequest.Nullary("apply"))); } return(req[1].Arguments[0].Request(ctx, MethodRequest.Nullary("apply"))); }
private GraceObject mIfFalse(EvaluationContext ctx, GraceObject b) { if (!Success) { return(b.Request(ctx, MethodRequest.Nullary("apply"))); } return(GraceObject.Done); }
/// <summary>Native method for Grace refine</summary> /// <param name="ctx">Current interpreter</param> /// <param name="name">Name of the sub-exception</param> public GraceObject Refine(EvaluationContext ctx, GraceObject name) { var asGraceString = name.Request(ctx, MethodRequest.Nullary("asString")) .FindNativeParent <GraceString>(); var nameStr = asGraceString.Value; AddDescendant(nameStr); return(new GraceExceptionKind(this, nameStr)); }
private void start() { var apply = MethodRequest.Nullary("apply"); try { block.Request(interpreter, apply); } catch (GraceExceptionPacketException gepe) { exception = gepe.ExceptionPacket; ErrorReporting.WriteException(exception); } }
/// <summary>Native method for Grace raise</summary> /// <param name="ctx">Current interpreter</param> /// <param name="message">Message string</param> public GraceObject Raise(EvaluationContext ctx, GraceObject message) { var msg = "<<No message>>"; var asGraceString = message.Request(ctx, MethodRequest.Nullary("asString")) .FindNativeParent <GraceString>(); if (asGraceString != null) { msg = asGraceString.Value; } GraceExceptionPacket.Throw(this, msg, ctx.GetStackTrace()); return(GraceObject.Done); }
/// <summary> /// Convert any GraceObject into a CLI string. /// </summary> /// <param name="ctx">Interpreter to call asString under</param> /// <param name="o">Object to convert</param> public static string AsNativeString(EvaluationContext ctx, GraceObject o) { var s = o as GraceString; if (s != null) { return(s.Value); } s = o.Request(ctx, MethodRequest.Nullary("asString")) as GraceString; if (s != null) { return(s.Value); } return("not a string, nor stringifiable"); }
private static GraceObject mConcatenate(EvaluationContext ctx, GraceString self, GraceObject other) { var oth = other.FindNativeParent <GraceString>(); if (oth != null) { return(GraceString.Create(self.Value + oth.Value)); } var op = other as GraceObjectProxy; if (op != null) { return(GraceString.Create(self.Value + op.Object)); } other = other.Request(ctx, MethodRequest.Nullary("asString")); oth = other.FindNativeParent <GraceString>(); return(GraceString.Create(self.Value + oth.Value)); }
/// <summary>Native method for Grace ifTrue ifFalse</summary> /// <param name="ctx">Current interpreter</param> /// <param name="req">Method request that gave rise to this method /// execution</param> public GraceObject IfTrueIfFalse(EvaluationContext ctx, MethodRequest req) { MethodHelper.CheckArity(ctx, req, 1, 1); var trueBlock = req[0].Arguments[0]; var falseBlock = req[1].Arguments[0]; if (!(trueBlock is GraceBlock)) { ErrorReporting.RaiseError(ctx, "R2001", new Dictionary <string, string>() { { "method", req.Name }, { "index", "1" }, { "part", "ifTrue" }, { "required", "Block" } }, "ArgumentTypeError: ifTrue ifFalse requires two block arguments" ); } if (!(falseBlock is GraceBlock)) { ErrorReporting.RaiseError(ctx, "R2001", new Dictionary <string, string>() { { "method", req.Name }, { "index", "1" }, { "part", "ifFalse" }, { "required", "Block" } }, "ArgumentTypeError: ifTrue ifFalse requires two block arguments" ); } var apply = MethodRequest.Nullary("apply"); if (Boolean) { return(trueBlock.Request(ctx, apply)); } return(falseBlock.Request(ctx, apply)); }
/// <summary>Native method for Grace orElse</summary> /// <param name="ctx">Current interpreter</param> /// <param name="other">Block to apply if false</param> public GraceObject OrElse(EvaluationContext ctx, GraceObject other) { var oth = other as GraceBlock; if (oth == null) { ErrorReporting.RaiseError(ctx, "R2001", new Dictionary <string, string>() { { "method", "orElse" }, { "index", "1" }, { "part", "ifFalse" }, { "required", "Block" } }, "ArgumentTypeError: orElse requires a block argument" ); } if (!Boolean) { var req = MethodRequest.Nullary("apply"); return(other.Request(ctx, req)); } return(True); }
/// <summary>Determine whether MatchResult failed</summary> /// <param name="ctx">Current interpreter</param> /// <param name="matchResult">MatchResult to examine</param> public static bool Failed(EvaluationContext ctx, GraceObject matchResult) { return(GraceBoolean.False == matchResult.Request(ctx, MethodRequest.Nullary("succeeded"))); }
/// <summary>Get the result of a MatchResult</summary> /// <param name="ctx">Current interpreter</param> /// <param name="matchResult">MatchResult to examine</param> public static GraceObject GetResult(EvaluationContext ctx, GraceObject matchResult) { return(matchResult.Request(ctx, MethodRequest.Nullary("result"))); }