Ejemplo n.º 1
0
        private void HandlePossibleConflict(ref OperatorData prevOpData,
                                            Operator <TTerm, TAfterString, TUserState> op,
                                            ref Reply <TTerm> reply,
                                            CharStream <TUserState> stream)
        {
            // "possible" conflict, because it's not a conflict when the
            // after-string-parser fails without changing the parser state.
            var state = stream.State;
            var ok    = stream.Skip(op.String);

            Debug.Assert(ok);
            var stateTag = stream.StateTag;
            var asReply  = op.AfterStringParser.Invoke(stream);

            if (asReply.Status == ReplyStatus.Ok)
            {
                stream.BacktrackTo(ref state);
                ReportConflict(ref prevOpData, op, asReply.Result, ref reply, stream);
            }
            else if (asReply.Status == ReplyStatus.Error && stateTag == stream.StateTag)
            {
                // backtrack and ignore the operator
                stream.BacktrackTo(ref state);
                reply.Error = ErrorMessageList.Merge(reply.Error, ExpectedInfixOrPostfixOperator);
            }
            else
            {
                // report AfterStringParser error instead of conflict
                reply.Error  = asReply.Error;
                reply.Status = asReply.Status;
            }
        }
Ejemplo n.º 2
0
        private string GetDebuggerDisplay()
        {
            if (Status == ReplyStatus.Ok)
            {
                string result;
                if (Result == null)
                {
                    result = typeof(TResult) == typeof(Microsoft.FSharp.Core.Unit) ? "()" : "null";
                }
                else if (typeof(TResult) == typeof(string))
                {
                    result = Text.DoubleQuote(Result.ToString());
                }
                else
                {
                    result = Result.ToString();
                }

                return(Error == null
                   ? "Reply(" + result + ")"
                   : "Reply(Ok, " + result + ", " + ErrorMessageList.GetDebuggerDisplay(Error) + ")");
            }
            else
            {
                var status = Status == ReplyStatus.Error ? "Error" :
                             Status == ReplyStatus.FatalError ? "FatalError" :
                             "(ReplyStatus)" + ((int)Status).ToString();

                return(Error == null
                   ? "Reply(" + status + ", NoErrorMessages)"
                   : "Reply(" + status + ", " + ErrorMessageList.GetDebuggerDisplay(Error) + ")");
            }
        }
Ejemplo n.º 3
0
 public CompoundError(string labelOfCompound,
                      Position nestedErrorPosition,
                      object nestedErrorUserState,
                      ErrorMessageList nestedErrorMessages) : base(ErrorMessageType.CompoundError)
 {
     String = labelOfCompound;
     NestedErrorPosition  = nestedErrorPosition;
     NestedErrorUserState = nestedErrorUserState;
     NestedErrorMessages  = nestedErrorMessages;
 }
Ejemplo n.º 4
0
        private bool Remove(OperatorType operatorType, string opString)
        {
            var ops = operatorType == OperatorType.Prefix ? LhsOps : RhsOps;
            int i, j;

            if (!FindPosition(ops, opString, out i, out j))
            {
                return(false);
            }
            var array = ops[i];
            var n     = array.Length;

            if (n == 1)
            {
                ops[i] = null;
            }
            else
            {
                var newArray = new Operator <TTerm, TAfterString, TUserState> [n - 1];
                if (j != 0)
                {
                    Array.Copy(array, 0, newArray, 0, j);
                }
                if (j + 1 != n)
                {
                    Array.Copy(array, j + 1, newArray, j, n - j - 1);
                }
                ops[i] = newArray;
            }
            if (operatorType == OperatorType.Infix)
            {
                --InfixOpCount;
                if (InfixOpCount == 0)
                {
                    ExpectedInfixOrPostfixOperator = PostfixOpCount == 0 ? null : Errors.ExpectedPostfixOperator;
                }
            }
            else if (operatorType == OperatorType.Postfix)
            {
                --PostfixOpCount;
                if (PostfixOpCount == 0)
                {
                    ExpectedInfixOrPostfixOperator = InfixOpCount == 0 ? null : Errors.ExpectedInfixOperator;
                }
            }
            else
            {
                --PrefixOpCount;
            }
            return(true);
        }
