/// <summary>
/// Constructor.
/// </summary>
/// <param name="program">Program</param>
/// <param name="machineNode">MachineDeclarationNode</param>
/// <param name="stateNode">StateDeclarationNode</param>
/// <param name="isModel">Is a model</param>
internal BlockSyntax(IPSharpProgram program, MachineDeclaration machineNode,
StateDeclaration stateNode, bool isModel)
: base(program, isModel)
{
this.Machine = machineNode;
this.State = stateNode;
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="program">Program</param>
/// <param name="machineNode">MachineDeclarationNode</param>
/// <param name="stateNode">StateDeclarationNode</param>
/// <param name="isModel">Is a model</param>
internal BlockSyntax(IPSharpProgram program, MachineDeclaration machineNode,
StateDeclaration stateNode, bool isModel)
: base(program, isModel)
{
this.Machine = machineNode;
this.State = stateNode;
}
/// <summary>
/// Visits the syntax node.
/// </summary>
/// <param name="parentNode">Node</param>
/// <param name="isStart">Is start state</param>
/// <param name="accMod">Access modifier</param>
internal void Visit(MachineDeclaration parentNode, bool isStart, AccessModifier accMod)
{
var node = new StateDeclaration(base.TokenStream.Program, parentNode,
isStart, parentNode.IsModel);
node.AccessModifier = accMod;
node.StateKeyword = base.TokenStream.Peek();
base.TokenStream.Index++;
base.TokenStream.SkipWhiteSpaceAndCommentTokens();
if (base.TokenStream.Done ||
base.TokenStream.Peek().Type != TokenType.Identifier)
{
throw new ParsingException("Expected state identifier.",
new List<TokenType>
{
TokenType.Identifier
});
}
base.TokenStream.CurrentState = base.TokenStream.Peek().Text;
base.TokenStream.Swap(new Token(base.TokenStream.Peek().TextUnit,
TokenType.StateIdentifier));
node.Identifier = base.TokenStream.Peek();
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
});
}
base.TokenStream.Swap(new Token(base.TokenStream.Peek().TextUnit,
TokenType.StateLeftCurlyBracket));
node.LeftCurlyBracketToken = base.TokenStream.Peek();
base.TokenStream.Index++;
base.TokenStream.SkipWhiteSpaceAndCommentTokens();
if (base.TokenStream.Program is PSharpProgram)
{
this.VisitNextPSharpIntraStateDeclaration(node);
}
else
{
this.VisitNextPIntraStateDeclaration(node);
}
parentNode.StateDeclarations.Add(node);
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="program">Program</param>
/// <param name="machineNode">PMachineDeclarationNode</param>
/// <param name="isInit">Is initial state</param>
/// <param name="isModel">Is a model</param>
internal StateDeclaration(IPSharpProgram program, MachineDeclaration machineNode,
bool isInit, bool isModel)
: base(program, isModel)
{
this.IsInitial = isInit;
this.Machine = machineNode;
this.GotoStateTransitions = new Dictionary <Token, Token>();
this.PushStateTransitions = new Dictionary <Token, Token>();
this.ActionBindings = new Dictionary <Token, Token>();
this.TransitionsOnExitActions = new Dictionary <Token, BlockSyntax>();
this.ActionHandlers = new Dictionary <Token, BlockSyntax>();
this.DeferredEvents = new HashSet <Token>();
this.IgnoredEvents = new HashSet <Token>();
}
/// <summary>
/// Rewrites the expression with a this expression.
/// </summary>
/// <param name="node">ThisExpressionSyntax</param>
/// <returns>SyntaxNode</returns>
private SyntaxNode RewriteExpression(ThisExpressionSyntax node)
{
SyntaxNode rewritten = node;
MachineDeclaration machine = null;
if (!base.TryGetParentMachine(rewritten, out machine))
{
return(rewritten);
}
var isMonitor = base.IsMonitor(machine.Identifier.TextUnit.Text);
if (!isMonitor && (rewritten.Parent is ArgumentSyntax ||
(rewritten.Parent is AssignmentExpressionSyntax &&
(rewritten.Parent as AssignmentExpressionSyntax).Right.IsEquivalentTo(node))))
{
var text = "this.Id";
rewritten = SyntaxFactory.ParseExpression(text);
rewritten = rewritten.WithTriviaFrom(node);
}
else if (rewritten.Parent is MemberAccessExpressionSyntax &&
base.IsInStateScope(rewritten) &&
(base.IsMachineField((rewritten.Parent as MemberAccessExpressionSyntax).Name) ||
base.IsMachineMethod((rewritten.Parent as MemberAccessExpressionSyntax).Name)))
{
var text = "(";
if (isMonitor)
{
text += "this.Monitor";
}
else
{
text += "this.Machine";
}
text += " as " + machine.Identifier.TextUnit.Text + ")";
rewritten = SyntaxFactory.ParseExpression(text);
rewritten = rewritten.WithTriviaFrom(node);
}
return(rewritten);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="program">Program</param>
/// <param name="machineNode">MachineDeclarationNode</param>
/// <param name="isModel">Is a model</param>
internal FieldDeclaration(IPSharpProgram program, MachineDeclaration machineNode, bool isModel)
: base(program, isModel)
{
this.Machine = machineNode;
}
/// <summary>
/// Visits a start state modifier.
/// </summary>
/// <param name="parentNode">Node</param>
private void VisitStartStateModifier(MachineDeclaration parentNode)
{
base.TokenStream.Index++;
base.TokenStream.SkipWhiteSpaceAndCommentTokens();
if (base.TokenStream.Done ||
(base.TokenStream.Peek().Type != TokenType.StateDecl &&
base.TokenStream.Peek().Type != TokenType.ColdState &&
base.TokenStream.Peek().Type != TokenType.HotState))
{
throw new ParsingException("Expected state declaration.",
new List<TokenType>
{
TokenType.StateDecl
});
}
if (base.TokenStream.Peek().Type == TokenType.ColdState ||
base.TokenStream.Peek().Type == TokenType.HotState)
{
base.TokenStream.Index++;
base.TokenStream.SkipWhiteSpaceAndCommentTokens();
if (base.TokenStream.Done ||
base.TokenStream.Peek().Type != TokenType.StateDecl)
{
throw new ParsingException("Expected state declaration.",
new List<TokenType>
{
TokenType.StateDecl
});
}
}
new StateDeclarationVisitor(base.TokenStream).Visit(parentNode, true, AccessModifier.None);
}
/// <summary>
/// Visits the syntax node.
/// </summary>
/// <param name="program">Program</param>
/// <param name="parentNode">Node</param>
/// <param name="isMain">Is main machine</param>
/// <param name="isModel">Is a model</param>
/// <param name="isMonitor">Is a monitor</param>
/// <param name="accMod">Access modifier</param>
/// <param name="inhMod">Inheritance modifier</param>
internal void Visit(IPSharpProgram program, NamespaceDeclaration parentNode, bool isMain,
bool isModel, bool isMonitor, AccessModifier accMod, InheritanceModifier inhMod)
{
var node = new MachineDeclaration(base.TokenStream.Program, isMain, isModel, isMonitor);
node.AccessModifier = accMod;
node.InheritanceModifier = inhMod;
node.MachineKeyword = base.TokenStream.Peek();
base.TokenStream.Index++;
base.TokenStream.SkipWhiteSpaceAndCommentTokens();
if (base.TokenStream.Done ||
base.TokenStream.Peek().Type != TokenType.Identifier)
{
throw new ParsingException("Expected machine identifier.",
new List<TokenType>
{
TokenType.Identifier
});
}
base.TokenStream.CurrentMachine = base.TokenStream.Peek().Text;
base.TokenStream.Swap(new Token(base.TokenStream.Peek().TextUnit,
TokenType.MachineIdentifier));
node.Identifier = base.TokenStream.Peek();
base.TokenStream.Index++;
base.TokenStream.SkipWhiteSpaceAndCommentTokens();
if (base.TokenStream.Program is PSharpProgram)
{
if (base.TokenStream.Done ||
(base.TokenStream.Peek().Type != TokenType.Colon &&
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();
if (base.TokenStream.Done ||
base.TokenStream.Peek().Type != TokenType.Identifier)
{
throw new ParsingException("Expected base machine identifier.",
new List<TokenType>
{
TokenType.Identifier
});
}
while (!base.TokenStream.Done &&
base.TokenStream.Peek().Type != TokenType.LeftCurlyBracket)
{
if (base.TokenStream.Peek().Type != TokenType.Identifier &&
base.TokenStream.Peek().Type != TokenType.Dot &&
base.TokenStream.Peek().Type != TokenType.NewLine)
{
throw new ParsingException("Expected base machine identifier.",
new List<TokenType>
{
TokenType.Identifier,
TokenType.Dot
});
}
else
{
node.BaseNameTokens.Add(base.TokenStream.Peek());
}
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
});
}
base.TokenStream.Swap(new Token(base.TokenStream.Peek().TextUnit,
TokenType.MachineLeftCurlyBracket));
node.LeftCurlyBracketToken = base.TokenStream.Peek();
base.TokenStream.Index++;
base.TokenStream.SkipWhiteSpaceAndCommentTokens();
if (base.TokenStream.Program is PSharpProgram)
{
this.VisitNextPSharpIntraMachineDeclaration(node);
parentNode.MachineDeclarations.Add(node);
}
else
{
this.VisitNextPIntraMachineDeclaration(node);
(program as PProgram).MachineDeclarations.Add(node);
}
if (node.StateDeclarations.Count == 0 && node.BaseNameTokens.Count == 0)
{
throw new ParsingException("A machine must declare at least one state.",
new List<TokenType>());
}
var initialStates = node.StateDeclarations.FindAll(s => s.IsInitial);
if (initialStates.Count == 0 && node.BaseNameTokens.Count == 0)
{
throw new ParsingException("A machine must declare a start state.",
new List<TokenType>());
}
else if (initialStates.Count > 1)
{
throw new ParsingException("A machine can declare only a single start state.",
new List<TokenType>());
}
}
/// <summary>
/// Visits the next intra-machine declration.
/// </summary>
/// <param name="node">Node</param>
private void VisitNextPSharpIntraMachineDeclaration(MachineDeclaration node)
{
bool fixpoint = false;
while (!fixpoint)
{
var token = base.TokenStream.Peek();
switch (token.Type)
{
case TokenType.WhiteSpace:
case TokenType.Comment:
case TokenType.NewLine:
base.TokenStream.Index++;
break;
case TokenType.CommentLine:
case TokenType.Region:
base.TokenStream.SkipWhiteSpaceAndCommentTokens();
break;
case TokenType.CommentStart:
base.TokenStream.SkipWhiteSpaceAndCommentTokens();
break;
case TokenType.StartState:
case TokenType.StateDecl:
case TokenType.ModelDecl:
case TokenType.Void:
case TokenType.MachineDecl:
case TokenType.Object:
case TokenType.String:
case TokenType.Sbyte:
case TokenType.Byte:
case TokenType.Short:
case TokenType.Ushort:
case TokenType.Int:
case TokenType.Uint:
case TokenType.Long:
case TokenType.Ulong:
case TokenType.Char:
case TokenType.Bool:
case TokenType.Decimal:
case TokenType.Float:
case TokenType.Double:
case TokenType.Identifier:
case TokenType.Private:
case TokenType.Protected:
case TokenType.Internal:
case TokenType.Public:
case TokenType.Async:
this.VisitMachineLevelDeclaration(node);
base.TokenStream.Index++;
break;
case TokenType.LeftSquareBracket:
base.TokenStream.Index++;
base.TokenStream.SkipWhiteSpaceAndCommentTokens();
new AttributeListVisitor(base.TokenStream).Visit();
base.TokenStream.Index++;
break;
case TokenType.RightCurlyBracket:
base.TokenStream.Swap(new Token(base.TokenStream.Peek().TextUnit,
TokenType.MachineRightCurlyBracket));
node.RightCurlyBracketToken = base.TokenStream.Peek();
base.TokenStream.CurrentMachine = "";
fixpoint = true;
break;
default:
throw new ParsingException("Unexpected token.",
new List<TokenType>());
}
if (base.TokenStream.Done)
{
throw new ParsingException("Expected \"}\".",
new List<TokenType>
{
TokenType.Private,
TokenType.Protected,
TokenType.StartState,
TokenType.StateDecl,
TokenType.ModelDecl,
TokenType.LeftSquareBracket,
TokenType.RightCurlyBracket
});
}
}
}
/// <summary>
/// Visits the next intra-machine declration.
/// </summary>
/// <param name="node">Node</param>
private void VisitNextPIntraMachineDeclaration(MachineDeclaration node)
{
bool fixpoint = false;
while (!fixpoint)
{
var token = base.TokenStream.Peek();
switch (token.Type)
{
case TokenType.WhiteSpace:
case TokenType.Comment:
case TokenType.NewLine:
base.TokenStream.Index++;
break;
case TokenType.CommentLine:
case TokenType.Region:
base.TokenStream.SkipWhiteSpaceAndCommentTokens();
break;
case TokenType.CommentStart:
base.TokenStream.SkipWhiteSpaceAndCommentTokens();
break;
case TokenType.StartState:
this.VisitStartStateModifier(node);
base.TokenStream.Index++;
break;
case TokenType.StateDecl:
new StateDeclarationVisitor(base.TokenStream).Visit(node, false, AccessModifier.None);
base.TokenStream.Index++;
break;
case TokenType.ModelDecl:
new FunctionDeclarationVisitor(base.TokenStream).Visit(node, true);
base.TokenStream.Index++;
break;
case TokenType.FunDecl:
new FunctionDeclarationVisitor(base.TokenStream).Visit(node, false);
base.TokenStream.Index++;
break;
case TokenType.Var:
new FieldDeclarationVisitor(base.TokenStream).Visit(node);
base.TokenStream.Index++;
break;
case TokenType.ColdState:
case TokenType.HotState:
base.TokenStream.Index++;
break;
case TokenType.RightCurlyBracket:
base.TokenStream.Swap(new Token(base.TokenStream.Peek().TextUnit,
TokenType.MachineRightCurlyBracket));
node.RightCurlyBracketToken = base.TokenStream.Peek();
base.TokenStream.CurrentMachine = "";
fixpoint = true;
break;
default:
throw new ParsingException("Unexpected token.",
new List<TokenType>());
}
if (base.TokenStream.Done)
{
throw new ParsingException("Expected \"}\".",
new List<TokenType>
{
TokenType.StartState,
TokenType.StateDecl,
TokenType.FunDecl,
TokenType.Var
});
}
}
}
/// <summary>
/// Visits a machine level declaration.
/// </summary>
/// <param name="parentNode">Node</param>
private void VisitMachineLevelDeclaration(MachineDeclaration parentNode)
{
AccessModifier am = AccessModifier.None;
InheritanceModifier im = InheritanceModifier.None;
bool isStart = false;
bool isModel = false;
bool isAsync = false;
while (!base.TokenStream.Done &&
base.TokenStream.Peek().Type != TokenType.StateDecl &&
base.TokenStream.Peek().Type != TokenType.MachineDecl &&
base.TokenStream.Peek().Type != TokenType.Void &&
base.TokenStream.Peek().Type != TokenType.Object &&
base.TokenStream.Peek().Type != TokenType.String &&
base.TokenStream.Peek().Type != TokenType.Sbyte &&
base.TokenStream.Peek().Type != TokenType.Byte &&
base.TokenStream.Peek().Type != TokenType.Short &&
base.TokenStream.Peek().Type != TokenType.Ushort &&
base.TokenStream.Peek().Type != TokenType.Int &&
base.TokenStream.Peek().Type != TokenType.Uint &&
base.TokenStream.Peek().Type != TokenType.Long &&
base.TokenStream.Peek().Type != TokenType.Ulong &&
base.TokenStream.Peek().Type != TokenType.Char &&
base.TokenStream.Peek().Type != TokenType.Bool &&
base.TokenStream.Peek().Type != TokenType.Decimal &&
base.TokenStream.Peek().Type != TokenType.Float &&
base.TokenStream.Peek().Type != TokenType.Double &&
base.TokenStream.Peek().Type != TokenType.Identifier)
{
if (am != AccessModifier.None &&
(base.TokenStream.Peek().Type == TokenType.Public ||
base.TokenStream.Peek().Type == TokenType.Private ||
base.TokenStream.Peek().Type == TokenType.Protected ||
base.TokenStream.Peek().Type == TokenType.Internal))
{
throw new ParsingException("More than one protection modifier.",
new List<TokenType>());
}
else if (im != InheritanceModifier.None &&
base.TokenStream.Peek().Type == TokenType.Abstract)
{
throw new ParsingException("Duplicate abstract modifier.",
new List<TokenType>());
}
else if (isStart &&
base.TokenStream.Peek().Type == TokenType.StartState)
{
throw new ParsingException("Duplicate start state modifier.",
new List<TokenType>());
}
else if (isModel &&
base.TokenStream.Peek().Type == TokenType.ModelDecl)
{
throw new ParsingException("Duplicate model method modifier.",
new List<TokenType>());
}
else if (isAsync &&
base.TokenStream.Peek().Type == TokenType.Async)
{
throw new ParsingException("Duplicate async method modifier.",
new List<TokenType>());
}
if (base.TokenStream.Peek().Type == TokenType.Public)
{
am = AccessModifier.Public;
}
else if (base.TokenStream.Peek().Type == TokenType.Private)
{
am = AccessModifier.Private;
}
else if (base.TokenStream.Peek().Type == TokenType.Protected)
{
am = AccessModifier.Protected;
}
else if (base.TokenStream.Peek().Type == TokenType.Internal)
{
am = AccessModifier.Internal;
}
else if (base.TokenStream.Peek().Type == TokenType.Abstract)
{
im = InheritanceModifier.Abstract;
}
else if (base.TokenStream.Peek().Type == TokenType.Virtual)
{
im = InheritanceModifier.Virtual;
}
else if (base.TokenStream.Peek().Type == TokenType.Override)
{
im = InheritanceModifier.Override;
}
else if (base.TokenStream.Peek().Type == TokenType.StartState)
{
isStart = true;
}
else if (base.TokenStream.Peek().Type == TokenType.ModelDecl)
{
isModel = true;
}
else if (base.TokenStream.Peek().Type == TokenType.Async)
{
isAsync = true;
}
base.TokenStream.Index++;
base.TokenStream.SkipWhiteSpaceAndCommentTokens();
}
if (base.TokenStream.Done ||
(base.TokenStream.Peek().Type != TokenType.StateDecl &&
base.TokenStream.Peek().Type != TokenType.MachineDecl &&
base.TokenStream.Peek().Type != TokenType.Void &&
base.TokenStream.Peek().Type != TokenType.Object &&
base.TokenStream.Peek().Type != TokenType.String &&
base.TokenStream.Peek().Type != TokenType.Sbyte &&
base.TokenStream.Peek().Type != TokenType.Byte &&
base.TokenStream.Peek().Type != TokenType.Short &&
base.TokenStream.Peek().Type != TokenType.Ushort &&
base.TokenStream.Peek().Type != TokenType.Int &&
base.TokenStream.Peek().Type != TokenType.Uint &&
base.TokenStream.Peek().Type != TokenType.Long &&
base.TokenStream.Peek().Type != TokenType.Ulong &&
base.TokenStream.Peek().Type != TokenType.Char &&
base.TokenStream.Peek().Type != TokenType.Bool &&
base.TokenStream.Peek().Type != TokenType.Decimal &&
base.TokenStream.Peek().Type != TokenType.Float &&
base.TokenStream.Peek().Type != TokenType.Double &&
base.TokenStream.Peek().Type != TokenType.Identifier))
{
throw new ParsingException("Expected state or method declaration.",
new List<TokenType>
{
TokenType.StateDecl,
TokenType.MachineDecl,
TokenType.Void,
TokenType.Object,
TokenType.String,
TokenType.Sbyte,
TokenType.Byte,
TokenType.Short,
TokenType.Ushort,
TokenType.Int,
TokenType.Uint,
TokenType.Long,
TokenType.Ulong,
TokenType.Char,
TokenType.Bool,
TokenType.Decimal,
TokenType.Float,
TokenType.Double,
TokenType.Identifier
});
}
if (base.TokenStream.Peek().Type == TokenType.StateDecl)
{
if (am == AccessModifier.Public)
{
throw new ParsingException("A state cannot be public.",
new List<TokenType>());
}
else if (am == AccessModifier.Internal)
{
throw new ParsingException("A state cannot be internal.",
new List<TokenType>());
}
if (im == InheritanceModifier.Abstract)
{
throw new ParsingException("A state cannot be abstract.",
new List<TokenType>());
}
else if (im == InheritanceModifier.Virtual)
{
throw new ParsingException("A state cannot be virtual.",
new List<TokenType>());
}
else if (im == InheritanceModifier.Override)
{
throw new ParsingException("A state cannot be overriden.",
new List<TokenType>());
}
if (isModel)
{
throw new ParsingException("A state cannot be a model.",
new List<TokenType>());
}
if (isAsync)
{
throw new ParsingException("A state cannot be async.",
new List<TokenType>());
}
new StateDeclarationVisitor(base.TokenStream).Visit(parentNode, isStart, am);
}
else
{
if (am == AccessModifier.Public)
{
throw new ParsingException("A field or method cannot be public.",
new List<TokenType>());
}
else if (am == AccessModifier.Internal)
{
throw new ParsingException("A field or method cannot be internal.",
new List<TokenType>());
}
new FieldOrMethodDeclarationVisitor(base.TokenStream).Visit(parentNode,
isModel, am, im, isAsync);
}
}
/// <summary>
/// Visits the syntax node.
/// </summary>
/// <param name="parentNode">Node</param>
/// <param name="isModel">Is model</param>
/// <param name="accMod">Access modifier</param>
/// <param name="inhMod">Inheritance modifier</param>
/// <param name="isAsync">Is async</param>
internal void Visit(MachineDeclaration parentNode, bool isModel, AccessModifier accMod,
InheritanceModifier inhMod, bool isAsync)
{
TextUnit textUnit = null;
new TypeIdentifierVisitor(base.TokenStream).Visit(ref textUnit);
var typeIdentifier = new Token(textUnit, TokenType.TypeIdentifier);
if (base.TokenStream.Done ||
base.TokenStream.Peek().Type != TokenType.Identifier)
{
throw new ParsingException("Expected field or method identifier.",
new List<TokenType>
{
TokenType.Identifier
});
}
var identifierToken = base.TokenStream.Peek();
base.TokenStream.Index++;
base.TokenStream.SkipWhiteSpaceAndCommentTokens();
if (base.TokenStream.Done ||
(base.TokenStream.Peek().Type != TokenType.LeftParenthesis &&
base.TokenStream.Peek().Type != TokenType.Semicolon))
{
throw new ParsingException("Expected \"(\" or \";\".",
new List<TokenType>
{
TokenType.LeftParenthesis,
TokenType.Semicolon
});
}
if (base.TokenStream.Peek().Type == TokenType.LeftParenthesis)
{
new MethodDeclarationVisitor(base.TokenStream).Visit(parentNode, typeIdentifier,
identifierToken, isModel, accMod, inhMod, isAsync);
}
else if (base.TokenStream.Peek().Type == TokenType.Semicolon)
{
if (inhMod == InheritanceModifier.Abstract)
{
throw new ParsingException("A field cannot be abstract.",
new List<TokenType>());
}
else if (inhMod == InheritanceModifier.Virtual)
{
throw new ParsingException("A field cannot be virtual.",
new List<TokenType>());
}
else if (inhMod == InheritanceModifier.Override)
{
throw new ParsingException("A field cannot be overriden.",
new List<TokenType>());
}
if (isModel)
{
throw new ParsingException("A field cannot be a model.",
new List<TokenType>());
}
if (isAsync)
{
throw new ParsingException("A field cannot be async.",
new List<TokenType>());
}
var node = new FieldDeclaration(base.TokenStream.Program, parentNode,
parentNode.IsModel);
node.AccessModifier = accMod;
node.TypeIdentifier = typeIdentifier;
node.Identifier = identifierToken;
node.SemicolonToken = base.TokenStream.Peek();
parentNode.FieldDeclarations.Add(node);
}
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="program">Program</param>
/// <param name="machineNode">PMachineDeclarationNode</param>
/// <param name="isModel">Is a model</param>
internal PFieldDeclaration(IPSharpProgram program, MachineDeclaration machineNode,
bool isModel)
: base(program, machineNode, isModel)
{
}
/// <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>
/// Constructor
/// </summary>
/// <param name="program">Program</param>
/// <param name="machineNode">PMachineDeclarationNode</param>
/// <param name="isModel">Is a model</param>
internal PFieldDeclaration(IPSharpProgram program, MachineDeclaration machineNode,
bool isModel)
: base(program, machineNode, isModel)
{
}
/// <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="parentNode">Node</param>
/// <param name="typeIdentifier">Type identifier</param>
/// <param name="identifier">Identifier</param>
/// <param name="isModel">Is model</param>
/// <param name="accMod">Access modifier</param>
/// <param name="inhMod">Inheritance modifier</param>
/// <param name="isAsync">Is async</param>
internal void Visit(MachineDeclaration parentNode, Token typeIdentifier, Token identifier,
bool isModel, AccessModifier accMod, InheritanceModifier inhMod, bool isAsync)
{
if (parentNode.IsModel)
{
isModel = true;
}
var node = new MethodDeclaration(base.TokenStream.Program, isModel);
node.AccessModifier = accMod;
node.InheritanceModifier = inhMod;
node.TypeIdentifier = typeIdentifier;
node.Identifier = identifier;
node.IsAsync = isAsync;
node.LeftParenthesisToken = base.TokenStream.Peek();
base.TokenStream.Index++;
base.TokenStream.SkipWhiteSpaceAndCommentTokens();
while (!base.TokenStream.Done &&
base.TokenStream.Peek().Type != TokenType.RightParenthesis)
{
base.TokenStream.Swap(new Token(base.TokenStream.Peek().TextUnit));
node.Parameters.Add(base.TokenStream.Peek());
base.TokenStream.Index++;
base.TokenStream.SkipWhiteSpaceAndCommentTokens();
}
node.RightParenthesisToken = base.TokenStream.Peek();
base.TokenStream.Index++;
base.TokenStream.SkipWhiteSpaceAndCommentTokens();
if (base.TokenStream.Done ||
(base.TokenStream.Peek().Type != TokenType.LeftCurlyBracket &&
base.TokenStream.Peek().Type != TokenType.Semicolon))
{
throw new ParsingException("Expected \"{\" or \";\".",
new List<TokenType>
{
TokenType.LeftCurlyBracket,
TokenType.Semicolon
});
}
if (base.TokenStream.Peek().Type == TokenType.LeftCurlyBracket)
{
var blockNode = new BlockSyntax(base.TokenStream.Program, parentNode,
null, parentNode.IsModel);
new BlockSyntaxVisitor(base.TokenStream).Visit(blockNode);
node.StatementBlock = blockNode;
}
else if (base.TokenStream.Peek().Type == TokenType.Semicolon)
{
node.SemicolonToken = base.TokenStream.Peek();
}
parentNode.MethodDeclarations.Add(node);
}
/// <summary>
/// Tries to return the parent machine identifier, if any.
/// </summary>
/// <param name="node">SyntaxNode</param>
/// <param name="machine">MachineDeclaration</param>
/// <returns>Boolean value</returns>
protected bool TryGetParentMachine(SyntaxNode node, out MachineDeclaration machine)
{
var result = false;
machine = null;
var ancestors = node.Ancestors().OfType<ClassDeclarationSyntax>().ToList();
foreach (var ancestor in ancestors)
{
machine = this.Project.PSharpPrograms.
SelectMany(p => p.NamespaceDeclarations).
SelectMany(n => n.MachineDeclarations).
FirstOrDefault(s => s.Identifier.TextUnit.Text.Equals(ancestor.Identifier.ValueText));
if (machine != null)
{
result = true;
break;
}
}
return result;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="program">Program</param>
/// <param name="machineNode">MachineDeclarationNode</param>
/// <param name="isModel">Is a model</param>
internal FieldDeclaration(IPSharpProgram program, MachineDeclaration machineNode, bool isModel)
: base(program, isModel)
{
this.Machine = machineNode;
}