internal static PrimitiveTypeValueAst ReadDefaultValue(ParserStream stream, IdentifierToken returnType) { switch (returnType.GetNormalizedName()) { case Keywords.DT_UINT8: case Keywords.DT_UINT16: case Keywords.DT_UINT32: case Keywords.DT_UINT64: case Keywords.DT_SINT8: case Keywords.DT_SINT16: case Keywords.DT_SINT32: case Keywords.DT_SINT64: case Keywords.DT_REAL32: case Keywords.DT_REAL64: case Keywords.DT_STRING: case Keywords.DT_DATETIME: case Keywords.DT_BOOLEAN: case Keywords.DT_OCTECTSTRING: // primitiveType return(PrimitiveTypeValueAst.Parse(stream)); default: /// structureOrClassName /// enumName /// classReference var peek = stream.Peek(); if (peek is NullLiteralToken) { return(NullValueAst.Parse(stream)); } throw new UnsupportedTokenException(stream.Peek()); } }
/// <summary> /// </summary> /// <returns></returns> /// <remarks> /// /// See http://www.dmtf.org/sites/default/files/standards/documents/DSP0221_3.0.0.pdf /// A.19 Reference type value /// /// referenceTypeValue = referenceValue / referenceValueArray /// referenceValueArray = "{" [ objectPathValue *( "," objectPathValue ) ] /// /// No whitespace is allowed between the elements of the rules in this ABNF section. /// /// objectPathValue = [namespacePath ":"] instanceId /// namespacePath = [serverPath] namespaceName /// /// ; Note: The production rules for host and port are defined in IETF /// ; RFC 3986 (Uniform Resource Identifiers (URI): Generic Syntax). /// /// serverPath = (host / LOCALHOST) [ ":" port] "/" /// LOCALHOST = "localhost" ; Case insensitive /// instanceId = className "." instanceKeyValue /// instanceKeyValue = keyValue *( "," keyValue ) /// keyValue = propertyName "=" literalValue /// /// </remarks> internal static ReferenceTypeValue Parse(ParserStream stream) { var node = new ReferenceTypeValue(); // referenceValue = objectPathValue node.Name = stream.Read<AliasIdentifierToken>().Name; return node; }
/// <summary> /// /// </summary> /// <param name="stream"></param> /// <returns></returns> /// <remarks> /// /// See http://www.dmtf.org/sites/default/files/standards/documents/DSP0221_3.0.0a.pdf /// A.1 Value definitions /// /// literalValue = integerValue / realValue / /// stringValue / octetStringValue /// booleanValue / /// nullValue / /// dateTimeValue /// /// </remarks> internal new static LiteralValueAst Parse(ParserStream stream) { //Note: This is a good candidate for the strategy pattern var peek = stream.Peek(); if (peek is IntegerLiteralToken) { // integerValue return(IntegerValueAst.Parse(stream)); } else if (peek is RealLiteralToken) { // doubleValue return(RealValueAst.Parse(stream)); } else if (peek is StringLiteralToken) { // stringValue return(StringValueAst.Parse(stream)); } else if (peek is BooleanLiteralToken) { // booleanValue return(BooleanValueAst.Parse(stream)); } else if (peek is NullLiteralToken) { // nullValue return(NullValueAst.Parse(stream)); } else { throw new UnexpectedTokenException(peek); } }
/// <summary> /// /// </summary> /// <param name="stream"></param> /// <returns></returns> /// <remarks> /// /// See http://www.dmtf.org/sites/default/files/standards/documents/DSP0221_3.0.0a.pdf /// A.12 Parameter declaration /// /// parameterDeclaration = [ qualifierList ] ( primitiveParamDeclaration / /// complexParamDeclaration / /// enumParamDeclaration / /// referenceParamDeclaration ) /// /// primitiveParamDeclaration = primitiveType parameterName [ array ] /// [ "=" primitiveTypeValue ] /// complexParamDeclaration = structureOrClassName parameterName [ array ] /// [ "=" ( complexTypeValue / aliasIdentifier ) ] /// enumParamDeclaration = enumName parameterName [ array ] /// [ "=" enumValue ] /// referenceParamDeclaration = classReference parameterName [ array ] /// [ "=" referenceTypeValue ] /// /// parameterName = IDENTIFIER /// /// </remarks> internal static ParameterDeclarationAst Parse(ParserStream stream) { var parameter = new ParameterDeclarationAst(); var qualifiers = default(QualifierListAst); if (stream.Peek <AttributeOpenToken>() != null) { qualifiers = QualifierListAst.Parse(stream); } parameter.Qualifiers = qualifiers; parameter.Type = stream.Read <IdentifierToken>(); if (stream.PeekIdentifier(Keywords.REF)) { stream.ReadIdentifier(Keywords.REF); parameter.IsRef = true; } else { parameter.IsRef = false; } parameter.Name = stream.Read <IdentifierToken>(); if (stream.Peek <AttributeOpenToken>() != null) { stream.Read <AttributeOpenToken>(); stream.Read <AttributeCloseToken>(); parameter.IsArray = true; } if (stream.Peek <EqualsOperatorToken>() != null) { stream.Read <EqualsOperatorToken>(); parameter.DefaultValue = ClassFeatureAst.ReadDefaultValue(stream, parameter.Type); } return(parameter); }
internal new static DateTimeValueAst Parse(ParserStream stream) { return(new DateTimeValueAst { Value = stream.Read <DateTimeLiteralToken>().Value }); }
internal new static OctetStringValueAst Parse(ParserStream stream) { return(new OctetStringValueAst { Value = stream.Read <OctetStringLiteralToken>().Value }); }
/// <summary> /// </summary> /// <returns></returns> /// <remarks> /// /// See http://www.dmtf.org/sites/default/files/standards/documents/DSP0221_3.0.0a.pdf /// A.1 Value definitions /// /// literalValueArray = "{" [ literalValue *( "," literalValue ) ] "}" /// /// </remarks> internal new static LiteralValueArrayAst Parse(ParserStream stream) { var node = new LiteralValueArrayAst(); // "{" stream.Read <BlockOpenToken>(); // [ literalValue *( "," literalValue) ] if (stream.Peek <BlockCloseToken>() == null) { while (!stream.Eof) { if (node.Values.Count > 0) { stream.Read <CommaToken>(); } node.Values.Add(LiteralValueAst.Parse(stream)); if (stream.Peek <BlockCloseToken>() != null) { break; } } } // "}" stream.Read <BlockCloseToken>(); // return the result return(node); }
internal new static RealValueAst Parse(ParserStream stream) { return(new RealValueAst { Value = stream.Read <RealLiteralToken>().Value }); }
/// <summary> /// </summary> /// <returns></returns> /// <remarks> /// /// See http://www.dmtf.org/sites/default/files/standards/documents/DSP0221_3.0.0a.pdf /// A.14 Complex type value /// /// complexTypeValue = complexValue / complexValueArray /// complexValueArray = "{" [ complexValue *( "," complexValue) ] "}" /// complexValue = ( INSTANCE / VALUE ) OF /// ( structureName / className / associationName ) /// [ alias ] propertyValueList /// propertyValueList = "{" *propertySlot "}" /// propertySlot = propertyName "=" propertyValue ";" /// propertyValue = primitiveTypeValue / complexTypeValue / referenceTypeValue / enumTypeValue /// alias = AS aliasIdentifier /// INSTANCE = "instance" ; keyword: case insensitive /// VALUE = "value" ; keyword: case insensitive /// AS = "as" ; keyword: case insensitive /// OF = "of" ; keyword: case insensitive /// /// propertyName = IDENTIFIER /// /// </remarks> internal static ComplexTypeValueAst Parse(ParserStream stream, QualifierListAst qualifiers) { ComplexTypeValueAst ast; var peek = stream.Peek(); if (peek is BlockOpenToken) { // complexValueArray ast = ComplexValueArrayAst.Parse(stream); } else if (peek is IdentifierToken) { // complexValue ast = ComplexValueAst.Parse(stream); } else { throw new InvalidOperationException(); } ast.Qualifiers = qualifiers; return ast; }
internal static new OctetStringValueAst Parse(ParserStream stream) { return new OctetStringValueAst { Value = stream.Read<OctetStringLiteralToken>().Value }; }
/// <summary> /// </summary> /// <returns></returns> /// <remarks> /// /// See http://www.dmtf.org/sites/default/files/standards/documents/DSP0221_3.0.0a.pdf /// A.14 Complex type value /// /// complexTypeValue = complexValue / complexValueArray /// /// </remarks> internal static ComplexTypeValueAst Parse(ParserStream stream, QualifierListAst qualifiers) { var node = default(ComplexTypeValueAst); var peek = stream.Peek(); if (peek is BlockOpenToken) { // complexValueArray node = ComplexValueArrayAst.Parse(stream); } else if (peek is IdentifierToken) { // complexValue node = ComplexValueAst.Parse(stream); } else { throw new UnexpectedTokenException(peek); } node.Qualifiers = qualifiers; return(node); }
internal static new BooleanValueAst Parse(ParserStream stream) { return new BooleanValueAst { Value = stream.Read<BooleanLiteralToken>().Value }; }
internal new static IntegerValueAst Parse(ParserStream stream) { return(new IntegerValueAst { Value = stream.Read <IntegerLiteralToken>().Value }); }
public void SkipToPeek() { using (var sr = new StringReader("abcd")) { var ps = new ParserStream(sr); ps.Peek(); ps.Peek(); ps.SkipToPeek(); ps.Current.Should().Be('c'); ps.CurrentPeek.Should().Be('c'); ps.GetPeekIndex().Should().Be(2); ps.GetIndex().Should().Be(2); ps.Peek(); ps.Current.Should().Be('c'); ps.CurrentPeek.Should().Be('d'); ps.GetPeekIndex().Should().Be(3); ps.GetIndex().Should().Be(2); ps.Next(); ps.Current.Should().Be('d'); ps.CurrentPeek.Should().Be('d'); ps.GetPeekIndex().Should().Be(3); ps.GetIndex().Should().Be(3); } }
internal static new NullValueAst Parse(ParserStream stream) { return new NullValueAst { Value = stream.Read<NullLiteralToken>().Value }; }
internal static new DateTimeValueAst Parse(ParserStream stream) { return new DateTimeValueAst { Value = stream.Read<DateTimeLiteralToken>().Value }; }
internal static QualifierAst Parse(ParserStream stream) { var ast = new QualifierAst(); ast.Qualifier = stream.Read<IdentifierToken>().Name; if (stream.Peek<OpenParenthesesToken>() != null) { stream.Read<OpenParenthesesToken>(); ast.Initializer = LiteralValueAst.Parse(stream); stream.Read<CloseParenthesesToken>(); } else if (stream.Peek<BlockOpenToken>() != null) { ast.Initializer = LiteralValueArrayAst.Parse(stream); } if (stream.Peek<ColonToken>() != null) { stream.Read<ColonToken>(); while (stream.Peek<IdentifierToken>() != null) { ast.Flavors.Add(stream.Read<IdentifierToken>().Name); } } return ast; }
public void Next() { using (var sr = new StringReader("abcd")) { var ps = new ParserStream(sr); ps.Current.Should().Be('a'); ps.GetIndex().Should().Be(0); ps.Next().Should().Be('b'); ps.Current.Should().Be('b'); ps.GetIndex().Should().Be(1); ps.Next().Should().Be('c'); ps.Current.Should().Be('c'); ps.GetIndex().Should().Be(2); ps.Next().Should().Be('d'); ps.Current.Should().Be('d'); ps.GetIndex().Should().Be(3); ps.Next().Should().Be(ParserStream.Eof); ps.Current.Should().Be(ParserStream.Eof); ps.GetIndex().Should().Be(4); } }
internal static new IntegerValueAst Parse(ParserStream stream) { return new IntegerValueAst { Value = stream.Read<IntegerLiteralToken>().Value }; }
internal new static QualifierDeclarationAst Parse(ParserStream stream) { var ast = new QualifierDeclarationAst(); ast.Name = stream.Read <IdentifierToken>(); if (stream.Peek <ParenthesesOpenToken>() != null) { stream.Read <ParenthesesOpenToken>(); ast.Initializer = LiteralValueAst.Parse(stream); stream.Read <ParenthesesCloseToken>(); } else if (stream.Peek <BlockOpenToken>() != null) { ast.Initializer = LiteralValueArrayAst.Parse(stream); } if (stream.Peek <ColonToken>() != null) { stream.Read <ColonToken>(); while (stream.Peek <IdentifierToken>() != null) { ast.Flavors.Add(stream.Read <IdentifierToken>().Name); } } return(ast); }
/// <summary> /// </summary> /// <returns></returns> /// <remarks> /// /// See http://www.dmtf.org/sites/default/files/standards/documents/DSP0221_3.0.0.pdf /// A.19 Reference type value /// /// referenceTypeValue = referenceValue / referenceValueArray /// referenceValueArray = "{" [ objectPathValue *( "," objectPathValue ) ] /// /// No whitespace is allowed between the elements of the rules in this ABNF section. /// /// objectPathValue = [namespacePath ":"] instanceId /// namespacePath = [serverPath] namespaceName /// /// ; Note: The production rules for host and port are defined in IETF /// ; RFC 3986 (Uniform Resource Identifiers (URI): Generic Syntax). /// /// serverPath = (host / LOCALHOST) [ ":" port] "/" /// LOCALHOST = "localhost" ; Case insensitive /// instanceId = className "." instanceKeyValue /// instanceKeyValue = keyValue *( "," keyValue ) /// keyValue = propertyName "=" literalValue /// /// </remarks> internal static ReferenceTypeValueAst Parse(ParserStream stream) { var node = new ReferenceTypeValueAst(); // referenceValue = objectPathValue node.Name = stream.Read <AliasIdentifierToken>().Name; return(node); }
/// <summary> /// </summary> /// <param name="stream"></param> /// <returns></returns> /// <remarks> /// /// See http://www.dmtf.org/sites/default/files/standards/documents/DSP0221_3.0.0.pdf /// /// Section A.17.7 - Null value /// /// nullValue = NULL /// NULL = "null" ; keyword: case insensitive /// ; second /// /// </remarks> internal new static NullValueAst Parse(ParserStream stream) { var token = stream.Read <NullLiteralToken>(); return(new NullValueAst() { Token = token }); }
/// <summary> /// </summary> /// <param name="stream"></param> /// <returns></returns> /// <remarks> /// See http://www.dmtf.org/sites/default/files/standards/documents/DSP0221_3.0.0.pdf /// Section A.2 - MOF specification /// /// mofProduction = compilerDirective / /// structureDeclaration / /// classDeclaration / /// associationDeclaration / /// enumerationDeclaration / /// instanceDeclaration / /// qualifierDeclaration /// /// </remarks> internal static MofProductionAst Parse(ParserStream stream) { var peek = stream.Peek(); // compilerDirective var pragma = peek as PragmaToken; if (pragma != null) { return(CompilerDirectiveAst.Parse(stream)); } // all other mofProduction structures can start with an optional qualifierList var qualifiers = default(QualifierListAst); if (peek is AttributeOpenToken) { qualifiers = QualifierListAst.Parse(stream); } var identifier = stream.Peek <IdentifierToken>(); switch (identifier.GetNormalizedName()) { case Keywords.STRUCTURE: // structureDeclaration throw new UnsupportedTokenException(identifier); case Keywords.CLASS: // classDeclaration var @class = ClassDeclarationAst.Parse(stream, qualifiers); return(@class); case Keywords.ASSOCIATION: // associationDeclaration throw new UnsupportedTokenException(identifier); case Keywords.ENUMERATION: // enumerationDeclaration throw new UnsupportedTokenException(identifier); case Keywords.INSTANCE: case Keywords.VALUE: // instanceDeclaration var instance = ComplexTypeValueAst.Parse(stream, qualifiers); return(instance); case Keywords.QUALIFIER: // qualifierDeclaration throw new UnsupportedTokenException(identifier); default: throw new UnexpectedTokenException(peek); } #endregion }
/// <summary> /// </summary> /// <param name="stream"></param> /// <returns></returns> /// <remarks> /// /// See http://www.dmtf.org/sites/default/files/standards/documents/DSP0221_3.0.0.pdf /// Section A.2 - MOF specification /// /// mofSpecification = *mofProduction /// mofProduction = compilerDirective / /// structureDeclaration / /// classDeclaration / /// associationDeclaration / /// enumerationDeclaration / /// instanceDeclaration / /// qualifierDeclaration /// /// </remarks> internal static MofSpecificationAst Parse(ParserStream stream) { var specification = new MofSpecificationAst(); while (!stream.Eof) { var production = MofProductionAst.Parse(stream); specification.Productions.Add(production); } return specification; }
/// <summary> /// </summary> /// <param name="stream"></param> /// <returns></returns> /// <remarks> /// See http://www.dmtf.org/sites/default/files/standards/documents/DSP0221_3.0.0.pdf /// A.17.6 Boolean value /// /// booleanValue = TRUE / FALSE /// FALSE = "false" ; keyword: case insensitive /// TRUE = "true" ; keyword: case insensitive /// /// </remarks> internal new static BooleanValueAst Parse(ParserStream stream) { var token = stream.Read <BooleanLiteralToken>(); return(new BooleanValueAst { Token = token, Value = token.Value }); }
public static AstNode Parse(List<Token> lexerTokens) { // remove all comments and whitespace var tokens = lexerTokens.Where(lt => !(lt is MultilineCommentToken) && !(lt is WhitespaceToken)).ToList(); var stream = new ParserStream(tokens); var program = MofSpecificationAst.Parse(stream); return program; }
/// <summary> /// </summary> /// <param name="stream"></param> /// <returns></returns> /// <remarks> /// See http://www.dmtf.org/sites/default/files/standards/documents/DSP0221_3.0.0.pdf /// Section A.2 - MOF specification /// /// mofSpecification = *mofProduction /// /// </remarks> internal static MofSpecificationAst Parse(ParserStream stream) { var specification = new MofSpecificationAst(); while (!stream.Eof) { var production = MofProductionAst.Parse(stream); specification.Productions.Add(production); } return(specification); }
internal new static CompilerDirectiveAst Parse(ParserStream stream) { var ast = new CompilerDirectiveAst(); stream.Read <PragmaToken>(); ast.Pragma = stream.Read <IdentifierToken>().Name; stream.Read <ParenthesesOpenToken>(); ast.Argument = stream.Read <StringLiteralToken>().Value; stream.Read <ParenthesesCloseToken>(); return(ast); }
internal static new PragmaAst Parse(ParserStream stream) { var ast = new PragmaAst(); stream.Read<PragmaToken>(); ast.Pragma = stream.Read<IdentifierToken>().Name; stream.Read<OpenParenthesesToken>(); ast.Argument = stream.Read<StringLiteralToken>().Value; stream.Read<CloseParenthesesToken>(); return ast; }
/// <summary> /// </summary> /// <returns></returns> /// <remarks> /// See http://www.dmtf.org/sites/default/files/standards/documents/DSP0221_3.0.0a.pdf /// A.5 Class declaration /// /// classDeclaration = [ qualifierList ] CLASS className [ superClass ] /// "{" *classFeature "}" ";" /// /// className = elementName /// superClass = ":" className /// classFeature = structureFeature / /// methodDeclaration /// CLASS = "class" ; keyword: case insensitive /// /// </remarks> internal static ClassDeclarationAst ParseClassAst(ParserStream stream, QualifierListAst qualifiers) { var node = new ClassDeclarationAst(); // [ qualifierList ] node.Qualifiers = qualifiers; // CLASS stream.ReadIdentifier(Keywords.CLASS); // className var className = stream.Read <IdentifierToken>(); if (!StringValidator.IsClassName(className.Name)) { throw new InvalidOperationException("Identifer is not a valid class name."); } node.ClassName = className; // [ superClass ] if (stream.Peek <ColonToken>() != null) { stream.Read <ColonToken>(); var superclass = stream.Read <IdentifierToken>(); if (!StringValidator.IsClassName(className.Name)) { throw new InvalidOperationException("Identifer is not a valid superclass name."); } node.Superclass = superclass; } // "{" stream.Read <BlockOpenToken>(); // *classFeature while (!stream.Eof) { var peek = stream.Peek() as BlockCloseToken; if (peek != null) { break; } var classFeature = ClassFeatureAst.Parse(stream); node.Features.Add(classFeature); } // "}" ";" stream.Read <BlockCloseToken>(); stream.Read <StatementEndToken>(); return(node); }
static void Main(string[] args) { var uriDatabase = new UriDatabase(); var errorDatabase = new MemoryDatabase<string, long>(); GenerateReport(uriDatabase.SoftDump(), errorDatabase.ToDictionary()); var feeder = new FeedStream<ThreadedWorker>(); feeder.Feed(args.Skip(1).Select(s => new Uri(s))); var requesters = new List<HttpRequestStream<ThreadedWorker>>(); for (int i = 0; i < int.Parse(args.ElementAt(0)); i++) { requesters.Add(new HttpRequestStream<ThreadedWorker>(uriDatabase)); } var funnel = new FunnelStream<ContentLoad, Uri, ThreadedWorker>(); var parser = new ParserStream<ThreadedWorker>(); feeder.ReturnFeed = parser; parser.ReturnFeed = funnel; requesters.ForEach(stream => stream.ReturnFeed = feeder); funnel.ReturnFeeds = requesters; feeder.OnError += (sender, eventArgs) => CollectError(errorDatabase, eventArgs.GetException()); parser.OnError += (sender, eventArgs) => CollectError(errorDatabase, eventArgs.GetException()); funnel.OnError += (sender, eventArgs) => CollectError(errorDatabase, eventArgs.GetException()); requesters.ForEach(stream => stream.OnError += (sender, eventArgs) => CollectError(errorDatabase, eventArgs.GetException())); parser.Start(); funnel.Start(); requesters.ForEach(stream => stream.Start()); feeder.Start(); var timer = new Timer(2000); timer.Elapsed += (sender, eventArgs) => { var dump = uriDatabase.SoftDump(); var errors = errorDatabase.ToDictionary(); GenerateReport(dump, errors); }; timer.Start(); Console.ReadLine(); }
/// <summary> /// /// </summary> /// <param name="stream"></param> /// <returns></returns> /// <remarks> /// /// primitiveTypeValue = literalValue / literalValueArray /// /// literalValueArray = "{" [ literalValue *( "," literalValue ) ] "}" /// /// literalValue = integerValue / realValue / /// stringValue / octetStringValue /// booleanValue / /// nullValue / /// dateTimeValue /// /// </remarks> internal static PrimitiveTypeValueAst Parse(ParserStream stream) { var peek = stream.Peek(); // primitiveTypeValue = literalValue / literalValueArray if (LiteralValueAst.IsLiteralValueToken(peek)) { // primitiveTypeValue return LiteralValueAst.Parse(stream); } else { throw new InvalidOperationException(); } }
/// <summary> /// </summary> /// <param name="stream"></param> /// <returns></returns> /// <remarks> /// /// See http://www.dmtf.org/sites/default/files/standards/documents/DSP0221_3.0.0.pdf /// Section A.2 - MOF specification /// /// mofSpecification = *mofProduction /// mofProduction = compilerDirective / /// structureDeclaration / /// classDeclaration / /// associationDeclaration / /// enumerationDeclaration / /// instanceDeclaration / /// qualifierDeclaration /// /// </remarks> internal static MofProductionAst Parse(ParserStream stream) { var peek = stream.Peek(); var identifier = peek as IdentifierToken; var pragma = peek as PragmaToken; var attribute = peek as AttributeOpenToken; if (identifier != null && (identifier.Name == "instance" || identifier.Name == "value")) { return ComplexTypeValueAst.Parse(stream, null); } else if (identifier != null && identifier.Name == "class") { return ClassAst.Parse(stream); } else if (pragma != null) { return PragmaAst.Parse(stream); } else if (attribute != null) { var qualifiers = QualifierListAst.Parse(stream); peek = stream.Peek(); identifier = peek as IdentifierToken; if (identifier != null && (identifier.Name == "instance" || identifier.Name == "value")) { return ComplexTypeValueAst.Parse(stream, qualifiers); } else if (identifier != null && identifier.Name == "class") { return ClassAst.Parse(stream); } else { throw new InvalidOperationException( string.Format("Invalid lexer token '{0}'", peek)); } } else { throw new InvalidOperationException( string.Format("Invalid lexer token '{0}'", peek)); } }
public void PeekCharIs() { using (var sr = new StringReader("abcd")) { var ps = new ParserStream(sr); ps.Next(); ps.Peek(); ps.PeekCharIs('d').Should().BeTrue(); ps.Current.Should().Be('b'); ps.CurrentPeek.Should().Be('c'); ps.SkipToPeek(); ps.Current.Should().Be('c'); } }
/// <summary> /// </summary> /// <returns></returns> /// <remarks> /// /// See http://www.dmtf.org/sites/default/files/standards/documents/DSP0221_3.0.0a.pdf /// A.14 Complex type value /// /// complexTypeValue = complexValue / complexValueArray /// complexValueArray = "{" [ complexValue *( "," complexValue) ] "}" /// complexValue = ( INSTANCE / VALUE ) OF /// ( structureName / className / associationName ) /// [ alias ] propertyValueList ";" /// propertyValueList = "{" *propertySlot "}" /// propertySlot = propertyName "=" propertyValue ";" /// propertyValue = primitiveTypeValue / complexTypeValue / referenceTypeValue / enumTypeValue /// alias = AS aliasIdentifier /// INSTANCE = "instance" ; keyword: case insensitive /// VALUE = "value" ; keyword: case insensitive /// AS = "as" ; keyword: case insensitive /// OF = "of" ; keyword: case insensitive /// /// propertyName = IDENTIFIER /// /// </remarks> internal static new ComplexValueArrayAst Parse(ParserStream stream) { // complexValueArray = var node = new ComplexValueArrayAst(); // "{" stream.Read<BlockOpenToken>(); // [ complexValue node.Values.Add(ComplexValueAst.Parse(stream)); // *( "," complexValue) ] while (stream.Peek<CommaToken>() != null) { stream.Read<CommaToken>(); node.Values.Add(ComplexValueAst.Parse(stream)); } // "}" stream.Read<BlockCloseToken>(); // return the result return node; }
/// <summary> /// /// </summary> /// <param name="stream"></param> /// <returns></returns> /// <remarks> /// /// See http://www.dmtf.org/sites/default/files/standards/documents/DSP0221_3.0.0a.pdf /// A.17 Primitive type values /// /// primitiveTypeValue = literalValue / literalValueArray /// /// </remarks> internal static PrimitiveTypeValueAst Parse(ParserStream stream) { var peek = stream.Peek(); if (LiteralValueAst.IsLiteralValueToken(peek)) { // literalValue return(LiteralValueAst.Parse(stream)); } else if (peek is BlockOpenToken) { // literalValueArray return(LiteralValueArrayAst.Parse(stream)); } else { throw new UnexpectedTokenException(peek); } }
public void ResetPeek() { using (var sr = new StringReader("abcd")) { var ps = new ParserStream(sr); ps.Next(); ps.Peek(); ps.Peek(); ps.ResetPeek(); ps.Current.Should().Be('b'); ps.CurrentPeek.Should().Be('b'); ps.GetPeekIndex().Should().Be(1); ps.GetIndex().Should().Be(1); ps.Peek(); ps.Current.Should().Be('b'); ps.CurrentPeek.Should().Be('c'); ps.GetPeekIndex().Should().Be(2); ps.GetIndex().Should().Be(1); ps.Peek(); ps.Peek(); ps.Peek(); ps.ResetPeek(); ps.Current.Should().Be('b'); ps.CurrentPeek.Should().Be('b'); ps.GetPeekIndex().Should().Be(1); ps.GetIndex().Should().Be(1); ps.Peek().Should().Be('c'); ps.Current.Should().Be('b'); ps.CurrentPeek.Should().Be('c'); ps.GetPeekIndex().Should().Be(2); ps.GetIndex().Should().Be(1); ps.Peek().Should().Be('d'); ps.Peek().Should().Be(ParserStream.Eof); } }
/// <summary> /// </summary> /// <returns></returns> /// <remarks> /// /// See http://www.dmtf.org/sites/default/files/standards/documents/DSP0221_3.0.0a.pdf /// A.14 Complex type value /// /// propertyValue = primitiveTypeValue / complexTypeValue / referenceTypeValue / enumTypeValue /// /// 7.3.5 /// /// primitiveTypeValue = literalValue / literalValueArray /// primitiveType = DT_Integer / DT_Real / DT_STRING / DT_DATETIME / DT_BOOLEAN / DT_OCTETSTRING /// /// A.1 /// /// complexTypeValue = complexValue / complexValueArray /// /// A.19 /// /// referenceTypeValue = referenceValue / referenceValueArray /// referenceValueArray = "{" [ objectPathValue *( "," objectPathValue ) ] 1163 "}" /// /// A.7 /// /// enumTypeValue = enumValue / enumValueArray /// enumDeclaration = enumTypeHeader enumName ":" enumTypeDeclaration ";" /// /// </remarks> internal static PropertyValueAst Parse(ParserStream stream) { var node = new PropertyValueAst(); var peek = stream.Peek(); // propertyValue = primitiveTypeValue / complexTypeValue / referenceTypeValue / enumTypeValue if (LiteralValueAst.IsLiteralValueToken(peek)) { // primitiveTypeValue -> literalValue node.Value = PrimitiveTypeValueAst.Parse(stream); } else if (peek is BlockOpenToken) { // we need to read the subsequent token to work out whether // this is a complexValueArray, literalValueArray, referenceValueArray or enumValueArray stream.Read(); peek = stream.Peek(); if (LiteralValueAst.IsLiteralValueToken(peek)) { // literalValueArray stream.Backtrack(); node.Value = LiteralValueArrayAst.Parse(stream); } else { // complexValueType stream.Backtrack(); node.Value = ComplexValueArrayAst.Parse(stream); } } else if (peek is AliasIdentifierToken) { // referenceTypeValue node.Value = ReferenceTypeValueAst.Parse(stream); } else { throw new UnexpectedTokenException(peek); } // return the result return(node); }
internal static QualifierListAst Parse(ParserStream stream) { var ast = new QualifierListAst(); stream.Read <AttributeOpenToken>(); while (!stream.Eof) { ast.Qualifiers.Add(QualifierDeclarationAst.Parse(stream)); if (stream.Peek <CommaToken>() == null) { break; } stream.Read <CommaToken>(); } stream.Read <AttributeCloseToken>(); return(ast); }
/// <summary> /// </summary> /// <returns></returns> /// <remarks> /// /// See http://www.dmtf.org/sites/default/files/standards/documents/DSP0221_3.0.0a.pdf /// A.14 Complex type value /// /// complexValueArray = "{" [ complexValue *( "," complexValue) ] "}" /// /// </remarks> internal new static ComplexValueArrayAst Parse(ParserStream stream) { // complexValueArray = var node = new ComplexValueArrayAst(); // "{" stream.Read <BlockOpenToken>(); // [ complexValue node.Values.Add(ComplexValueAst.Parse(stream)); // *( "," complexValue) ] while (stream.Peek <CommaToken>() != null) { stream.Read <CommaToken>(); node.Values.Add(ComplexValueAst.Parse(stream)); } // "}" stream.Read <BlockCloseToken>(); // return the result return(node); }
/// <summary> /// </summary> /// <returns></returns> /// <remarks> /// /// See http://www.dmtf.org/sites/default/files/standards/documents/DSP0221_3.0.0a.pdf /// A.14 Complex type value /// /// complexTypeValue = complexValue / complexValueArray /// complexValueArray = "{" [ complexValue *( "," complexValue) ] "}" /// complexValue = ( INSTANCE / VALUE ) OF /// ( structureName / className / associationName ) /// [ alias ] propertyValueList ";" /// propertyValueList = "{" *propertySlot "}" /// propertySlot = propertyName "=" propertyValue ";" /// propertyValue = primitiveTypeValue / complexTypeValue / referenceTypeValue / enumTypeValue /// alias = AS aliasIdentifier /// INSTANCE = "instance" ; keyword: case insensitive /// VALUE = "value" ; keyword: case insensitive /// AS = "as" ; keyword: case insensitive /// OF = "of" ; keyword: case insensitive /// /// propertyName = IDENTIFIER /// /// </remarks> internal static PropertyValueAst Parse(ParserStream stream) { var node = new PropertyValueAst(); var peek = stream.Peek(); // propertyValue = primitiveTypeValue / complexTypeValue / referenceTypeValue / enumTypeValue if (LiteralValueAst.IsLiteralValueToken(peek)) { // primitiveTypeValue -> literalValue node.Value = PrimitiveTypeValueAst.Parse(stream); } else if (peek is BlockOpenToken) { // we need to read the subsequent token to work out whether // this is a complexValueArray or a literalValueArray stream.Read(); peek = stream.Peek(); if (LiteralValueAst.IsLiteralValueToken(peek)) { // literalValueArray stream.Backtrack(); node.Value = LiteralValueArrayAst.Parse(stream); } else { // complexValueType stream.Backtrack(); node.Value = ComplexValueArrayAst.Parse(stream); } } else if (peek is AliasIdentifierToken) { // referenceTypeValue node.Value = ReferenceTypeValue.Parse(stream); } else { throw new InvalidOperationException(); } // return the result return node; }
/// <summary> /// </summary> /// <returns></returns> /// <remarks> /// See http://www.dmtf.org/sites/default/files/standards/documents/DSP0221_3.0.0a.pdf /// A.5 Class declaration /// /// classFeature = structureFeature / methodDeclaration /// /// structureFeature = structureDeclaration / ; local structure /// enumDeclaration / ; local enumeration /// propertyDeclaration /// /// structureDeclaration = [ qualifierList ] STRUCTURE structureName /// [ superstructure ] /// "{" *structureFeature "}" ";" /// /// enumDeclaration = enumTypeHeader /// enumName ":" enumTypeDeclaration ";" /// enumTypeHeader = [ qualifierList ] ENUMERATION /// /// propertyDeclaration = [ qualifierList ] ( primitivePropertyDeclaration / /// complexPropertyDeclaration / /// enumPropertyDeclaration /// referencePropertyDeclaration ) ";" /// /// methodDeclaration = [ qualifierList ] ( ( returnDataType [ array ] ) / /// VOID ) methodName /// "(" [ parameterList ] ")" ";" /// /// </remarks> internal static ClassFeatureAst Parse(ParserStream stream) { // all classFeatures start with an optional "[ qualifierList ]" var qualifierList = default(QualifierListAst); var peek = stream.Peek() as AttributeOpenToken; if ((peek as AttributeOpenToken) != null) { qualifierList = QualifierListAst.Parse(stream); } // we now need to work out if it's a structureDeclaration, enumDeclaration, // propertyDeclaration or methodDeclaration var identifier = stream.Peek <IdentifierToken>(); var identifierName = identifier.GetNormalizedName(); if (identifier == null) { throw new UnexpectedTokenException(peek); } else if (identifierName == Keywords.STRUCTURE) { // structureDeclaration throw new UnsupportedTokenException(identifier); } else if (identifierName == Keywords.ENUMERATION) { // enumDeclaration throw new UnsupportedTokenException(identifier); } else { // propertyDeclaration or methodDeclaration return(ClassFeatureAst.ParseMemberDeclaration(stream, qualifierList)); } }
/// <summary> /// /// </summary> /// <param name="stream"></param> /// <returns></returns> /// <remarks> /// /// primitiveTypeValue = literalValue / literalValueArray /// /// literalValueArray = "{" [ literalValue *( "," literalValue ) ] "}" /// /// literalValue = integerValue / realValue / /// stringValue / octetStringValue /// booleanValue / /// nullValue / /// dateTimeValue /// /// </remarks> internal static new LiteralValueAst Parse(ParserStream stream) { // propertyValue = primitiveTypeValue / complexTypeValue / referenceTypeValue / enumTypeValue var peek = stream.Peek(); if (peek is StringLiteralToken) { // primitiveTypeValue return StringValueAst.Parse(stream); } else if (peek is BooleanLiteralToken) { // primitiveTypeValue return BooleanValueAst.Parse(stream); } else if(peek is IntegerLiteralToken) { // primitiveTypeValue return IntegerValueAst.Parse(stream); } else { throw new InvalidOperationException(); } }
/// <summary> /// </summary> /// <returns></returns> /// <remarks> /// /// See http://www.dmtf.org/sites/default/files/standards/documents/DSP0221_3.0.0a.pdf /// A.14 Complex type value /// /// complexTypeValue = complexValue / complexValueArray /// complexValueArray = "{" [ complexValue *( "," complexValue) ] "}" /// complexValue = ( INSTANCE / VALUE ) OF /// ( structureName / className / associationName ) /// [ alias ] propertyValueList ";" /// propertyValueList = "{" *propertySlot "}" /// propertySlot = propertyName "=" propertyValue ";" /// propertyValue = primitiveTypeValue / complexTypeValue / referenceTypeValue / enumTypeValue /// alias = AS aliasIdentifier /// INSTANCE = "instance" ; keyword: case insensitive /// VALUE = "value" ; keyword: case insensitive /// AS = "as" ; keyword: case insensitive /// OF = "of" ; keyword: case insensitive /// /// propertyName = IDENTIFIER /// /// </remarks> internal static new ComplexValueAst Parse(ParserStream stream) { // complexValue = var node = new ComplexValueAst(); // ( INSTANCE / VALUE ) var keyword = stream.ReadKeyword(); switch (keyword.Name) { case "instance": node.IsInstance = true; node.IsValue = false; break; case "value": node.IsInstance = false; node.IsValue = true; break; default: throw new InvalidOperationException(); } // OF stream.ReadKeyword("of"); // ( structureName / className / associationName ) node.TypeName = stream.Read<IdentifierToken>().Name; // [ alias ] if (stream.PeekKeyword("as")) { stream.ReadKeyword("as"); // BUGBUG - PowerShell DSC MOFs allow schema names in an alias identifier //node.Alias = NameValidator.ValidateAliasIdentifier("$" + stream.Read<AliasIdentifierToken>().Name); node.Alias = stream.Read<AliasIdentifierToken>().Name; } // propertyValueList stream.Read<BlockOpenToken>(); while (!stream.Eof && (stream.Peek<BlockCloseToken>() == null)) { // propertyName var propertyName = NameValidator.ValidateIdentifier(stream.Read<IdentifierToken>().Name); // "=" stream.Read<EqualsOperatorToken>(); // propertyValue var propertyValue = PropertyValueAst.Parse(stream); // ";" stream.Read<StatementEndToken>(); node.Properties.Add(propertyName, propertyValue); } // "}" stream.Read<BlockCloseToken>(); // ";" stream.Read<StatementEndToken>(); // return the result return node; }
internal new static ClassDeclarationAst Parse(ParserStream stream) { return(ClassDeclarationAst.ParseClassAst(stream, null)); }
internal static ClassDeclarationAst Parse(ParserStream stream, QualifierListAst qualifiers) { return(ClassDeclarationAst.ParseClassAst(stream, qualifiers)); }
internal static MemberAst Parse(ParserStream stream, QualifierListAst qualifiers) { var type = stream.Read<IdentifierToken>(); bool isRef; if (stream.PeekKeyword("ref")) { stream.ReadKeyword("ref"); isRef = true; } else { isRef = false; } var name = stream.Read<IdentifierToken>(); if (stream.Peek<OpenParenthesesToken>() != null && !isRef) { var ast = new MethodAst { Qualifiers = qualifiers, Name = name.Name, ReturnType = type.Name }; stream.Read<OpenParenthesesToken>(); while (!stream.Eof) { if (stream.Peek<CloseParenthesesToken>() != null) break; QualifierListAst argQualifiers = null; if (stream.Peek<AttributeOpenToken>() != null) { argQualifiers = QualifierListAst.Parse(stream); } var argument = new MethodAst.Argument { Qualifiers = argQualifiers }; argument.Type = stream.Read<IdentifierToken>().Name; if (stream.PeekKeyword("ref")) { stream.ReadKeyword("ref"); argument.IsRef = true; } else { argument.IsRef = false; } argument.Name = stream.Read<IdentifierToken>().Name; if (stream.Peek<AttributeOpenToken>() != null) { stream.Read<AttributeOpenToken>(); stream.Read<AttributeCloseToken>(); } if (stream.Peek<EqualsOperatorToken>() != null) { stream.Read<EqualsOperatorToken>(); argument.DefaultValue = LiteralValueAst.Parse(stream); } ast.Arguments.Add(argument); if (stream.Peek<CommaToken>() == null) break; stream.Read<CommaToken>(); } stream.Read<CloseParenthesesToken>(); stream.Read<StatementEndToken>(); return ast; } else { var ast = new FieldAst { Qualifiers = qualifiers, Name = name.Name, Type = type.Name, IsRef = isRef }; if (stream.Peek<AttributeOpenToken>() != null) { stream.Read<AttributeOpenToken>(); stream.Read<AttributeCloseToken>(); ast.IsArray = true; } if (stream.Peek<EqualsOperatorToken>() != null) { stream.Read<EqualsOperatorToken>(); ast.Initializer = LiteralValueAst.Parse(stream); } stream.Read<StatementEndToken>(); return ast; } }
/// <summary> /// </summary> /// <returns></returns> /// <remarks> /// /// See http://www.dmtf.org/sites/default/files/standards/documents/DSP0221_3.0.0a.pdf /// A.14 Complex type value /// /// complexValue = ( INSTANCE / VALUE ) OF /// ( structureName / className / associationName ) /// [ alias ] propertyValueList ";" /// propertyValueList = "{" *propertySlot "}" /// propertySlot = propertyName "=" propertyValue ";" /// propertyValue = primitiveTypeValue / complexTypeValue / referenceTypeValue / enumTypeValue /// alias = AS aliasIdentifier /// INSTANCE = "instance" ; keyword: case insensitive /// VALUE = "value" ; keyword: case insensitive /// AS = "as" ; keyword: case insensitive /// OF = "of" ; keyword: case insensitive /// /// propertyName = IDENTIFIER /// /// </remarks> internal new static ComplexValueAst Parse(ParserStream stream) { // complexValue = var node = new ComplexValueAst(); // ( INSTANCE / VALUE ) var keyword = stream.ReadIdentifier(); switch (keyword.GetNormalizedName()) { case Keywords.INSTANCE: node.IsInstance = true; node.IsValue = false; break; case Keywords.VALUE: node.IsInstance = false; node.IsValue = true; break; default: throw new UnexpectedTokenException(keyword); } // OF stream.ReadIdentifier(Keywords.OF); // ( structureName / className / associationName ) node.TypeName = stream.Read <IdentifierToken>().Name; if (!StringValidator.IsStructureName(node.TypeName) && !StringValidator.IsClassName(node.TypeName) && !StringValidator.IsAssociationName(node.TypeName)) { throw new InvalidOperationException("Identifer is not a structureName, className or associationName"); } // [ alias ] if (stream.PeekIdentifier(Keywords.AS)) { stream.ReadIdentifier(Keywords.AS); var aliasName = stream.Read <AliasIdentifierToken>().Name; if (!StringValidator.IsIdentifier(aliasName)) { throw new InvalidOperationException("Value is not a valid aliasIdentifier"); } node.Alias = aliasName; } // propertyValueList stream.Read <BlockOpenToken>(); while (!stream.Eof && (stream.Peek <BlockCloseToken>() == null)) { // propertyName var propertyName = stream.Read <IdentifierToken>().Name; if (!StringValidator.IsIdentifier(propertyName)) { throw new InvalidOperationException("Value is not a valid property name."); } // "=" stream.Read <EqualsOperatorToken>(); // propertyValue var propertyValue = PropertyValueAst.Parse(stream); // ";" stream.Read <StatementEndToken>(); node.Properties.Add(propertyName, propertyValue); } // "}" stream.Read <BlockCloseToken>(); // ";" stream.Read <StatementEndToken>(); // return the result return(node); }
/// <summary> Create a source of characters.</summary> /// <param name="stream">The stream of bytes to use. /// </param> /// <param name="charset">The character set used in encoding the stream. /// </param> /// <param name="size">The initial character buffer size. /// </param> /// <exception cref="UnsupportedEncodingException">If the character set /// is unsupported. /// </exception> public InputStreamSource(System.IO.Stream stream, System.String charset, int size) : base(stream) { if (null == stream) stream = new ParserStream(null); // bug #1044707 mark()/reset() issues else { //UPGRADE_ISSUE: Method 'java.io.InputStream.markSupported' was not converted. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1000_javaioInputStreammarkSupported'" //if (!stream.markSupported()) // wrap the stream so we can reset // stream = new Stream(stream); } // else // just because mark is supported doesn't guarantee // proper reset operation; there is no call to mark // in this code, so if reset misbehaves there is an // appropriate message in setEncoding() to suggest // wraping it in a Stream. // This was deemed better than an attempt to call // reset at this point just to check if we would // succeed later, or to call mark with an arbitrary // lookahead size mStream = stream; if (null == charset || String.Empty == charset) { mReader = new System.IO.StreamReader(stream, System.Text.Encoding.Default); mEncoding = mReader.CurrentEncoding.EncodingName; } else { mEncoding = charset; mReader = new System.IO.StreamReader(stream, System.Text.Encoding.GetEncoding(charset)); } mBuffer = new char[size]; mLevel = 0; mOffset = 0; mMark = - 1; }
/// <summary> /// </summary> /// <returns></returns> /// <remarks> /// See http://www.dmtf.org/sites/default/files/standards/documents/DSP0221_3.0.0a.pdf /// A.10 Property declaration /// Whitespace as defined in 5.2 is allowed between the elements of the rules in this ABNF section. /// /// propertyDeclaration = [ qualifierList ] ( primitivePropertyDeclaration / /// complexPropertyDeclaration / /// enumPropertyDeclaration / /// referencePropertyDeclaration) ";" /// /// primitivePropertyDeclaration = primitiveType propertyName [ array ] /// [ "=" primitiveTypeValue] /// complexPropertyDeclaration = structureOrClassName propertyName [ array ] /// [ "=" ( complexTypeValue / aliasIdentifier ) ] /// enumPropertyDeclaration = enumName propertyName [ array ] /// [ "=" enumTypeValue] /// referencePropertyDeclaration = classReference propertyName [ array ] /// [ "=" referenceTypeValue ] /// /// array = "[" "]" /// propertyName = IDENTIFIER /// structureOrClassName = IDENTIFIER /// classReference = DT_REFERENCE /// DT_REFERENCE = className REF /// REF = "ref" ; keyword: case insensitive /// /// A.11 Method declaration /// Whitespace as defined in 5.2 is allowed between the elements of the rules in this ABNF section. /// /// methodDeclaration = [ qualifierList ] ( ( returnDataType [ array ] ) / /// VOID ) methodName /// "(" [ parameterList ] ")" ";" /// /// returnDataType = primitiveType / /// structureOrClassName / /// enumName / /// classReference /// array = "[" "]" /// methodName = IDENTIFIER /// classReference = DT_REFERENCE /// DT_REFERENCE = className REF /// REF = "ref" ; keyword: case insensitive /// VOID = "void" ; keyword: case insensitive /// parameterList = parameterDeclaration *( "," parameterDeclaration ) /// private static ClassFeatureAst ParseMemberDeclaration(ParserStream stream, QualifierListAst qualifiers) { // primitiveType / structureOrClassName / enumName / classReference var returnType = stream.Read <IdentifierToken>(); var @ref = default(IdentifierToken); if (stream.PeekIdentifier(Keywords.REF)) { @ref = stream.ReadIdentifier(Keywords.REF); } // [ array ] var returnTypeIsArray = false; if (stream.Peek <AttributeOpenToken>() != null) { stream.Read <AttributeOpenToken>(); stream.Read <AttributeCloseToken>(); returnTypeIsArray = true; } // propertyName / methodName var memberName = stream.Read <IdentifierToken>(); if ((stream.Peek <ParenthesesOpenToken>() != null) && (@ref == null)) { // read the remainder of a methodDeclaration var ast = new MethodDeclarationAst { Qualifiers = qualifiers, Name = memberName, ReturnType = returnType, ReturnTypeIsArray = returnTypeIsArray }; // "(" stream.Read <ParenthesesOpenToken>(); // [ parameterList ] if (stream.Peek <ParenthesesCloseToken>() == null) { while (!stream.Eof) { if (ast.Parameters.Count > 0) { stream.Read <CommaToken>(); } var parameter = ParameterDeclarationAst.Parse(stream); ast.Parameters.Add(parameter); if (stream.Peek <ParenthesesCloseToken>() != null) { break; } } } // ")" ";" stream.Read <ParenthesesCloseToken>(); stream.Read <StatementEndToken>(); return(ast); } else { // read the remainder of a propertyDeclaration var ast = new PropertyDeclarationAst { Qualifiers = qualifiers, Name = memberName, Type = returnType, IsRef = (@ref != null) }; if (stream.Peek <AttributeOpenToken>() != null) { stream.Read <AttributeOpenToken>(); stream.Read <AttributeCloseToken>(); ast.IsArray = true; } if (stream.Peek <EqualsOperatorToken>() != null) { stream.Read <EqualsOperatorToken>(); ast.Initializer = ClassFeatureAst.ReadDefaultValue(stream, returnType); } stream.Read <StatementEndToken>(); return(ast); } }
private void GetPageContent(HttpProtocol obProtocol, bool bIsRefresh) { if(m_bHasContent && !bIsRefresh) { return; } if(obProtocol == null) { throw new ArgumentNullException("obProtocol", "Null HttpProtocol object specified"); } lock(this) { ParserStream stream = null; System.String type = String.Empty; System.String charset = String.Empty; try { m_obProtocolOutput = obProtocol.GetProtocolOutput(); if (m_obProtocolOutput.Status.Code == HttpProtocolStatus.SUCCESS) { m_bHasContent = true; this.m_HttpContentProperties = m_obProtocolOutput.Content.ContentProperties; type = this.ContentType; charset = GetCharset(type); stream = new ParserStream(new System.IO.MemoryStream(m_obProtocolOutput.Content.ContentData)); } if (null != stream) { mSource = new InputStreamSource(stream,charset,m_obProtocolOutput.Content.ContentData.Length); } } catch (System.Exception e) { throw new ParserException("Failed to get page content", e); } mUrl = obProtocol.URL.ToString(); mIndex = new PageIndex(this); } }