Ejemplo n.º 5
0
        private void HandleMissingTernary2ndStringError(ref OperatorData opData,
                                                        ref Reply <TTerm> reply,
                                                        CharStream <TUserState> stream)
        {
            var firstStringIndex  = opData.IndexToken.GetIndex(stream);
            var firstStringColumn = firstStringIndex - opData.LineBegin + 1;
            var firstStringPos    = new Position(stream.Name, firstStringIndex, opData.Line, firstStringColumn);
            var secondStringPos   = stream.Position;
            var error1            = ExpectedInfixOrPostfixOperator;
            var error2            = MissingTernary2ndStringErrorFormatter.Invoke(Tuple.Create(firstStringPos, secondStringPos, (TernaryOperator <TTerm, TAfterString, TUserState>)opData.Operator, opData.AfterStringValue));

            reply.Error  = ErrorMessageList.Merge(reply.Error, ErrorMessageList.Merge(error1, error2));
            reply.Status = ReplyStatus.Error;
        }
Ejemplo n.º 6
0
        private void ReportConflict(ref OperatorData prevOpData,
                                    Operator <TTerm, TAfterString, TUserState> op,
                                    TAfterString afterStringValue,
                                    ref Reply <TTerm> reply,
                                    CharStream <TUserState> stream)
        {
            var prevOpIndex  = prevOpData.IndexToken.GetIndex(stream);
            var prevOpColumn = prevOpIndex - prevOpData.LineBegin + 1;
            var prevOpPos    = new Position(stream.Name, prevOpIndex, prevOpData.Line, prevOpColumn);
            var error        = _OperatorConflictErrorFormatter.Invoke(
                Tuple.Create(prevOpPos, prevOpData.Operator, prevOpData.AfterStringValue),
                Tuple.Create(stream.Position, op, afterStringValue));

            reply.Error  = ErrorMessageList.Merge(reply.Error, error);
            reply.Status = ReplyStatus.Error;
        }
Ejemplo n.º 7
0
        public override Reply <TResult> Invoke(CharStream <TUserState> stream)
        {
            var tag    = stream.StateTag;
            var eReply = EndParser.Invoke(stream);

            if (eReply.Status == ReplyStatus.Error && tag == stream.StateTag)
            {
                var reply = CharParser1.Invoke(stream);
                if (reply.Status == ReplyStatus.Ok)
                {
                    return(ParseRestOfString(stream, reply.Result, reply.Error));
                }
                else
                {
                    var error = tag == stream.StateTag
                            ? ErrorMessageList.Merge(eReply.Error, reply.Error)
                            : reply.Error;
                    return(new Reply <TResult> {
                        Status = reply.Status, Error = error
                    });
                }
            }
            else if (eReply.Status == ReplyStatus.Ok)
            {
                var result = Mapping.Invoke("", eReply.Result);
                return(new Reply <TResult> {
                    Status = ReplyStatus.Ok, Result = result, Error = eReply.Error
                });
            }
            else
            {
                return(new Reply <TResult> {
                    Status = eReply.Status, Error = eReply.Error
                });
            }
        }
Ejemplo n.º 8
0
        ParseExpression(ref OperatorData prevOpData, // prevOpData is passed as ref for performance reasons, but is not mutated
                        ref Reply <TTerm> reply,
                        CharStream <TUserState> stream)
        {
            Operator <TTerm, TAfterString, TUserState> op;

            if (PrefixOpCount != 0 && ((op = PeekOp(stream, LhsOps)) != null))
            {
                op = ParsePrefixOp(ref prevOpData, op, ref reply, stream);
                // ParsePrefixOp returns ErrorOp when it backtracks and we should try to parse a term
                if (op == null)
                {
                    goto Break;
                }
                if (op != ErrorOp)
                {
                    goto CheckNextOp;
                }
            }
            var error    = reply.Error;
            var stateTag = stream.StateTag;

            reply = TermParser.Invoke(stream); // <-- this is where we parse the terms
            if (stateTag == stream.StateTag)
            {
                error = ErrorMessageList.Merge(error, reply.Error);
                if (PrefixOpCount != 0)
                {
                    error = ErrorMessageList.Merge(error, Errors.ExpectedPrefixOperator);
                }
                reply.Error = error;
            }
            if (reply.Status != ReplyStatus.Ok)
            {
                goto ReturnNull;
            }
            op = PeekOp(stream, RhsOps);
CheckNextOp:
            if (op != null)
            {
                var prevOp = prevOpData.Operator;
                if (prevOp.Precedence > op.Precedence)
                {
                    goto Break;
                }
                if (prevOp.Precedence < op.Precedence)
                {
                    goto Continue;
                }
                // prevOp.Precedence == op.Precedence
                if (op.Type == OperatorType.Infix)
                {
                    var assoc = prevOp.Associativity & op.Associativity;
                    if (assoc == Associativity.Left || prevOp.Type == OperatorType.Prefix)
                    {
                        goto Break;
                    }
                    if (assoc == Associativity.Right)
                    {
                        goto Continue;
                    }
                }
                else
                {
                    if (prevOp.Type == OperatorType.Infix)
                    {
                        goto Continue;
                    }
                    Debug.Assert(prevOp.Type == OperatorType.Prefix && op.Type == OperatorType.Postfix);
                    if ((prevOp.Associativity | op.Associativity) != Associativity.None)
                    {
                        goto Break;
                    }
                }
                HandlePossibleConflict(ref prevOpData, op, ref reply, stream);
            }
            else
            {
                error       = ErrorMessageList.Merge(reply.Error, ExpectedInfixOrPostfixOperator);
                reply.Error = error;
            }
ReturnNull:
            op = null;
Break:
            return(op);

Continue:
            return(ParseExpressionContinue(ref prevOpData, op, ref reply, stream));
        }
