public StoryboardParserTests() { blockFactory = new FakeBlockFactory(); dismissNodes = new(); parsingContext = A.Fake<IParsingContext>(i => i.Strict()); A.CallTo(() => parsingContext.RegisterDismissNode(A<INode>.Ignored)) .Invokes(i => dismissNodes.Add(i.Arguments.Get<INode>(0))); A.CallTo(() => parsingContext.BlockFactory).Returns(blockFactory); rootBlockParser = A.Fake<IRootBlockParser>(i => i.Strict()); sceneNavigator = A.Fake<ISceneNavigator>(i => i.Strict()); eventManager = A.Fake<IEventManager>(i => i.Strict()); randomizer = A.Fake<IRandomizer>(i => i.Strict()); navigationState = A.Fake<INavigationState>(i => i.Strict()); variableDictionary = A.Fake<IVariableDictionary>(i => i.Strict()); blockState = A.Fake<IBlockState>(i => i.Strict()); var serviceProvider = A.Fake<IServiceProvider>(i => i.Strict()); A.CallTo(() => serviceProvider.GetService(typeof(IParsingContext))).Returns(parsingContext); A.CallTo(() => serviceProvider.GetService(typeof(IRootBlockParser))).Returns(rootBlockParser); A.CallTo(() => serviceProvider.GetService(typeof(ISceneNavigator))).Returns(sceneNavigator); A.CallTo(() => serviceProvider.GetService(typeof(IEventManager))).Returns(eventManager); A.CallTo(() => serviceProvider.GetService(typeof(IRandomizer))).Returns(randomizer); A.CallTo(() => serviceProvider.GetService(typeof(INavigationState))).Returns(navigationState); A.CallTo(() => serviceProvider.GetService(typeof(IVariableDictionary))).Returns(variableDictionary); A.CallTo(() => serviceProvider.GetService(typeof(IBlockState))).Returns(blockState); sut = new StoryboardParser(serviceProvider); }
public async Task ParseAsync(XmlReader reader, IParsingContext parsingContext, IParentParsingContext parentParsingContext) { var myContext = new TextParentParsingContext(); await elementParser.ParseAsync(reader, parsingContext, myContext, Settings); var parsedText = myContext.ParsedText; parsingContext.SceneContext.Reset(); if (string.IsNullOrWhiteSpace(parsedText)) { var node = new PauseNode(myContext.When); parentParsingContext.AddNode(node); return; } var value = int.Parse(parsedText); if (value <= 0) { parsingContext.LogError(reader, "O tempo de espera precisa ser maior que zero."); return; } if (value > 5000) { parsingContext.LogError(reader, "O tempo de espera não pode ser maior que 5000."); return; } var timedPauseNode = new TimedPauseNode(TimeSpan.FromMilliseconds(value), myContext.When); parentParsingContext.AddNode(timedPauseNode); }
internal ArrayInfo(IParsingContext context) { ObjectId = context.ReadInt32(); Length = context.ReadInt32(); Check.That(Length >= 0, "Expected Length >=0, got " + Length); }
public RootBlockParserTests() { reader = A.Dummy <XmlReader>(); context = A.Fake <IParsingContext>(i => i.Strict()); elementParser = A.Fake <IElementParser>(i => i.Strict()); backgroundNodeParser = Helper.FakeParser <IBackgroundNodeParser>("background"); blockNodeParser = Helper.FakeParser <IBlockNodeParser>("do"); pauseNodeParser = Helper.FakeParser <IPauseNodeParser>("pause"); musicNodeParser = Helper.FakeParser <IMusicNodeParser>("music"); protagonistNodeParser = Helper.FakeParser <IProtagonistNodeParser>("protagonist"); personNodeParser = Helper.FakeParser <IPersonNodeParser>("person"); narrationNodeParser = Helper.FakeParser <INarrationNodeParser>("narration"); tutorialNodeParser = Helper.FakeParser <ITutorialNodeParser>("tutorial"); setNodeParser = Helper.FakeParser <ISetNodeParser>("set"); unsetNodeParser = Helper.FakeParser <IUnsetNodeParser>("unset"); sut = new( elementParser, musicNodeParser, backgroundNodeParser, blockNodeParser, pauseNodeParser, protagonistNodeParser, personNodeParser, narrationNodeParser, tutorialNodeParser, setNodeParser, unsetNodeParser ); }
public MethodDefinition(IParsingContext[] parsingContext, string name, TypeReference declaringType) { mParsingContext = parsingContext; Parameters = new List<ParameterDefinition>(); mName = name; mDeclaringType = declaringType; }
public async Task ParseAsync(XmlReader reader, IParsingContext parsingContext, IParentParsingContext parentParsingContext) { var myContext = new BalloonChildParsingContext(); await elementParser.ParseAsync(reader, parsingContext, myContext, Settings); if (myContext.ParsedText is null) { return; } var textSourceParsingResult = textSourceParser.Parse(myContext.ParsedText); if (textSourceParsingResult.IsError) { parsingContext.LogError(reader, textSourceParsingResult.ErrorMessage); return; } var textSource = textSourceParsingResult.TextSource; if (reader.ReadState != ReadState.EndOfFile) { await elementParser.ParseAsync(reader, parsingContext, myContext, AggregationSettings); } var node = new BalloonTextNode(textSource, BalloonType, myContext.ChoiceNode); parentParsingContext.AddNode(node); parsingContext.SceneContext.Reset(); }
public async Task ParseAsync(XmlReader reader, IParsingContext parsingContext, IParentParsingContext parentParsingContext) { var myContext = new TextParentParsingContext(); await elementParser.ParseAsync(reader, parsingContext, myContext, Settings); if (myContext.ParsedText is null) { return; } var value = int.Parse(myContext.ParsedText); if (value < 1) { return; } if (value > 30000) { parsingContext.LogError(reader, "O limite de tempo não pode ser maior que 30 segundos."); return; } var ctx = (ChoiceParentParsingContext)parentParsingContext; ctx.Choice.TimeLimit = TimeSpan.FromMilliseconds(value); }
public async Task ParseAsync(XmlReader reader, IParsingContext parsingContext, IParentParsingContext parentParsingContext) { var context = new BackgroundContext(); await elementParser.ParseAsync(reader, parsingContext, context, Settings); if (!string.IsNullOrWhiteSpace(context.ParsedText)) { var state = new BackgroundState(context.ParsedText, BackgroundType.Image, BackgroundPosition.Left); var block = parsingContext.BlockFactory.Create( new BackgroundNode(state, null), new ScrollNode(null) ); parentParsingContext.AddNode(new BlockNode(block, context.When)); parsingContext.RegisterDismissNode(DismissNode); return; } if (context.Nodes.Count == 0) { parsingContext.LogError(reader, "Nome de imagem ou elemento filho era esperado."); return; } { var block = parsingContext.BlockFactory.Create(context.Nodes); parentParsingContext.AddNode(new BlockNode(block, context.When)); parsingContext.RegisterDismissNode(DismissNode); } }
public SerializationHeaderRecord(IParsingContext context) { RootId = context.ReadInt32(); HeaderId = context.ReadInt32(); MajorVersion = context.ReadInt32(); MinorVersion = context.ReadInt32(); }
public StatementParser(Token[] tokens, IParsingContext[] parsingContexts, MethodDefinition containingMethod) { mTokens = tokens; mParsingContexts = parsingContexts; mContainingMethod = containingMethod; Reset(); }
protected virtual void TraceDebug( IParsingContext <TToken> context, string messageFormat, params object[] args) { var message = string.Format(CultureInfo.InvariantCulture, messageFormat, args); Debug.WriteLine("[" + context.BranchId + "] " + message); }
public string?Parse(XmlReader reader, IParsingContext parsingContext, string value) { if (string.IsNullOrWhiteSpace(value)) { return(null); } return(value); }
public async Task ParseAsync(XmlReader reader, IParsingContext parsingContext, IParentParsingContext parentParsingContext) { var myContext = new TextParentParsingContext(); await elementParser.ParseAsync(reader, parsingContext, myContext, Settings); var node = new ScrollNode(myContext.When); parentParsingContext.AddNode(node); }
public async Task ParseAsync(XmlReader reader, IParsingContext parsingContext, IParentParsingContext parentParsingContext) { var myContext = new TextParentParsingContext(); await elementParser.ParseAsync(reader, parsingContext, myContext, Settings); var ctx = (ChoiceOptionParentParsingContext)parentParsingContext; ctx.Option.DisabledText = myContext.ParsedText; }
public async Task ParseAsync(XmlReader reader, IParsingContext parsingContext, IParentParsingContext parentParsingContext) { var myContext = new TextParentParsingContext(); await elementParser.ParseAsync(reader, parsingContext, myContext, Settings); var ctx = (ChoiceParentParsingContext)parentParsingContext; ctx.Choice.RandomOrder = true; }
public async Task ParseAsync(XmlReader reader, IParsingContext parsingContext, IParentParsingContext parentParsingContext) { while (await reader.ReadAsync()) { } if (ret is not null) { parentParsingContext.AddNode(ret); } }
public IAttribute?Parse(XmlReader reader, IParsingContext parsingContext) { if (ConditionParser.TryParse(reader.Value, out var condition)) { return(new WhenAttribute(condition)); } parsingContext.LogError(reader, "Condição 'when' inválida."); return(null); }
/// <summary> /// Matches specific set of tokens. /// </summary> /// <param name="context">Parsing context</param> /// <returns>Original context with consumed tokens or null, if match did not succeed.</returns> protected sealed override async Task <IReadOnlyCollection <IParsingContext <TToken> > > MatchInternal( IParsingContext <TToken> context) { if (await TryMatch(context)) { return(new[] { context }); } return(null); }
public UnsetNodeParserTests() { reader = A.Dummy <XmlReader>(); context = A.Fake <IParsingContext>(i => i.Strict()); parentContext = new(); elementParser = A.Fake <IElementParser>(i => i.Strict()); nameTextParser = A.Fake <INameTextParser>(i => i.Strict()); sut = new(elementParser, nameTextParser); }
Object IValueHolder.GetValue(IParsingContext context) { var elementType = ClassRecordBase.ToRealType(PrimitiveType); var arr = Array.CreateInstance(elementType, ArrayInfo.Length); for (var idx = 0; idx < arr.Length; ++idx) { arr.SetValue(Values[idx].Value, idx); } return arr; }
public SetNodeParserTests() { reader = A.Dummy <XmlReader>(); context = A.Fake <IParsingContext>(i => i.Strict()); parentContext = new(); varSetParser = A.Fake <IVarSetParser>(i => i.Strict()); elementParser = A.Fake <IElementParser>(i => i.Strict()); varSetTextParser = A.Fake <IVarSetTextParser>(i => i.Strict()); sut = new(varSetParser, elementParser, varSetTextParser); }
protected override async Task <bool> TryMatch(IParsingContext <char> context) { if (context.TokenStream.CurrentToken == '*') { await context.TokenStream.Consume(); return(true); } return(false); }
public IAttribute?Parse(XmlReader reader, IParsingContext parsingContext) { var result = conditionParser.Parse(reader.Value); if (result.Condition is not null) { return(new WhenAttribute(result.Condition)); } parsingContext.LogError(reader, "Condição 'when' inválida. " + result.Message); return(null); }
public async Task <List <INode> > ParseAsync(XmlReader reader, IParsingContext parsingContext) { var context = new BlockParentParsingContext(); await elementParser.ParseAsync(reader, parsingContext, context, Settings); if (context.Nodes.Count == 0) { parsingContext.LogError(reader, "Elemento filho era esperado."); } return(context.Nodes); }
public ClassInfo(IParsingContext context) { ObjectId = context.ReadInt32(); Name = context.ReadString(); var memberCount = context.ReadInt32(); Check.That(memberCount >= 0, "MemberCount MUST be 0 or a positive integer."); Members = new String[memberCount]; for (var i = 0; i < memberCount; ++i) { Members[i] = context.ReadString(); } }
internal ArraySinglePrimitive(IParsingContext context) { ArrayInfo = new ArrayInfo(context); PrimitiveType = (PrimitiveTypeEnumeration) context.ReadByte(); Check.That(PrimitiveType != PrimitiveTypeEnumeration.Null, "PrimitiveType must not be Null."); Check.That(PrimitiveType != PrimitiveTypeEnumeration.String, "PrimitiveType must not be String."); Values = new MemberPrimitiveUnTyped[ArrayInfo.Length]; for (var idx = 0; idx < Values.Length; ++idx) { Values[idx] = new MemberPrimitiveUnTyped(context, PrimitiveType); } }
public async Task ParseAsync(XmlReader reader, IParsingContext parsingContext, IParentParsingContext parentParsingContext) { var myContext = new TextParentParsingContext(); await elementParser.ParseAsync(reader, parsingContext, myContext, Settings); if (myContext.ParsedText is null) { return; } var ctx = (ChoiceParentParsingContext)parentParsingContext; ctx.Choice.Default = myContext.ParsedText; }
protected override ParsingResult ProcessCharacterImpl(IParsingContext context, char nextChar) { ParsingResult finalResult = ParsingResult.Match; System.Diagnostics.Debug.Assert(currentCharacterIndex < tokenToMatch.Length * 2); int currentCompareCharacterIndex = currentCharacterIndex % tokenToMatch.Length; if (nextChar == tokenToMatch[currentCompareCharacterIndex]) { currentCharacterIndex++; if (this.currentCharacterIndex == tokenToMatch.Length * 2) { if (this.errorState != null) { context.CurrentState = this.errorState; context.Append(this.tokenToMatch); } else { finalResult = ParsingResult.Done; } this.currentCharacterIndex = 0; } } else { if (currentCharacterIndex == 0) { finalResult = ParsingResult.Miss; } else if (currentCompareCharacterIndex == currentCharacterIndex) { context.CurrentState = this.errorState; context.Append(this.tokenToMatch.Substring(0, this.currentCharacterIndex)); finalResult = ParsingResult.Miss; } else { context.CurrentState = this.nextState; context.Append(this.tokenToMatch.Substring(0, currentCompareCharacterIndex)); finalResult = ParsingResult.Miss; } this.currentCharacterIndex = 0; } return(finalResult); }
public string?Parse(XmlReader reader, IParsingContext parsingContext, string value) { if (string.IsNullOrWhiteSpace(value)) { return(string.Empty); } if (!Regex.IsMatch(value, @"^(#[a-f0-9]{6}|black|green|silver|gray|olive|white|yellow|maroon|navy|red|blue|purple|teal|fuchsia|aqua)$", RegexOptions.IgnoreCase)) { parsingContext.LogError(reader, $"O texto '{value}' não representa uma cor válida."); return(null); } return(value.ToLower()); }
public async Task ParseAsync(XmlReader reader, IParsingContext parsingContext, IParentParsingContext parentParsingContext) { var myContext = new ChoiceParentParsingContext(); await elementParser.ParseAsync(reader, parsingContext, myContext, Settings); if (myContext.Choice.Options.Count == 0) { parsingContext.LogError(reader, "Nenhuma opção informada."); return; } var ctx = (BalloonChildParsingContext)parentParsingContext; ctx.ChoiceNode = myContext.Choice; }
protected override async Task <bool> TryMatch(IParsingContext <char> context) { var matched = false; while (context.TokenStream.CurrentToken == ' ' || context.TokenStream.CurrentToken == '\t' || context.TokenStream.CurrentToken == '\n' || context.TokenStream.CurrentToken == '\r') { matched = true; await context.TokenStream.Consume(); } return(matched); }
private ObjectValues Build(IParsingContext context, Object current, ClassInfo type, Object[] values, IDictionary<Int32, ObjectValues> cache) { // Check (and return) cached values early so we don't enter an infinite // loop while resolving references to ourself. var hasObjectId = current as ISerializedObject; if (hasObjectId != null && cache.ContainsKey(hasObjectId.ObjectId)) { return cache[hasObjectId.ObjectId]; } String libraryName = null; var hasLibraryId = current as IHasLibraryId; if (hasLibraryId != null) { var library = context.GetLibrary(hasLibraryId.LibraryId); libraryName = library.LibraryName; } var target = new ObjectValues(libraryName, type.Name); if (hasObjectId != null) { // Store the item in the cache early to avoid infinite loops if // we have a reference to ourself. cache[hasObjectId.ObjectId] = target; } for(var i = 0; i < values.Length; ++i){ var memberName = type.Members[i]; var value = values[i]; while(value is IValueHolder) { value = ((IValueHolder)value).GetValue(context); } var nestedTypeHolder = value as ITypeHolder; if (nestedTypeHolder != null) { var nestedType = nestedTypeHolder.GetClassInfo(context); var nestedValues = ((ClassRecordBase)value).Values; Object result; if (TryBuildSystemType(context, nestedType, nestedValues, out result)) target[memberName] = result; else target[memberName] = Build(context, value, nestedType, nestedValues, cache); } else { target[memberName] = value; } } return target; }
protected override async Task <bool> TryMatch(IParsingContext <char> context) { var matched = false; while ((context.TokenStream.CurrentToken >= 'a' && context.TokenStream.CurrentToken <= 'z') || (context.TokenStream.CurrentToken >= 'A' && context.TokenStream.CurrentToken <= 'Z') || (context.TokenStream.CurrentToken >= '0' && context.TokenStream.CurrentToken <= '9') || context.TokenStream.CurrentToken == '_') { await context.TokenStream.Consume(); matched = true; } return(matched); }
public async Task ParseAsync(XmlReader reader, IParsingContext parsingContext, IParentParsingContext parentParsingContext) { var myContext = new BlockParentParsingContext(); await elementParser.ParseAsync(reader, parsingContext, myContext, Settings); if (myContext.Nodes.Count == 0) { parsingContext.LogError(reader, "Elemento filho era esperado."); return; } var block = parsingContext.BlockFactory.Create(myContext.Nodes, myContext.While); var node = new BlockNode(block, myContext.When); parentParsingContext.AddNode(node); }
public async Task ParseAsync(XmlReader reader, IParsingContext parsingContext, IParentParsingContext parentParsingContext) { var myContext = new TextParentParsingContext(); await elementParser.ParseAsync(reader, parsingContext, myContext, Settings); var parsedText = myContext.ParsedText; if (parsedText is null) { return; } var varSet = new VarSet(parsedText, null); parentParsingContext.AddNode(new VarSetNode(varSet)); }
/// <summary> /// Tries to match provided rule one time. /// </summary> /// <param name="context">Parsing context</param> /// <returns> /// Original branch, if rule doesn't match, otherwise both - original branch and /// branch with consumed optional match. /// </returns> public async Task <IReadOnlyCollection <IParsingContext <TToken> > > Match(IParsingContext <TToken> context) { var branchesWithOptionalMatch = await rule.Match(context.Clone()); if (branchesWithOptionalMatch != null && branchesWithOptionalMatch.Count > 0) { return (new List <IParsingContext <TToken> >(branchesWithOptionalMatch) { context }); } // Optional rule didn't match, return original parsing context return(new[] { context }); }
protected override async Task <bool> TryMatch(IParsingContext <char> context) { while (context.TokenStream.CurrentToken != '"') { if ((context.TokenStream.CurrentToken >= '\u0000' && context.TokenStream.CurrentToken <= '\u0021') || (context.TokenStream.CurrentToken >= '\u0023' && context.TokenStream.CurrentToken <= '\u005b') || (context.TokenStream.CurrentToken >= '\u005d' && context.TokenStream.CurrentToken <= '\uFFFF')) { await context.TokenStream.Consume(); continue; } else if (context.TokenStream.CurrentToken == '\\') { await context.TokenStream.Consume(); if (context.TokenStream.CurrentToken == '\\' || context.TokenStream.CurrentToken == '"') { await context.TokenStream.Consume(); continue; } else if (context.TokenStream.CurrentToken == 'u') { await context.TokenStream.Consume(); for (var hexIndex = 0; hexIndex < 4; ++hexIndex) { if (context.TokenStream.CurrentToken < '0' && context.TokenStream.CurrentToken > '9' && context.TokenStream.CurrentToken < 'A' && context.TokenStream.CurrentToken > 'F') { return(false); } await context.TokenStream.Consume(); } continue; } } return(false); } return(true); }
public async Task <INode?> ParseAsync(XmlReader reader, IParsingContext parsingContext) { var parsed = await elementParser.ParseAsync(reader, parsingContext); if (parsed is null) { return(null); } if (parsed.Block is null || parsed.Block.IsEmpty()) { parsingContext.LogError(reader, "Nenhum comando de storyboard válido encontrado."); return(null); } return(new BlockNode(parsed.Block, null, null)); }
protected internal static Object ReadPrimitiveValue(IParsingContext context, PrimitiveTypeEnumeration type) { switch (type) { case PrimitiveTypeEnumeration.Boolean: return context.ReadBoolean(); case PrimitiveTypeEnumeration.Byte: return context.ReadByte(); case PrimitiveTypeEnumeration.Char: return context.ReadChar(); case PrimitiveTypeEnumeration.DateTime: var data = context.ReadInt64(); var dt = DateTime.FromBinary(data); var dtUtc = dt.ToUniversalTime(); return new DateTime(dtUtc.Ticks, dt.Kind); case PrimitiveTypeEnumeration.Decimal: return Decimal.Parse(context.ReadString(), CultureInfo.InvariantCulture); case PrimitiveTypeEnumeration.Double: return context.ReadDouble(); case PrimitiveTypeEnumeration.Int16: return context.ReadInt16(); case PrimitiveTypeEnumeration.Int32: return context.ReadInt32(); case PrimitiveTypeEnumeration.Int64: return context.ReadInt64(); case PrimitiveTypeEnumeration.Null: return null; case PrimitiveTypeEnumeration.SByte: return context.ReadSByte(); case PrimitiveTypeEnumeration.Single: return context.ReadSingle(); case PrimitiveTypeEnumeration.String: return context.ReadString(); case PrimitiveTypeEnumeration.TimeSpan: return TimeSpan.FromTicks(context.ReadInt64()); case PrimitiveTypeEnumeration.UInt16: return context.ReadUInt16(); case PrimitiveTypeEnumeration.UInt32: return context.ReadUInt32(); case PrimitiveTypeEnumeration.UInt64: return context.ReadUInt64(); default: throw new NotSupportedException("Unsupported primitive type " + type); } }
public ParsingResult ProcessCharacter(IParsingContext context, char nextChar) { ArgumentVerifier.CheckObjectArgument(context, "context"); foreach (IParsingState parsingState in nextStates) { ParsingResult result = parsingState.ProcessCharacter(context, nextChar); if (result != ParsingResult.Miss) { if (context.CurrentState == this) { // If the current state has not changed in the ProcessCharacter call, // we should change it now. context.CurrentState = parsingState; } return result; } } context.Append(nextChar); return ParsingResult.Match; }
protected virtual ParsingResult ProcessCharacterImpl(IParsingContext context, char nextChar) { ParsingResult finalResult = ParsingResult.Match; System.Diagnostics.Debug.Assert(currentCharacterIndex < tokenToMatch.Length); if (nextChar == tokenToMatch[currentCharacterIndex]) { currentCharacterIndex++; if (this.currentCharacterIndex == tokenToMatch.Length) { if (this.nextState != null) { context.CurrentState = this.nextState; } else { finalResult = ParsingResult.Done; } this.currentCharacterIndex = 0; } } else { if (currentCharacterIndex == 0) { finalResult = ParsingResult.Miss; } else { context.CurrentState = this.errorState; context.Append(this.tokenToMatch.Substring(0, this.currentCharacterIndex)); finalResult = ParsingResult.Miss; } this.currentCharacterIndex = 0; } return finalResult; }
public BinaryLibrary(IParsingContext context) { LibraryId = context.ReadInt32(); LibraryName = context.ReadString(); }
public ClassTypeInfo(IParsingContext context) { TypeName = context.ReadString(); LibraryId = context.ReadInt32(); }
public ParsingResult ProcessCharacter(IParsingContext context, char nextChar) { return result; }
private ImapDataResponse ParseDataResponse(ByteString line, ref IParsingContext parsingContext) { // mailbox-data / message-data / capability-data etc. // ("*" / tag) SP var offset = (parsingContext == null) ? line.IndexOf(Octets.SP) + 1 : 0; var parsedData = ParseData(line, offset, ref parsingContext); if (parsedData == null) return null; else return ImapDataResponse.Create(parsedData); }
private ImapResponse ParseResponce(ByteString line, ref IParsingContext parsingContext) { // response = *(continue-req / response-data) response-done // continue-req = "+" SP (resp-text / base64) CRLF if (line.StartsWith(continueReqMark)) return new ImapCommandContinuationRequest(line.ToString(2, line.Length - 4)); // remove leading "+" SP and trailing CRLF // greeting = "*" SP (resp-cond-auth / resp-cond-bye) CRLF // response-done = response-tagged / response-fatal // response-data = "*" SP (resp-cond-state / resp-cond-bye / // mailbox-data / message-data / capability-data) CRLF // response-fatal = "*" SP resp-cond-bye CRLF // ; Server closes connection immediately // response-tagged = tag SP resp-cond-state CRLF // ("*" / tag) SP var tagSep = line.IndexOf(Octets.SP); if (tagSep == -1) // response-done and response-data must contain SP throw new ImapMalformedResponseException("malformed response-done/response-data", line.ToString()); var untagged = (tagSep == 1 && line[0] == ImapOctets.Asterisk); // ("OK" / "BAD" / "NO" / "BYE" / "PREAUTH" / text) SP var respCondSep = line.IndexOf(Octets.SP, tagSep + 1); var cond = ImapResponseCondition.Undefined; if (respCondSep == -1) { if (!untagged) throw new ImapMalformedResponseException("malformed response-data", line.ToString()); //else // '* SEARCH\r\n' (mailbox-data which contains no SP) } else { cond = ParseCondition(line.Substring(tagSep + 1, respCondSep - tagSep - 1)); } if (cond != ImapResponseCondition.Undefined || line.StartsWith(respCondMark)) { // resp-cond-auth / resp-cond-state / resp-cond-bye var responseText = ParseRespText((cond == ImapResponseCondition.Undefined) ? line.Substring(tagSep + 1) : line.Substring(respCondSep + 1)); if (untagged) return new ImapUntaggedStatusResponse((ImapResponseCondition)cond, responseText); else return new ImapTaggedStatusResponse(line.ToString(0, tagSep), (ImapResponseCondition)cond, responseText); } // mailbox-data / message-data / capability-data etc. return ParseDataResponse(line, ref parsingContext); }
public ParsingResult ProcessCharacter(IParsingContext context, char nextChar) { ArgumentVerifier.CheckObjectArgument(context, "context"); return ProcessCharacterImpl(context, nextChar); }
public MemberTypeInfo(IParsingContext context, Int32 count) { BinaryTypeEnums = new BinaryTypeEnumeration[count]; AdditionalInfos = new Object[count]; for (var i = 0; i < count; ++i) { BinaryTypeEnums[i] = (BinaryTypeEnumeration)context.ReadByte(); } for (var i = 0; i < count; ++i) { var binaryType = BinaryTypeEnums[i]; switch (binaryType) { case BinaryTypeEnumeration.String: case BinaryTypeEnumeration.StringArray: case BinaryTypeEnumeration.Object: case BinaryTypeEnumeration.ObjectArray: break; case BinaryTypeEnumeration.Primitive: case BinaryTypeEnumeration.PrimitiveArray: AdditionalInfos[i] = (PrimitiveTypeEnumeration)context.ReadByte(); break; case BinaryTypeEnumeration.SystemClass: AdditionalInfos[i] = context.ReadString(); break; case BinaryTypeEnumeration.Class: AdditionalInfos[i] = new ClassTypeInfo(context); break; default: throw new NotSupportedException("Unsupported BinaryType " + binaryType); } } }
public Object GetValue(IParsingContext context) { return Value; }
public MemberReference(IParsingContext context) { IdRef = context.ReadInt32(); ; }
public BinaryObjectString(IParsingContext context) { ObjectId = context.ReadInt32(); Value = context.ReadString(); }
public ParameterDefinition(IParsingContext[] parsingContext) { mParsingContext = parsingContext; }
public Object GetValue(IParsingContext context) { return context.GetObject(IdRef); }
internal MemberPrimitiveTyped(IParsingContext context) { PrimitiveType = (PrimitiveTypeEnumeration) context.ReadByte(); Value = ClassRecordBase.ReadPrimitiveValue(context, PrimitiveType); }
protected ImapData[] ParseData(ByteString line, int offset, ref IParsingContext context) { var index = offset; var c = context as ParsingContext; if (c == null) { context = c = new ParsingContext(); } else { if (line.Length - index == 2/*CRLF*/) { if (c.ParenthesesClosed) { // end of data context = null; return c.GetParsed(); } else { throw new ImapMalformedDataException("unclosed parenthesis"); } } else if (line[index] == Octets.SP) { index++; } } var bytes = line.ByteArray; for (;;) { if (bytes[index] == Octets.SP) // skip SP index = line.IndexOfNot(Octets.SP, index); switch (bytes[index]) { case ImapOctets.DQuote: { // quoted c.AddData(ImapData.CreateTextData(ParseQuotedString(line, ref index))); break; } case ImapOctets.OpenParen: { // parenthesized begin c.OpenParenthesis(); index++; // '(' break; } case ImapOctets.CloseParen: { // parenthesized end c.CloseParenthesis(); index++; // ')' break; } case ImapOctets.OpenBrace: case ImapOctets.Tilde: { // literal/literal8 ImapData parsed; var isLiteral = ParseLiteral((bytes[index] == ImapOctets.Tilde), line, ref index, out parsed); c.AddData(parsed); if (isLiteral) return null; // incomplete else break; } default: { // non-quoted var text = ParseNonQuotedString(line, ref index); if (nil.EqualsIgnoreCase(text)) c.AddData(ImapData.CreateNilData()); else c.AddData(ImapData.CreateTextData(text)); break; } } if (line.Length - index == 2/*CRLF*/) { if (c.ParenthesesClosed) { // end of data context = null; return c.GetParsed(); } else { return null; // incomplete } } else { if (bytes[index] == Octets.SP) index++; } } // for }
private Boolean TryBuildSystemType(IParsingContext context, ClassInfo classInfo, Object[] values, out Object result) { Func<String, Object> V = name => classInfo.GetValue(name, values); if (classInfo.Name == "System.Guid") { result = new Guid((Int32)V("_a"), (Int16)V("_b"), (Int16)V("_c"), (Byte)V("_d"), (Byte)V("_e"), (Byte)V("_f"), (Byte)V("_g"), (Byte)V("_h"), (Byte)V("_i"), (Byte)V("_j"), (Byte)V("_k")); return true; } result = null; return false; }
public SystemClassWithMembersAndTypes(IParsingContext context) : base(context) { Values = ReadValues(context, MemberTypeInfo); }
public ImapResponse ReceiveResponse() { var line = Receive(); try { return (dataParsingContext == null) ? ParseResponce(line, ref dataParsingContext) : ParseDataResponse(line, ref dataParsingContext); } catch (Exception ex) { dataParsingContext = null; // discard context if (ex is ImapMalformedDataException) throw new ImapMalformedResponseException(ex.Message); else throw; } }
internal MemberPrimitiveUnTyped(IParsingContext context, PrimitiveTypeEnumeration primitiveType) { Value = ClassRecordBase.ReadPrimitiveValue(context, primitiveType); }
Object IValueHolder.GetValue(IParsingContext context) { return Value; }