private void Push(Token token)
{
_stack.Push(token);
}
private static void AssertTokenKind(TokenKind expected, Token actual)
{
if (null == actual || actual.Kind != expected)
{
UnexpectedToken(expected, actual);
}
}
private static void UnexpectedToken(TokenKind expectedKind, Token actual)
{
throw new ArgumentException(string.Format("Unexpected Token: '{0}' (Expected kind: '{1}')", actual,
expectedKind));
}
private static bool IsInnerGenericTypeReference(Token t)
{
return TokenKind.GenericQualifier == t.Kind;
}
private static bool IsOpenGenericTypeDefinition(Token t)
{
return t.Kind != TokenKind.LBrack;
}
private SimpleTypeReference InternalParseGenericTypeReference(Token id, int count)
{
var argcToken = Expect(TokenKind.Number);
id.Value += "`" + argcToken.Value;
var argc = int.Parse(argcToken.Value);
var t = NextToken();
while (TokenKind.NestedQualifier == t.Kind)
{
var nestedId = Expect(TokenKind.Id);
id.Value += "+" + nestedId.Value;
t = NextToken();
}
if (IsInnerGenericTypeReference(t))
{
return InternalParseGenericTypeReference(id, argc + count);
}
var args = new TypeReference[0];
if (!IsOpenGenericTypeDefinition(t))
{
args = new TypeReference[argc + count];
AssertTokenKind(TokenKind.LBrack, t);
for (var i = 0; i < args.Length; ++i)
{
if (i > 0) Expect(TokenKind.Comma);
Expect(TokenKind.LBrack);
args[i] = Parse();
Expect(TokenKind.RBrack);
}
Expect(TokenKind.RBrack);
}
else
{
Push(t);
}
return new GenericTypeReference(id.Value, args);
}
private SimpleTypeReference ParseGenericTypeReference(Token id)
{
return InternalParseGenericTypeReference(id, 0);
}
private Token TokenFromBuffer(TokenKind kind)
{
Token token = new Token(kind, _buffer.ToString());
_buffer.Length = 0;
return token;
}