Ejemplo n.º 9
0
        public void AddOperator(Operator <TTerm, TAfterString, TUserState> op)
        {
            Operator <TTerm, TAfterString, TUserState> oldOp;

            if (Reserved.TryGetValue(op.String, out oldOp) ||
                (op.IsTernary && Reserved.TryGetValue(op.TernaryRightString, out oldOp)))
            {
                ThrowDefinitionConflictException(op, oldOp);
            }
            var ops = op.Type == OperatorType.Prefix ? LhsOps : RhsOps;
            int i, j;

            if (FindPosition(ops, op.String, out i, out j))
            {
                ThrowDefinitionConflictException(op, ops[i][j]);
            }
            if (op.IsTernary)
            {
                int i2, j2;
                // make sure the Ternary2ndString isn't registered as an operator
                if (FindPosition(LhsOps, op.TernaryRightString, out i2, out j2))
                {
                    ThrowDefinitionConflictException(op, LhsOps[i2][j2]);
                }
                if (FindPosition(RhsOps, op.TernaryRightString, out i2, out j2))
                {
                    ThrowDefinitionConflictException(op, RhsOps[i2][j2]);
                }
                Reserved.Add(op.TernaryRightString, op);
            }
            var array = ops[i];

            if (array == null)
            {
                ops[i] = new Operator <TTerm, TAfterString, TUserState>[1] {
                    op
                };
            }
            else
            {
                int n        = array.Length;
                var newArray = new Operator <TTerm, TAfterString, TUserState> [n + 1];
                if (j != 0)
                {
                    Array.Copy(array, 0, newArray, 0, j);
                }
                newArray[j] = op;
                if (j != n)
                {
                    Array.Copy(array, j, newArray, j + 1, n - j);
                }
                ops[i] = newArray;
            }
            if (op.Type == OperatorType.Infix)
            {
                ++InfixOpCount;
                if (InfixOpCount == 1)
                {
                    ExpectedInfixOrPostfixOperator = PostfixOpCount == 0
                                                 ? Errors.ExpectedInfixOperator
                                                 : Errors.ExpectedInfixOrPostfixOperator;
                }
            }
            else if (op.Type == OperatorType.Postfix)
            {
                ++PostfixOpCount;
                if (PostfixOpCount == 1)
                {
                    ExpectedInfixOrPostfixOperator = InfixOpCount == 0
                                                 ? Errors.ExpectedPostfixOperator
                                                 : Errors.ExpectedInfixOrPostfixOperator;
                }
            }
            else
            {
                ++PrefixOpCount;
            }
        }
Ejemplo n.º 10
0
 public Reply(ReplyStatus status, ErrorMessageList error)
 {
     Status = status;
     Error  = error;
     Result = default(TResult);
 }
