/// <summary>
/// Visits the syntax node.
/// </summary>
/// <param name="parentNode">Node</param>
internal void Visit(PPayloadReceiveNode node)
{
node.PayloadKeyword = base.TokenStream.Peek();
base.TokenStream.Index++;
base.TokenStream.SkipWhiteSpaceAndCommentTokens();
if (base.TokenStream.Done ||
base.TokenStream.Peek().Type != TokenType.As)
{
throw new ParsingException("Expected \"as\".",
new List <TokenType>
{
TokenType.As
});
}
node.AsKeyword = base.TokenStream.Peek();
base.TokenStream.Index++;
base.TokenStream.SkipWhiteSpaceAndCommentTokens();
PBaseType type = null;
new TypeIdentifierVisitor(base.TokenStream).Visit(ref type);
node.Type = type;
if (base.TokenStream.Peek().Type == TokenType.RightParenthesis)
{
node.RightParenthesisToken = base.TokenStream.Peek();
base.TokenStream.Index++;
base.TokenStream.SkipWhiteSpaceAndCommentTokens();
if (base.TokenStream.Peek().Type == TokenType.Dot)
{
node.DotToken = base.TokenStream.Peek();
base.TokenStream.Index++;
base.TokenStream.SkipWhiteSpaceAndCommentTokens();
if (base.TokenStream.Done ||
base.TokenStream.Peek().Type != TokenType.Identifier)
{
throw new ParsingException("Expected index.",
new List <TokenType>
{
TokenType.Identifier
});
}
node.IndexToken = base.TokenStream.Peek();
base.TokenStream.Index++;
base.TokenStream.SkipWhiteSpaceAndCommentTokens();
}
}
}
/// <summary>
/// Visits the syntax node.
/// </summary>
/// <param name="type">Type</param>
public void Visit(ref PSeqType type)
{
type.TypeTokens.Add(base.TokenStream.Peek());
base.TokenStream.Index++;
base.TokenStream.SkipWhiteSpaceAndCommentTokens();
if (base.TokenStream.Done ||
base.TokenStream.Peek().Type != TokenType.LeftSquareBracket)
{
throw new ParsingException("Expected \"[\".",
new List <TokenType>
{
TokenType.LeftSquareBracket
});
}
type.TypeTokens.Add(base.TokenStream.Peek());
base.TokenStream.Index++;
base.TokenStream.SkipWhiteSpaceAndCommentTokens();
PBaseType seqType = null;
new TypeIdentifierVisitor(base.TokenStream).Visit(ref seqType);
type.SeqType = seqType;
if (base.TokenStream.Done ||
base.TokenStream.Peek().Type != TokenType.RightSquareBracket)
{
throw new ParsingException("Expected \"]\".",
new List <TokenType>
{
TokenType.RightSquareBracket
});
}
type.TypeTokens.Add(base.TokenStream.Peek());
}
/// <summary>
/// Visits the syntax node.
/// </summary>
/// <param name="program">Program</param>
/// <param name="parentNode">Node</param>
/// <param name="accMod">Access modifier</param>
internal void Visit(IPSharpProgram program, NamespaceDeclaration parentNode, AccessModifier accMod)
{
var node = new EventDeclaration(base.TokenStream.Program);
node.AccessModifier = accMod;
node.EventKeyword = base.TokenStream.Peek();
base.TokenStream.Index++;
base.TokenStream.SkipWhiteSpaceAndCommentTokens();
if (base.TokenStream.Done ||
(base.TokenStream.Peek().Type != TokenType.Identifier &&
base.TokenStream.Peek().Type != TokenType.HaltEvent &&
base.TokenStream.Peek().Type != TokenType.DefaultEvent))
{
throw new ParsingException("Expected event identifier.",
new List <TokenType>
{
TokenType.Identifier,
TokenType.HaltEvent,
TokenType.DefaultEvent
});
}
if (base.TokenStream.Peek().Type == TokenType.Identifier)
{
base.TokenStream.Swap(new Token(base.TokenStream.Peek().TextUnit,
TokenType.EventIdentifier));
}
node.Identifier = base.TokenStream.Peek();
base.TokenStream.Index++;
base.TokenStream.SkipWhiteSpaceAndCommentTokens();
if (base.TokenStream.Done ||
(base.TokenStream.Peek().Type != TokenType.Assert &&
base.TokenStream.Peek().Type != TokenType.Assume &&
base.TokenStream.Peek().Type != TokenType.Colon &&
base.TokenStream.Peek().Type != TokenType.Semicolon))
{
throw new ParsingException("Expected \":\" or \";\".",
new List <TokenType>
{
TokenType.Assert,
TokenType.Assume,
TokenType.Colon,
TokenType.Semicolon
});
}
if (base.TokenStream.Peek().Type == TokenType.Assert ||
base.TokenStream.Peek().Type == TokenType.Assume)
{
bool isAssert = true;
if (base.TokenStream.Peek().Type == TokenType.Assert)
{
node.AssertKeyword = base.TokenStream.Peek();
}
else
{
node.AssumeKeyword = base.TokenStream.Peek();
isAssert = false;
}
base.TokenStream.Index++;
base.TokenStream.SkipWhiteSpaceAndCommentTokens();
if (base.TokenStream.Done ||
base.TokenStream.Peek().Type != TokenType.Identifier)
{
throw new ParsingException("Expected integer.",
new List <TokenType>
{
TokenType.Identifier
});
}
int value;
if (!int.TryParse(base.TokenStream.Peek().TextUnit.Text, out value))
{
throw new ParsingException("Expected integer.",
new List <TokenType>
{
TokenType.Identifier
});
}
if (isAssert)
{
node.AssertValue = value;
}
else
{
node.AssumeValue = value;
}
base.TokenStream.Index++;
base.TokenStream.SkipWhiteSpaceAndCommentTokens();
if (base.TokenStream.Done ||
(base.TokenStream.Peek().Type != TokenType.Colon &&
base.TokenStream.Peek().Type != TokenType.Semicolon))
{
throw new ParsingException("Expected \":\" or \";\".",
new List <TokenType>
{
TokenType.Colon,
TokenType.Semicolon
});
}
}
if (base.TokenStream.Peek().Type == TokenType.Colon)
{
node.ColonToken = base.TokenStream.Peek();
base.TokenStream.Index++;
base.TokenStream.SkipWhiteSpaceAndCommentTokens();
PBaseType payloadType = null;
new TypeIdentifierVisitor(base.TokenStream).Visit(ref payloadType);
node.PayloadType = payloadType;
}
if (base.TokenStream.Done ||
base.TokenStream.Peek().Type != TokenType.Semicolon)
{
throw new ParsingException("Expected \";\".",
new List <TokenType>
{
TokenType.Semicolon
});
}
node.SemicolonToken = base.TokenStream.Peek();
if (base.TokenStream.Program is PSharpProgram)
{
parentNode.EventDeclarations.Add(node);
}
else
{
(program as PProgram).EventDeclarations.Add(node);
}
}
/// <summary>
/// Visits the syntax node.
/// </summary>
/// <param name="parentNode">Node</param>
/// <param name="isModel">Is model</param>
internal void Visit(MachineDeclaration parentNode, bool isModel)
{
var node = new PFunctionDeclaration(base.TokenStream.Program,
parentNode.IsModel || isModel);
if (isModel)
{
base.TokenStream.Index++;
base.TokenStream.SkipWhiteSpaceAndCommentTokens();
if (base.TokenStream.Done ||
base.TokenStream.Peek().Type != TokenType.FunDecl)
{
throw new ParsingException("Expected function declaration.",
new List <TokenType>
{
TokenType.FunDecl
});
}
}
node.FunctionKeyword = base.TokenStream.Peek();
base.TokenStream.Index++;
base.TokenStream.SkipWhiteSpaceAndCommentTokens();
if (base.TokenStream.Done ||
base.TokenStream.Peek().Type != TokenType.Identifier)
{
throw new ParsingException("Expected identifier.",
new List <TokenType>
{
TokenType.Identifier
});
}
node.Identifier = base.TokenStream.Peek();
base.TokenStream.Index++;
base.TokenStream.SkipWhiteSpaceAndCommentTokens();
if (base.TokenStream.Done ||
base.TokenStream.Peek().Type != TokenType.LeftParenthesis)
{
throw new ParsingException("Expected \"(\".",
new List <TokenType>
{
TokenType.LeftParenthesis
});
}
node.LeftParenthesisToken = base.TokenStream.Peek();
base.TokenStream.Index++;
base.TokenStream.SkipWhiteSpaceAndCommentTokens();
bool expectsColon = false;
bool expectsType = false;
bool expectsComma = false;
while (!base.TokenStream.Done &&
base.TokenStream.Peek().Type != TokenType.RightParenthesis)
{
if ((!expectsColon && !expectsComma && !expectsType &&
base.TokenStream.Peek().Type != TokenType.Identifier) ||
(!expectsColon && !expectsComma && expectsType &&
base.TokenStream.Peek().Type != TokenType.MachineDecl &&
base.TokenStream.Peek().Type != TokenType.Int &&
base.TokenStream.Peek().Type != TokenType.Bool &&
base.TokenStream.Peek().Type != TokenType.Seq &&
base.TokenStream.Peek().Type != TokenType.Map &&
base.TokenStream.Peek().Type != TokenType.LeftParenthesis) ||
(expectsColon && base.TokenStream.Peek().Type != TokenType.Colon) ||
(expectsComma && base.TokenStream.Peek().Type != TokenType.Comma))
{
break;
}
if (!expectsType &&
base.TokenStream.Peek().Type == TokenType.Identifier)
{
node.Parameters.Add(base.TokenStream.Peek());
base.TokenStream.Index++;
base.TokenStream.SkipWhiteSpaceAndCommentTokens();
expectsColon = true;
}
else if (base.TokenStream.Peek().Type == TokenType.Colon)
{
base.TokenStream.Index++;
base.TokenStream.SkipWhiteSpaceAndCommentTokens();
expectsColon = false;
expectsType = true;
}
else if (expectsType &&
(base.TokenStream.Peek().Type == TokenType.MachineDecl ||
base.TokenStream.Peek().Type == TokenType.Int ||
base.TokenStream.Peek().Type == TokenType.Bool ||
base.TokenStream.Peek().Type == TokenType.Seq ||
base.TokenStream.Peek().Type == TokenType.Map ||
base.TokenStream.Peek().Type == TokenType.LeftParenthesis))
{
PBaseType type = null;
new TypeIdentifierVisitor(base.TokenStream).Visit(ref type);
node.ParameterTypes.Add(type);
expectsType = false;
expectsComma = true;
}
else if (base.TokenStream.Peek().Type == TokenType.Comma)
{
base.TokenStream.Index++;
base.TokenStream.SkipWhiteSpaceAndCommentTokens();
expectsComma = false;
}
}
node.RightParenthesisToken = base.TokenStream.Peek();
base.TokenStream.Index++;
base.TokenStream.SkipWhiteSpaceAndCommentTokens();
if (base.TokenStream.Done ||
(base.TokenStream.Peek().Type != TokenType.Colon &&
base.TokenStream.Peek().Type != TokenType.LeftSquareBracket &&
base.TokenStream.Peek().Type != TokenType.LeftCurlyBracket))
{
throw new ParsingException("Expected \":\" or \"{\".",
new List <TokenType>
{
TokenType.Colon,
TokenType.LeftCurlyBracket
});
}
if (base.TokenStream.Peek().Type == TokenType.Colon)
{
node.ColonToken = base.TokenStream.Peek();
base.TokenStream.Index++;
base.TokenStream.SkipWhiteSpaceAndCommentTokens();
PBaseType type = null;
new TypeIdentifierVisitor(base.TokenStream).Visit(ref type);
node.ReturnType = type;
}
if (base.TokenStream.Peek().Type == TokenType.LeftSquareBracket)
{
while (!base.TokenStream.Done &&
base.TokenStream.Peek().Type != TokenType.LeftCurlyBracket)
{
base.TokenStream.Index++;
base.TokenStream.SkipWhiteSpaceAndCommentTokens();
}
}
if (base.TokenStream.Done ||
base.TokenStream.Peek().Type != TokenType.LeftCurlyBracket)
{
throw new ParsingException("Expected \"{\".",
new List <TokenType>
{
TokenType.LeftCurlyBracket
});
}
var blockNode = new BlockSyntax(base.TokenStream.Program, parentNode,
null, node.IsModel);
new BlockSyntaxVisitor(base.TokenStream).Visit(blockNode);
node.StatementBlock = blockNode;
parentNode.FunctionDeclarations.Add(node);
}
/// <summary>
/// Visits the syntax node
/// </summary>
/// <param name="type">Type</param>
public void Visit(ref PTupleType type)
{
type.TypeTokens.Add(base.TokenStream.Peek());
base.TokenStream.Index++;
base.TokenStream.SkipWhiteSpaceAndCommentTokens();
if (base.TokenStream.Done ||
(base.TokenStream.Peek().Type != TokenType.MachineDecl &&
base.TokenStream.Peek().Type != TokenType.Int &&
base.TokenStream.Peek().Type != TokenType.Bool &&
base.TokenStream.Peek().Type != TokenType.Seq &&
base.TokenStream.Peek().Type != TokenType.Map &&
base.TokenStream.Peek().Type != TokenType.Any &&
base.TokenStream.Peek().Type != TokenType.EventDecl &&
base.TokenStream.Peek().Type != TokenType.LeftParenthesis &&
base.TokenStream.Peek().Type != TokenType.Identifier))
{
throw new ParsingException("Expected type.",
new List<TokenType>
{
TokenType.MachineDecl,
TokenType.Int,
TokenType.Bool,
TokenType.Seq,
TokenType.Map,
TokenType.Any,
TokenType.EventDecl
});
}
bool isNamed = false;
bool expectsName = false;
if (base.TokenStream.Peek().Type == TokenType.Identifier)
{
isNamed = true;
expectsName = true;
}
bool expectsComma = false;
while (!base.TokenStream.Done &&
base.TokenStream.Peek().Type != TokenType.RightParenthesis)
{
if ((!expectsComma && !expectsName &&
base.TokenStream.Peek().Type != TokenType.MachineDecl &&
base.TokenStream.Peek().Type != TokenType.Int &&
base.TokenStream.Peek().Type != TokenType.Bool &&
base.TokenStream.Peek().Type != TokenType.Seq &&
base.TokenStream.Peek().Type != TokenType.Map &&
base.TokenStream.Peek().Type != TokenType.Any &&
base.TokenStream.Peek().Type != TokenType.EventDecl &&
base.TokenStream.Peek().Type != TokenType.LeftParenthesis) ||
(expectsName && base.TokenStream.Peek().Type != TokenType.Identifier) ||
(expectsComma && base.TokenStream.Peek().Type != TokenType.Comma))
{
break;
}
if (base.TokenStream.Peek().Type == TokenType.MachineDecl ||
base.TokenStream.Peek().Type == TokenType.Int ||
base.TokenStream.Peek().Type == TokenType.Bool ||
base.TokenStream.Peek().Type == TokenType.Seq ||
base.TokenStream.Peek().Type == TokenType.Map ||
base.TokenStream.Peek().Type == TokenType.Any ||
base.TokenStream.Peek().Type == TokenType.EventDecl ||
base.TokenStream.Peek().Type == TokenType.LeftParenthesis)
{
PBaseType tupleType = null;
new TypeIdentifierVisitor(base.TokenStream).Visit(ref tupleType);
type.TupleTypes.Add(tupleType);
expectsComma = true;
}
else if (base.TokenStream.Peek().Type == TokenType.Identifier)
{
type.NameTokens.Add(base.TokenStream.Peek());
base.TokenStream.Index++;
base.TokenStream.SkipWhiteSpaceAndCommentTokens();
if (base.TokenStream.Done ||
(base.TokenStream.Peek().Type != TokenType.Colon))
{
throw new ParsingException("Expected \":\".",
new List<TokenType>
{
TokenType.Colon
});
}
base.TokenStream.Index++;
base.TokenStream.SkipWhiteSpaceAndCommentTokens();
expectsName = false;
}
else if (base.TokenStream.Peek().Type == TokenType.Comma)
{
type.TypeTokens.Add(base.TokenStream.Peek());
base.TokenStream.Index++;
base.TokenStream.SkipWhiteSpaceAndCommentTokens();
expectsComma = false;
if (isNamed)
{
expectsName = true;
}
}
}
if (base.TokenStream.Done ||
base.TokenStream.Peek().Type != TokenType.RightParenthesis)
{
throw new ParsingException("Expected \")\".",
new List<TokenType>
{
TokenType.RightParenthesis
});
}
type.TypeTokens.Add(base.TokenStream.Peek());
}
/// <summary>
/// Visits the type.
/// </summary>
/// <param name="type">Type</param>
public void Visit(ref PBaseType type)
{
if (base.TokenStream.Done ||
(base.TokenStream.Peek().Type != TokenType.MachineDecl &&
base.TokenStream.Peek().Type != TokenType.Int &&
base.TokenStream.Peek().Type != TokenType.Bool &&
base.TokenStream.Peek().Type != TokenType.Seq &&
base.TokenStream.Peek().Type != TokenType.Map &&
base.TokenStream.Peek().Type != TokenType.Any &&
base.TokenStream.Peek().Type != TokenType.EventDecl &&
base.TokenStream.Peek().Type != TokenType.LeftParenthesis))
{
throw new ParsingException("Expected type.",
new List <TokenType>
{
TokenType.MachineDecl,
TokenType.Int,
TokenType.Bool,
TokenType.Seq,
TokenType.Map,
TokenType.Any,
TokenType.EventDecl
});
}
if (base.TokenStream.Peek().Type == TokenType.MachineDecl)
{
base.TokenStream.Swap(new Token(new TextUnit("MachineId", base.TokenStream.
Peek().TextUnit.Line), TokenType.MachineDecl));
type = new PBaseType(PType.Machine);
type.TypeTokens.Add(base.TokenStream.Peek());
}
else if (base.TokenStream.Peek().Type == TokenType.Int)
{
type = new PBaseType(PType.Int);
type.TypeTokens.Add(base.TokenStream.Peek());
}
else if (base.TokenStream.Peek().Type == TokenType.Bool)
{
type = new PBaseType(PType.Bool);
type.TypeTokens.Add(base.TokenStream.Peek());
}
else if (base.TokenStream.Peek().Type == TokenType.Any)
{
type = new PBaseType(PType.Any);
type.TypeTokens.Add(base.TokenStream.Peek());
}
else if (base.TokenStream.Peek().Type == TokenType.EventDecl)
{
type = new PBaseType(PType.Event);
type.TypeTokens.Add(base.TokenStream.Peek());
}
else if (base.TokenStream.Peek().Type == TokenType.Seq)
{
var seqType = new PSeqType();
new SeqTypeIdentifierVisitor(base.TokenStream).Visit(ref seqType);
type = seqType;
}
else if (base.TokenStream.Peek().Type == TokenType.Map)
{
var mapType = new PMapType();
new MapTypeIdentifierVisitor(base.TokenStream).Visit(ref mapType);
type = mapType;
}
else if (base.TokenStream.Peek().Type == TokenType.LeftParenthesis)
{
var tupleType = new PTupleType();
new TupleTypeIdentifierVisitor(base.TokenStream).Visit(ref tupleType);
type = tupleType;
}
base.TokenStream.Index++;
base.TokenStream.SkipWhiteSpaceAndCommentTokens();
}
/// <summary>
/// Visits the syntax node.
/// </summary>
/// <param name="parentNode">Node</param>
internal void Visit(MachineDeclaration parentNode)
{
var nodes = new List <PFieldDeclaration>();
var fieldKeyword = base.TokenStream.Peek();
base.TokenStream.Index++;
base.TokenStream.SkipWhiteSpaceAndCommentTokens();
if (base.TokenStream.Done ||
base.TokenStream.Peek().Type != TokenType.Identifier)
{
throw new ParsingException("Expected identifier.",
new List <TokenType>
{
TokenType.Identifier
});
}
nodes.Add(new PFieldDeclaration(base.TokenStream.Program, parentNode,
parentNode.IsModel));
nodes[nodes.Count - 1].FieldKeyword = fieldKeyword;
nodes[nodes.Count - 1].Identifier = base.TokenStream.Peek();
base.TokenStream.Index++;
base.TokenStream.SkipWhiteSpaceAndCommentTokens();
bool expectsComma = true;
while (!base.TokenStream.Done &&
base.TokenStream.Peek().Type != TokenType.Colon)
{
if ((!expectsComma &&
base.TokenStream.Peek().Type != TokenType.Identifier) ||
(expectsComma && base.TokenStream.Peek().Type != TokenType.Comma))
{
break;
}
if (base.TokenStream.Peek().Type == TokenType.Identifier)
{
nodes.Add(new PFieldDeclaration(base.TokenStream.Program, parentNode,
parentNode.IsModel));
nodes[nodes.Count - 1].FieldKeyword = fieldKeyword;
nodes[nodes.Count - 1].Identifier = base.TokenStream.Peek();
base.TokenStream.Index++;
base.TokenStream.SkipWhiteSpaceAndCommentTokens();
expectsComma = true;
}
else if (base.TokenStream.Peek().Type == TokenType.Comma)
{
base.TokenStream.Index++;
base.TokenStream.SkipWhiteSpaceAndCommentTokens();
expectsComma = false;
}
}
if (base.TokenStream.Done ||
base.TokenStream.Peek().Type != TokenType.Colon)
{
throw new ParsingException("Expected \":\".",
new List <TokenType>
{
TokenType.Colon
});
}
foreach (var node in nodes)
{
node.ColonToken = base.TokenStream.Peek();
}
base.TokenStream.Index++;
base.TokenStream.SkipWhiteSpaceAndCommentTokens();
PBaseType type = null;
new TypeIdentifierVisitor(base.TokenStream).Visit(ref type);
foreach (var node in nodes)
{
node.Type = type;
}
if (base.TokenStream.Done ||
base.TokenStream.Peek().Type != TokenType.Semicolon)
{
throw new ParsingException("Expected \";\".",
new List <TokenType>
{
TokenType.Semicolon
});
}
foreach (var node in nodes)
{
node.SemicolonToken = base.TokenStream.Peek();
parentNode.FieldDeclarations.Add(node);
}
}
/// <summary>
/// Visits the syntax node.
/// </summary>
/// <param name="type">Type</param>
public void Visit(ref PMapType type)
{
type.TypeTokens.Add(base.TokenStream.Peek());
base.TokenStream.Index++;
base.TokenStream.SkipWhiteSpaceAndCommentTokens();
if (base.TokenStream.Done ||
base.TokenStream.Peek().Type != TokenType.LeftSquareBracket)
{
throw new ParsingException("Expected \"[\".",
new List <TokenType>
{
TokenType.LeftSquareBracket
});
}
type.TypeTokens.Add(base.TokenStream.Peek());
base.TokenStream.Index++;
base.TokenStream.SkipWhiteSpaceAndCommentTokens();
if (base.TokenStream.Done ||
(base.TokenStream.Peek().Type != TokenType.MachineDecl &&
base.TokenStream.Peek().Type != TokenType.Int &&
base.TokenStream.Peek().Type != TokenType.Bool &&
base.TokenStream.Peek().Type != TokenType.Seq &&
base.TokenStream.Peek().Type != TokenType.Map &&
base.TokenStream.Peek().Type != TokenType.Any &&
base.TokenStream.Peek().Type != TokenType.EventDecl &&
base.TokenStream.Peek().Type != TokenType.LeftParenthesis))
{
throw new ParsingException("Expected \"[\".",
new List <TokenType>
{
TokenType.MachineDecl,
TokenType.Int,
TokenType.Bool,
TokenType.Seq,
TokenType.Map,
TokenType.Any,
TokenType.EventDecl
});
}
PBaseType keyType = null;
new TypeIdentifierVisitor(base.TokenStream).Visit(ref keyType);
type.KeyType = keyType;
if (base.TokenStream.Done ||
base.TokenStream.Peek().Type != TokenType.Comma)
{
throw new ParsingException("Expected \",\".",
new List <TokenType>
{
TokenType.Comma
});
}
base.TokenStream.Index++;
base.TokenStream.SkipWhiteSpaceAndCommentTokens();
if (base.TokenStream.Done ||
(base.TokenStream.Peek().Type != TokenType.MachineDecl &&
base.TokenStream.Peek().Type != TokenType.Int &&
base.TokenStream.Peek().Type != TokenType.Bool &&
base.TokenStream.Peek().Type != TokenType.Seq &&
base.TokenStream.Peek().Type != TokenType.Map &&
base.TokenStream.Peek().Type != TokenType.Any &&
base.TokenStream.Peek().Type != TokenType.EventDecl &&
base.TokenStream.Peek().Type != TokenType.LeftParenthesis))
{
throw new ParsingException("Expected \"[\".",
new List <TokenType>
{
TokenType.MachineDecl,
TokenType.Int,
TokenType.Bool,
TokenType.Seq,
TokenType.Map,
TokenType.Any,
TokenType.EventDecl
});
}
PBaseType valueType = null;
new TypeIdentifierVisitor(base.TokenStream).Visit(ref valueType);
type.ValueType = valueType;
if (base.TokenStream.Done ||
base.TokenStream.Peek().Type != TokenType.RightSquareBracket)
{
throw new ParsingException("Expected \"]\".",
new List <TokenType>
{
TokenType.RightSquareBracket
});
}
type.TypeTokens.Add(base.TokenStream.Peek());
}
