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);
}
}