Ejemplo n.º 11
0
        internal string GetDebuggerDisplay()
        {
            switch (Type)
            {
            case ErrorMessageType.Expected:
                return(String == null
                       ? "Expected(null)"
                       : Text.DoubleQuote("Expected(", String, ")"));

            case ErrorMessageType.ExpectedString:
                return(String == null
                       ? "ExpectedString(null)"
                       : Text.DoubleQuote("ExpectedString(", String, ")"));

            case ErrorMessageType.ExpectedCaseInsensitiveString:
                return(String == null
                       ? "ExpectedCaseInsensitiveString(null)"
                       : Text.DoubleQuote("ExpectedCaseInsensitiveString(", String, ")"));

            case ErrorMessageType.Unexpected:
                return(String == null
                       ? "Unexpected(null)"
                       : Text.DoubleQuote("Unexpected(", String, ")"));

            case ErrorMessageType.UnexpectedString:
                return(String == null
                       ? "UnexpectedString(null)"
                       : Text.DoubleQuote("UnexpectedString(", String, ")"));

            case ErrorMessageType.UnexpectedCaseInsensitiveString:
                return(String == null
                       ? "UnexpectedCaseInsensitiveString(null)"
                       : Text.DoubleQuote("UnexpectedCaseInsensitiveString(", String, ")"));

            case ErrorMessageType.Message:
                return(String == null
                       ? "Message(null)"
                       : Text.DoubleQuote("Message(", String, ")"));

            case ErrorMessageType.NestedError: {
                var ne   = (NestedError)this;
                var pos  = ne.Position == null ? "null" : ne.Position.ToString();
                var msgs = ErrorMessageList.GetDebuggerDisplay(ne.Messages);
                return("NestedError(" + pos + ", ..., " + msgs + ")");
            }

            case ErrorMessageType.CompoundError: {
                var ce    = (CompoundError)this;
                var label = ce.String == null ? "null" : Text.Escape(ce.String, "", "\"", "\"", "", '"');
                var pos   = ce.NestedErrorPosition == null ? "" : ce.NestedErrorPosition.ToString();
                var msgs  = ErrorMessageList.GetDebuggerDisplay(ce.NestedErrorMessages);
                return("CompoundError(" + label + ", " + pos + ", ..., " + msgs + ")");
            }

            case ErrorMessageType.Other: {
                var oe = (Other)this;
                return(oe.Data == null ? "Other(null)" : "Other(" + oe.ToString() + ")");
            }

            default:
                throw new InvalidOperationException();
            }
        }
Ejemplo n.º 12
0
            public override int Compare(ErrorMessage x, ErrorMessage y)
            {
                if (x == null || y == null)
                {
                    return(x == null && y == null ? 0 : (x == null ? -1 : 1));
                }
                int d = (int)x.Type - (int)y.Type;

                if (d != 0)
                {
                    return(d);
                }
                var type = x.Type;

                if (type <= ErrorMessageType.Message)
                {
                    Debug.Assert(type >= 0);
                    return(String.CompareOrdinal(x.String, y.String));
                }
                else if (type == ErrorMessageType.NestedError)
                {
                    var ne1 = (NestedError)x;
                    var ne2 = (NestedError)y;
                    var c   = Position.Compare(ne1.Position, ne2.Position);
                    if (c != 0)
                    {
                        return(c);
                    }
                    var msgs1 = ErrorMessageList.ToSortedArray(ne1.Messages);
                    var msgs2 = ErrorMessageList.ToSortedArray(ne2.Messages);
                    int n     = Math.Min(msgs1.Length, msgs2.Length);
                    for (int i = 0; i < n; ++i)
                    {
                        c = Compare(msgs1[i], msgs2[i]);
                        if (c != 0)
                        {
                            return(c);
                        }
                    }
                    return(msgs1.Length - msgs2.Length);
                }
                else if (type == ErrorMessageType.CompoundError)
                {
                    var c = String.CompareOrdinal(x.String, y.String);
                    if (c != 0)
                    {
                        return(c);
                    }
                    var ce1 = (CompoundError)x;
                    var ce2 = (CompoundError)y;
                    c = Position.Compare(ce1.NestedErrorPosition, ce2.NestedErrorPosition);
                    if (c != 0)
                    {
                        return(c);
                    }
                    var msgs1 = ErrorMessageList.ToSortedArray(ce1.NestedErrorMessages);
                    var msgs2 = ErrorMessageList.ToSortedArray(ce2.NestedErrorMessages);
                    int n     = Math.Min(msgs1.Length, msgs2.Length);
                    for (int i = 0; i < n; ++i)
                    {
                        c = Compare(msgs1[i], msgs2[i]);
                        if (c != 0)
                        {
                            return(c);
                        }
                    }
                    return(msgs1.Length - msgs2.Length);
                }
                else
                {
                    Debug.Assert(type == ErrorMessageType.Other);
                    return(0);
                }
            }
Ejemplo n.º 13
0
 public NestedError(Position position, object userState, ErrorMessageList messages) : base(ErrorMessageType.NestedError)
 {
     Position  = position;
     UserState = userState;
     Messages  = messages;
 }
Ejemplo n.º 14
0
 public Reply(ReplyStatus status, TResult result, ErrorMessageList error)
 {
     Status = status;
     Error  = error;
     Result = result;
 }
Ejemplo n.º 15
0
        ParseExpressionContinue(ref OperatorData prevOpData,
                                Operator <TTerm, TAfterString, TUserState> op,
                                ref Reply <TTerm> reply,
                                CharStream <TUserState> stream)
        {
            var opData = new OperatorData();

            for (;;)
            {
                opData.Line       = stream.Line;
                opData.LineBegin  = stream.LineBegin;
                opData.IndexToken = stream.IndexToken;
                opData.Operator   = op;
        #if DEBUG
                var ok = stream.Skip(op.String);
                Debug.Assert(ok);
        #else
                stream.Skip((uint)op.String.Length);
        #endif
                var stateTag = stream.StateTag;
                var asReply  = op.AfterStringParser.Invoke(stream);
                if (asReply.Status == ReplyStatus.Ok)
                {
                    opData.AfterStringValue = asReply.Result;
                    reply.Error             = asReply.Error;
                    if (op.Type == OperatorType.Infix)
                    {
                        var result1 = reply.Result;
                        if (!op.IsTernary)
                        {
                            var nextOp = ParseExpression(ref opData, ref reply, stream);
                            if (reply.Status == ReplyStatus.Ok)
                            {
                                reply.Result = op.Mapping2.Invoke(opData.AfterStringValue, result1, reply.Result);
                            }
                            op = nextOp;
                            if (op == null)
                            {
                                break;
                            }
                            goto CheckNextOp;
                        }
                        else
                        {
                            ParseExpression(ref ZeroPrecedenceOperatorData, ref reply, stream);
                            if (reply.Status != ReplyStatus.Ok)
                            {
                                goto ReturnNull;
                            }
                            var result2 = reply.Result;
                            if (stream.Skip(op.TernaryRightString))
                            {
                                stateTag = stream.StateTag;
                                asReply  = op.AfterTernaryRightStringParser.Invoke(stream);
                                if (asReply.Status == ReplyStatus.Ok)
                                {
                                    reply.Error = asReply.Error;
                                    var nextOp = ParseExpression(ref opData, ref reply, stream);
                                    if (reply.Status == ReplyStatus.Ok)
                                    {
                                        reply.Result = op.Mapping3.Invoke(opData.AfterStringValue, asReply.Result, result1, result2, reply.Result);
                                    }
                                    op = nextOp;
                                    if (op == null)
                                    {
                                        break;
                                    }
                                    goto CheckNextOp;
                                }
                                else if (asReply.Status != ReplyStatus.Error || stateTag != stream.StateTag)
                                {
                                    reply.Error  = asReply.Error;
                                    reply.Status = asReply.Status;
                                    goto ReturnNull;
                                }
                                else
                                {
                                    // backtrack
                                    stream.Skip(-op.TernaryRightString.Length);
                                    stream.StateTag -= 2;
                                }
                            }
                            HandleMissingTernary2ndStringError(ref opData, ref reply, stream);
                            goto ReturnNull;
                        }
                    }
                    else
                    {
                        Debug.Assert(op.Type == OperatorType.Postfix);
                        reply.Result = op.Mapping1.Invoke(opData.AfterStringValue, reply.Result);
                        var lastOp = op;
                        op = PeekOp(stream, RhsOps);
                        // we check for adjacent postfix operators here ...
                        if (op != null)
                        {
                            if (op.Type == OperatorType.Postfix && lastOp.Precedence <= op.Precedence)
                            {
                                if (lastOp.Precedence < op.Precedence ||
                                    (lastOp.Associativity | op.Associativity) != Associativity.None)
                                {
                                    continue;
                                }
                                // ... so we can report conflicting postfix operators
                                HandlePossibleConflict(ref opData, op, ref reply, stream);
                                goto ReturnNull;
                            }
                        }
                        else
                        {
                            reply.Error = ErrorMessageList.Merge(reply.Error, ExpectedInfixOrPostfixOperator);
                            break;
                        }
                    }
CheckNextOp:
                    var prevOp = prevOpData.Operator;
                    if (prevOp.Precedence < op.Precedence)
                    {
                        continue;
                    }
                    if (prevOp.Precedence > op.Precedence)
                    {
                        break;
                    }
                    // prevOp.Precedence == op.Precedence
                    if (op.Type == OperatorType.Infix)
                    {
                        var assoc = prevOp.Associativity & op.Associativity;
                        if (assoc == Associativity.Left || prevOp.Type == OperatorType.Prefix)
                        {
                            break;
                        }
                        if (assoc == Associativity.Right)
                        {
                            continue;
                        }
                    }
                    else // op.OperatorType == OperatorType.Postfix
                    {
                        if (prevOp.Type == OperatorType.Infix)
                        {
                            continue;
                        }
                        Debug.Assert(prevOp.Type == OperatorType.Prefix);
                        if ((prevOp.Associativity | op.Associativity) != Associativity.None)
                        {
                            break;
                        }
                    }
                    HandlePossibleConflict(ref prevOpData, op, ref reply, stream);
                }
                else // asReply.Status != ReplyStatus.Ok
                {
                    if (asReply.Status == ReplyStatus.Error && stateTag == stream.StateTag)
                    {
                        // backtrack
                        stream.Seek(opData.IndexToken);
                        stream.StateTag -= 2;
                        reply.Error      = ErrorMessageList.Merge(reply.Error, ExpectedInfixOrPostfixOperator);
                    }
                    else
                    {
                        reply.Error  = asReply.Error;
                        reply.Status = asReply.Status;
                    }
                }
ReturnNull:
                op = null;
                break;
            }
            return(op);
        }
Ejemplo n.º 16
0
     protected Reply <string> ParseRestOfString(CharStream <TUserState> stream, char firstChar, ErrorMessageList error)
     {
 #if LOW_TRUST
         var sb = new StringBuilder(16);
         sb.Append(firstChar);
 #else
         _16CharBuffer buffer_; // produces more efficient code on .NET than stackalloc char[16]
         char *        buffer = (char *)(&buffer_);
         buffer[0] = firstChar;
         char[] chars = null;
         uint   n     = 1;
 #endif
         for (;;)
         {
             var tag   = stream.StateTag;
             var reply = CharParser.Invoke(stream);
             if (reply.Status == ReplyStatus.Ok)
             {
                 if (tag == stream.StateTag)
                 {
                     throw Internal.ParserCombinatorInInfiniteLoopHelper.CreateException("manyChars", stream);
                 }
                 error = reply.Error;
         #if LOW_TRUST
                 sb.Append(reply.Result);
         #else
                 var i = n % 16;
                 if (i != 0)
                 {
                     buffer[i] = reply.Result;
                     ++n;
                 }
                 else
                 {
                     if (chars == null)
                     {
                         chars = new char[32];
                     }
                     else if (n == chars.Length)
                     {
                         var newChars = new char[2 * chars.Length];
                         Array.Copy(chars, newChars, chars.Length);
                         chars = newChars;
                     }
                     for (i = 0; i < 16; ++i)
                     {
                         chars[n - 16 + i] = buffer[i];
                     }
                     buffer[0] = reply.Result;
                     ++n;
                 }
         #endif
             }
             else if (reply.Status == ReplyStatus.Error && tag == stream.StateTag)
             {
                 string str;
         #if LOW_TRUST
                 str = sb.ToString();
         #else
                 if (n <= 16)
                 {
                     str = new String(buffer, 0, (int)n);
                 }
                 else
                 {
                     for (uint i = (n - 1) & 0x7ffffff0u; i < n; ++i)
                     {
                         chars[i] = buffer[i % 16];
                     }
                     str = new string(chars, 0, (int)n);
                 }
         #endif
                 error = ErrorMessageList.Merge(error, reply.Error);
                 return(new Reply <string> {
                     Status = ReplyStatus.Ok, Result = str, Error = error
                 });
             }
             else
             {
                 error = tag == stream.StateTag ? ErrorMessageList.Merge(error, reply.Error) : reply.Error;
                 return(new Reply <string> {
                     Status = reply.Status, Error = error
                 });
             }
         }
     }
Ejemplo n.º 17
0
 public DebugView(ErrorMessageList list)
 {
     List = list;
 }
Ejemplo n.º 18
0
 public Reply(TResult result)
 {
     Result = result;
     Error  = null;
     Status = ReplyStatus.Ok;
 }