// subtree gets succ.
public override TokenSet Init_FollowSet(ParseNode_Root parser, TokenSet succ)
{
Init_PreCheckSet(parser);
FollowSet = succ;
node.Init_FollowSet(parser, succ);
return(FirstSet);
}
public void FromArrayWithUnsortedArrayThrows()
{
Assert.Throws <InvalidOperationException>(() =>
{
TokenSet.FromArray(new[] { "z", "a" });
});
}
public void UnicodeTest()
{
TokenSet tokens = Tokenizer.Tokenize("N'NOON'");
Assert.AreEqual(1, tokens.Count);
Assert.AreEqual("'NOON'", tokens.First.Value);
}
public void Current_MoveNext_CurrentHasValue()
{
var tokenSet = new TokenSet(new[] { new Token() });
tokenSet.MoveNext();
tokenSet.Current.Should().NotBeNull();
}
public bool TrySetTokens(string?idToken, string?accessToken)
{
if (string.IsNullOrEmpty(idToken) || string.IsNullOrEmpty(accessToken))
{
return(false);
}
if (TryParseJsonPayload(idToken, out var json))
{
if (json.RootElement.TryGetProperty("exp", out var expProperty) &&
expProperty.TryGetInt64(out long exp))
{
if (DateTimeOffset.FromUnixTimeSeconds(exp) < DateTimeOffset.UtcNow)
{
return(false);
}
}
if (json.RootElement.TryGetProperty("preferred_username", out var usernameProperty))
{
UserName = usernameProperty.GetString();
}
if (json.RootElement.TryGetProperty("sub", out var userIdProperty))
{
UserId = userIdProperty.GetString();
}
}
Token = accessToken;
TokenSet?.Invoke();
return(true);
}
public async Task BuilderBuildsInvertedIndex()
{
var builder = new Builder();
builder.AddField("title");
await builder.Add(new Document
{
{ "id", "id" },
{ "title", "test" },
{ "body", "missing" }
});
Index index = builder.Build();
Assert.Empty(builder.InvertedIndex["test"]["title"]["id"]);
Assert.IsType <Vector>(builder.FieldVectors["title/id"]);
Assert.False(builder.InvertedIndex.ContainsKey("missing"));
var needle = TokenSet.FromString("test");
Assert.Contains("test", builder.TokenSet.Intersect(needle).ToEnumeration());
Assert.Equal(1, builder.DocumentCount);
Assert.Equal(1, builder.AverageFieldLength["title"]);
Assert.NotNull(index);
}
// Use this for initialization
void Start()
{
start = false;
startTime = 0.0f;
/* Generate TokenSet base on the information and the template (TokenSet) */
localSet = new TokenSet(directionList, positionList, tokenTemplate);
}
public void ToEnumerateIncludesSingleWords()
{
string word = "bat";
var tokenSet = TokenSet.FromString(word);
Assert.Equal(new[] { word }, tokenSet.ToEnumeration());
}
// checks for ambiguous lookahead.
public bool Accepts(TokenSet s)
{
if (s.set != null)
{
if (set != null)
{
var intersection = new BitArray(set);
intersection = intersection.And(s.set);
for (var n = 0; n < intersection.Count; ++n)
{
if (intersection[n])
{
return(true);
}
}
}
else if (tokenId >= 0)
{
return(s.set[tokenId]);
}
}
else if (s.tokenId >= 0)
{
if (set != null)
{
return(set[s.tokenId]);
}
if (tokenId >= 0)
{
return(tokenId == s.tokenId);
}
}
return(false);
}
public override TokenSet Init_PreCheckSet(ParseNode_Root parser)
{
if (FirstSet == null)
{
FirstSet = new TokenSet();
foreach (var t in nodes)
{
if (t is ParseNode_ManyOpt_If)
{
continue;
}
var set = t.Init_PreCheckSet(parser);
if (FirstSet.Accepts(set))
{
Debug.LogError(this + ": ambiguous alternatives");
Debug.LogWarning(FirstSet.Intersecton(set).ToString(parser));
}
FirstSet.Add(set);
}
foreach (var t in nodes)
{
if (t is ParseNode_ManyOpt_If)
{
var set = t.Init_PreCheckSet(parser);
FirstSet.Add(set);
}
}
}
return(FirstSet);
}
public void ParseSentence_EmptyTokenSet_NullCommand()
{
var tokenSet = new TokenSet();
var cmd = _parser.ParseSentence(tokenSet);
cmd.Should().BeNull();
}
public override TokenSet Init_PreCheckSet(ParseNode_Root parser)
{
if (FirstSet == null)
{
FirstSet = new TokenSet();
if (nodes.Count == 0)
{
FirstSet.AddEmpty();
}
else
{
for (int i = 0; i < nodes.Count; ++i)
{
var t = nodes[i];
var set = t.Init_PreCheckSet(parser);
FirstSet.Add(set);
if (!set.ContainsEmpty())
{
FirstSet.RemoveEmpty();
break;
}
}
}
}
return(FirstSet);
}
public async Task <ApiResponse <List <Artist> > > GetArtists(TokenSet tokenSet, List <string> artistIds, bool shouldCache = false)
{
var artistList = new List <Artist>();
var completedCount = 0;
while (completedCount != artistIds.Count)
{
var currentSet = artistIds.Skip(completedCount).Take(MAX_ARTIST_LIMIT_VALUE);
var idString = string.Join(",", currentSet);
var artistsResponse = shouldCache ?
await _client.SendAsyncWithCaching <ArtistsWrapper>(tokenSet, HttpMethod.Get, $"artists?ids={idString}") :
await _client.SendAsync <ArtistsWrapper>(tokenSet, HttpMethod.Get, $"artists?ids={idString}");
if (!artistsResponse.IsSuccessStatusCode)
{
break;
}
artistList.AddRange(artistsResponse.Content.Artists);
completedCount += artistsResponse.Content.Artists.Count;
}
return(new ApiResponse <List <Artist> >(HttpStatusCode.OK)
{
Content = artistList
});
}
public void IntersectWithFuzzierStringTranspose()
{
var x = TokenSet.FromString("bca");
var y = TokenSet.FromFuzzyString("abc", 2);
Assert.Equal(new[] { "bca" }, x.Intersect(y).ToEnumeration());
}
private BlockStatement ParseStatementBlock(TokenSet followers) {
SourceLocationBuilder slb = new SourceLocationBuilder(this.scanner.CurrentSourceLocation);
List<Statement> statements = new List<Statement>();
this.ParseStatements(statements, followers);
slb.UpdateToSpan(this.scanner.CurrentSourceLocation);
return new BlockStatement(statements, slb);
}
public void IntersectWithFuzzierStringSubstitution()
{
var x = TokenSet.FromString("axx");
var y = TokenSet.FromFuzzyString("abc", 2);
Assert.Equal(new[] { "axx" }, x.Intersect(y).ToEnumeration());
}
public async Task ReturnValidTokenWhenExpiredAndRenewAllowed()
{
using (var httpTest = new HttpTest())
{
// Arrange
RepositoryEnrichedTokenSet tokenSet = new RepositoryEnrichedTokenSet
{
AthleteId = "1",
AccessToken = "2",
ExpiresAtUtc = DateTime.UtcNow.AddDays(-1),
RefreshToken = "3"
};
_tokenRepository.GetForAccessToken("1").Returns(tokenSet);
httpTest.RespondWith(JsonConvert.SerializeObject(new StravaTokenExchangeResponse
{
access_token = "4",
athlete = new TokenExchangeAthlete {
id = "1"
},
expires_at = (int)DateTime.UtcNow.AddDays(1).Subtract(new DateTime(1970, 1, 1)).TotalSeconds,
refresh_token = "5"
}));
// Act
TokenSet result = await _testSubject.GetTokenSetForAccessToken("1", true);
// Assert
Assert.Equal("1", result.AthleteId);
Assert.Equal("4", result.AccessToken);
httpTest.ShouldHaveCalled(_options.TokenEndPoint);
}
}
public void ToEnumerationIncludesAllWords()
{
string[] words = new[] { "bat", "cat" };
var tokenSet = TokenSet.FromArray(words);
Assert.True(new HashSet <string>(words).SetEquals(tokenSet.ToEnumeration()));
}
private Statement ParseFor(TokenSet followers)
//^ requires this.currentToken == Token.For;
//^ ensures followers[this.currentToken] || this.currentToken == Token.EndOfFile;
{
SourceLocationBuilder slb = new SourceLocationBuilder(this.scanner.CurrentSourceLocation);
this.GetNextToken();
if (this.currentToken == Token.Each) return this.ParseForEach(slb, followers);
SmallBasicSimpleName variableName = this.ParseSimpleName(followers|Parser.ExpressionStart|Token.Equals|Token.To|Token.Step|Token.EndOfLine);
variableName.rootClass = this.rootClass;
this.Skip(Token.Equals);
Expression startValue = this.ParseExpression(followers|Parser.ExpressionStart|Token.To|Token.Step|Token.EndOfLine);
variableName.expressionToInferTargetTypeFrom = startValue;
SourceLocationBuilder rslb = new SourceLocationBuilder(startValue.SourceLocation);
this.Skip(Token.To);
Expression endValue = this.ParseExpression(followers|Parser.ExpressionStart|Token.Step|Token.EndOfLine);
rslb.UpdateToSpan(endValue.SourceLocation);
Expression/*?*/ stepValue = null;
if (this.currentToken == Token.Step) {
this.GetNextToken();
stepValue = this.ParseExpression(followers|Token.EndOfLine);
}
this.Skip(Token.EndOfLine);
BlockStatement body = this.ParseStatementBlock(followers|Token.Next);
slb.UpdateToSpan(body.SourceLocation);
ForRangeStatement result = new ForRangeStatement(null, variableName, new Range(startValue, endValue, rslb), stepValue, body, slb); //TODO Spec#: Range should not be ambiguous
this.SkipClosingKeyword(Token.Next, followers);
return result;
}
public Task <TokenSet> AddOrUpdateTokenSet(TokenSet tokenSet)
{
AddOrUpdateTokenSetCount++;
if (tokenSet is null)
{
throw new ArgumentNullException(nameof(tokenSet));
}
var existingToken = TokenSets.Find(t => t.Id == tokenSet.Id);
if (existingToken != null)
{
TokenSets.Remove(existingToken);
}
if (string.IsNullOrEmpty(tokenSet.Id))
{
tokenSet.Id = Guid.NewGuid().ToString();
}
TokenSets.Add(tokenSet);
return(Task.FromResult(tokenSet));
}
public async Task <ApiResponse <T> > SendAsync <T>(TokenSet tokenSet, HttpMethod method, string endpoint)
{
var requestUrl = endpoint.Contains("https://") ? endpoint : $"{_config.ApiBaseUri}/{endpoint}";
var request = new HttpRequestMessage(method, requestUrl)
{
Headers =
{
{ "Authorization", $"Bearer {tokenSet.AccessToken}" }
}
};
var response = await _client.SendAsync(request);
var apiResponse = new ApiResponse <T>(response.StatusCode);
if (response.IsSuccessStatusCode)
{
var content = await response.Content.ReadAsStringAsync();
apiResponse.Content = JsonConvert.DeserializeObject <T>(content);
}
else
{
apiResponse.ReasonPhrase = response.ReasonPhrase;
}
return(apiResponse);
}
public void TokenSetToStringWritesLeftOperationRight()
{
var set = new TokenSet {
Left = "Left", Operation = "Operation", Right = "Right"
};
Assert.AreEqual("Left Operation Right", set.ToString());
}
public void IntersectWithContainedWildcardBacktrackingIntersection()
{
var x = TokenSet.FromString("ababc");
var y = TokenSet.FromString("a*bc");
TokenSet z = x.Intersect(y);
Assert.Equal(new[] { "ababc" }, z.ToEnumeration());
}
public void IntersectWithContainedWildcardNoIntersection()
{
var x = TokenSet.FromString("foo");
var y = TokenSet.FromString("b*r");
TokenSet z = x.Intersect(y);
Assert.Empty(z.ToEnumeration());
}
public void IntersectWiildcardMatchesZeroOrMoreCharacters()
{
var x = TokenSet.FromString("foo");
var y = TokenSet.FromString("foo*");
TokenSet z = x.Intersect(y);
Assert.Equal(new[] { "foo" }, z.ToEnumeration());
}
public void IntersectWithContainedWildcardBacktrackingNoIntersection()
{
var x = TokenSet.FromString("ababc");
var y = TokenSet.FromString("a*ac");
TokenSet z = x.Intersect(y);
Assert.Empty(z.ToEnumeration());
}
public void IntersectLeadingAndTrailingBacktrackingIntersection()
{
var x = TokenSet.FromString("acbaabab");
var y = TokenSet.FromString("*ab*");
TokenSet z = x.Intersect(y);
Assert.Equal(new[] { "acbaabab" }, z.ToEnumeration());
}
public void CatastrophicBacktrackingWithLeadingCharacters()
{
var x = TokenSet.FromString("fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
var y = TokenSet.FromString("*ff");
TokenSet z = x.Intersect(y);
Assert.Single(z.ToEnumeration());
}
public void FromStringWithoutWildCard()
{
var idProvider = new TokenSetIdProvider();
var x = TokenSet.FromString("a", idProvider);
Assert.Equal("0a2", x.ToString());
Assert.True(x.Edges['a'].IsFinal);
}
public void IntersectMultipleContainedWildcardBackTracking()
{
var x = TokenSet.FromString("acbaabab");
var y = TokenSet.FromString("a*ba*b");
TokenSet z = x.Intersect(y);
Assert.Equal(new[] { "acbaabab" }, z.ToEnumeration());
}
public void FromArrayWithSortedArray()
{
var tokenSet = TokenSet.FromArray(new[] { "a", "z" });
Assert.Equal(
new[] { "a", "z" },
tokenSet.ToEnumeration().OrderBy(t => t));
}
public void IntersectWithContainedWildcardIntersection()
{
var x = TokenSet.FromString("foo");
var y = TokenSet.FromString("f*o");
TokenSet z = x.Intersect(y);
Assert.Equal(new[] { "foo" }, z.ToEnumeration());
}
private Statement ParseDo(TokenSet followers)
//^ requires this.currentToken == Token.Do;
//^ ensures followers[this.currentToken] || this.currentToken == Token.EndOfFile;
{
SourceLocationBuilder slb = new SourceLocationBuilder(this.scanner.CurrentSourceLocation);
this.GetNextToken();
this.Skip(Token.While);
Expression condition = this.ParseExpression(followers|Token.EndOfLine);
this.Skip(Token.EndOfLine);
BlockStatement body = this.ParseStatementBlock(followers|Token.Loop);
slb.UpdateToSpan(this.scanner.CurrentSourceLocation);
WhileDoStatement result = new WhileDoStatement(condition, body, slb);
this.SkipClosingKeyword(Token.Loop, followers);
return result;
}
private void ParseStatements(List<Statement> statements, TokenSet followers)
//^ ensures followers[this.currentToken] || this.currentToken == Token.EndOfFile;
{
while (Parser.StatementStart[this.currentToken]) {
switch (this.currentToken) {
case Token.Do: statements.Add(this.ParseDo(followers)); break;
case Token.For: statements.Add(this.ParseFor(followers)); break;
case Token.Gosub: statements.Add(this.ParseGosub(followers)); break;
case Token.Goto: statements.Add(this.ParseGoto(followers)); break;
case Token.Identifier: statements.Add(this.ParseAssignmentOrCallOrLabel(followers)); break;
case Token.If: statements.Add(this.ParseIf(followers)); break;
case Token.Return: statements.Add(this.ParseReturn(followers)); break;
case Token.EndOfLine: this.GetNextToken(); break;
default: this.SkipTo(followers); break;
}
}
}
protected override Expression ParseBraceLabeledExpression(SourceLocationBuilder slb, TokenSet followers)
{
var lab = (VccLabeledExpression)this.ParseLabeledExpression(followers | Token.RightBrace);
this.Skip(Token.RightBrace);
var body = this.ParseExpression(followers);
var labString = lab.Label.Name.Value;
var labName = new VccByteStringLiteral(labString, lab.Label.SourceLocation);
var labArg = lab.Expression;
if (labArg is DummyExpression)
labArg = new CompileTimeConstant(1, false, lab.Label.SourceLocation);
if (labString == "use") { // this condition is sort of a hack, it should likely look at some function \lbl_use(...) or something
labArg = new VccByteStringLiteral(labArg.SourceLocation.Source, labArg.SourceLocation);
}
var args = new[] { labName, labArg, body };
slb.UpdateToSpan(body.SourceLocation);
return new VccMethodCall(this.GetSimpleNameFor("\\labeled_expression"), args, slb.GetSourceLocation());
}
public void TestCountByName()
{
TokenSet a = new TokenSet((IRandom)m_Random.MockInstance);
a.Name = "a";
TokenSet a2 = new TokenSet((IRandom)m_Random.MockInstance);
a2.Name = "a";
Assert.AreEqual(0, m_TokenSetCollection.CountByName("a"));
m_TokenSetCollection.Add(a);
Assert.AreEqual(1, m_TokenSetCollection.CountByName("a"));
m_TokenSetCollection.Add(a2);
Assert.AreEqual(2, m_TokenSetCollection.CountByName("a"));
Assert.AreEqual(0, m_TokenSetCollection.CountByName("b"));
}
public void TestGetByName()
{
TokenSet a = new TokenSet((IRandom)m_Random.MockInstance);
a.Name = "a";
TokenSet a2 = new TokenSet((IRandom)m_Random.MockInstance);
a2.Name = "a";
Assert.IsNull(m_TokenSetCollection.FindByName("a"));
m_TokenSetCollection.Add(a);
Assert.AreSame(a, m_TokenSetCollection.FindByName("a"));
m_TokenSetCollection.Add(a2);
Assert.AreSame(a, m_TokenSetCollection.FindByName("a"));
Assert.IsNull(m_TokenSetCollection.FindByName("b"));
}
protected override List<Expression> ParseArgumentList(SourceLocationBuilder slb, TokenSet followers)
{
var result = new List<Expression>();
this.Skip(Token.LeftParenthesis);
while (this.currentToken != Token.RightParenthesis) {
if (this.currentToken == Token.Specification) {
result.Add(this.ParseSpecArgument(followers | Token.Comma | Token.Specification | Token.RightParenthesis));
continue;
}
result.Add(this.ParseArgumentExpression(followers | Token.Comma | Token.Specification | Token.RightParenthesis));
if (this.currentToken == Token.Comma) {
this.GetNextToken();
continue;
}
if (this.currentToken == Token.Specification)
continue;
break;
}
slb.UpdateToSpan(this.scanner.SourceLocationOfLastScannedToken);
this.SkipOverTo(Token.RightParenthesis, followers);
return result;
}
private void ParseGenericTypeParameterConstraintsClauses(List<Ast.GenericTypeParameterDeclaration> genericTypeParameters, TokenSet followers)
// ^ requires forall{Ast.GenericTypeParameterDeclaration genericTypeParameter in genericTypeParameters; genericTypeParameter is SpecSharpGenericTypeParameterDeclaration};
//^ ensures followers[this.currentToken] || this.currentToken == Token.EndOfFile;
{
while (this.currentToken == Token.Where) {
this.GetNextToken();
if (!Parser.IdentifierOrNonReservedKeyword[this.currentToken])
this.HandleError(Error.ExpectedIdentifier);
NameDeclaration name = this.ParseNameDeclaration();
SpecSharpGenericTypeParameterDeclaration/*?*/ applicableParameter = null;
foreach (Ast.GenericTypeParameterDeclaration genericTypeParameter in genericTypeParameters)
if (genericTypeParameter.Name.UniqueKey == name.UniqueKey) {
//^ assume genericTypeParameter is SpecSharpGenericTypeParameterDeclaration; //follows from precondition
applicableParameter = (SpecSharpGenericTypeParameterDeclaration)genericTypeParameter;
break;
}
if (applicableParameter == null) {
this.HandleError(name.SourceLocation, Error.TyVarNotFoundInConstraint);
applicableParameter = new SpecSharpGenericTypeParameterDeclaration(null, name, (ushort)genericTypeParameters.Count);
}
this.Skip(Token.Colon);
this.ParseGenericTypeParameterConstraints(applicableParameter, followers|Token.Where);
}
this.SkipTo(followers);
}
private void SkipSemiColon(TokenSet followers)
//^ ensures followers[this.currentToken] || this.currentToken == Token.EndOfFile;
{
if (this.currentToken == Token.Semicolon) {
this.GetNextToken();
this.SkipTo(followers);
} else {
this.Skip(Token.Semicolon);
while (!this.scanner.TokenIsFirstAfterLineBreak && this.currentToken != Token.Semicolon && this.currentToken != Token.RightBrace && this.currentToken != Token.EndOfFile
&& (this.currentToken != Token.LeftBrace || !followers[Token.LeftBrace]))
this.GetNextToken();
if (this.currentToken == Token.Semicolon)
this.GetNextToken();
this.SkipTo(followers);
}
}
private void ParseGenericTypeParameterConstraints(SpecSharpGenericTypeParameterDeclaration applicableParameter, TokenSet followers)
//^ ensures followers[this.currentToken] || this.currentToken == Token.EndOfFile;
{
TokenSet constraintStart = Parser.IdentifierOrNonReservedKeyword|Token.Struct|Token.Class|Token.New;
if (!constraintStart[this.currentToken]) {
this.HandleError(Error.TypeExpected);
this.SkipTo(followers);
return;
}
if (this.currentToken == Token.Class) {
this.GetNextToken();
applicableParameter.MustBeReferenceType = true;
} else if (this.currentToken == Token.Struct) {
this.GetNextToken();
applicableParameter.MustBeValueType = true;
}
while (constraintStart[this.currentToken]) {
if (this.currentToken == Token.Class || this.currentToken == Token.Struct) {
this.HandleError(Error.RefValBoundMustBeFirst);
this.GetNextToken(); continue;
} else if (this.currentToken == Token.New) {
this.GetNextToken();
this.Skip(Token.LeftParenthesis);
this.Skip(Token.RightParenthesis);
applicableParameter.MustHaveDefaultConstructor = true;
if (this.currentToken == Token.Comma) {
this.HandleError(Error.NewBoundMustBeLast);
}
break;
}
//^ assume this.currentToken != Token.EndOfFile;
applicableParameter.AddConstraint(this.ParseTypeExpression(false, false, constraintStart|Token.Comma|followers));
if (this.currentToken != Token.Comma) break;
this.GetNextToken();
}
this.SkipTo(followers);
}
private void SkipTo(TokenSet followers)
//^ ensures followers[this.currentToken] || this.currentToken == Token.EndOfFile;
{
if (followers[this.currentToken]) return;
Error error = Error.InvalidExprTerm;
if (this.currentToken == Token.Using)
error = Error.UsingAfterElements;
else if (!this.insideBlock)
error = Error.InvalidMemberDecl;
this.HandleError(error, this.scanner.GetTokenSource());
while (!followers[this.currentToken] && this.currentToken != Token.EndOfFile)
this.GetNextToken();
}
private void SkipTo(TokenSet followers, Error error, params string[] messages)
//^ ensures followers[this.currentToken] || this.currentToken == Token.EndOfFile;
{
if (error != Error.None)
this.HandleError(error, messages);
while (!followers[this.currentToken] && this.currentToken != Token.EndOfFile)
this.GetNextToken();
}
private void ParseTypeDeclaration(List<INamespaceDeclarationMember> namespaceMembers, TokenSet followers)
//^ ensures followers[this.currentToken] || this.currentToken == Token.EndOfFile;
{
SourceLocationBuilder sctx = new SourceLocationBuilder(this.scanner.SourceLocationOfLastScannedToken);
List<SourceCustomAttribute>/*?*/ attributes = this.ParseAttributes(followers|Parser.AttributeOrTypeDeclarationStart);
List<ModifierToken> modifiers = this.ParseModifiers();
TypeDeclaration.Flags flags = this.ConvertToTypeDeclarationFlags(modifiers);
switch (this.currentToken) {
case Token.Class:
this.ParseNamespaceClassDeclaration(namespaceMembers, attributes, flags, sctx, followers);
break;
case Token.Interface:
this.ParseNamespaceInterfaceDeclaration(namespaceMembers, attributes, flags, sctx, followers);
break;
case Token.Struct:
this.ParseNamespaceStructDeclaration(namespaceMembers, attributes, flags, sctx, followers);
break;
case Token.Delegate:
this.ParseNamespaceDelegateDeclaration(namespaceMembers, attributes, flags, sctx, followers);
break;
case Token.Enum:
this.ParseNamespaceEnumDeclaration(namespaceMembers, attributes, flags, sctx, followers);
break;
default:
if (modifiers.Count > 0 || !followers[this.currentToken])
this.SkipTo(followers, Error.BadTokenInType);
return;
}
}
static TokenSets()
{
AddOp = new TokenSet("addition operator");
AddOp.Add(TokenType.PlusSign);
AddOp.Add(TokenType.MinusSign);
AddOp.Add(TokenType.OrKeyword);
AddOp.Add(TokenType.XorKeyword);
Block = new TokenSet("block");
Block.Add(TokenType.BeginKeyword);
Block.Add(TokenType.AsmKeyword);
ClassDisposition = new TokenSet("class disposition");
ClassDisposition.Add(TokenType.AbstractSemikeyword);
ClassDisposition.Add(TokenType.SealedSemikeyword);
ConstHeader = new TokenSet("const section");
ConstHeader.Add(TokenType.ConstKeyword);
ConstHeader.Add(TokenType.ResourceStringKeyword);
Directive = new TokenSet("directive");
Directive.Add(TokenType.AbstractSemikeyword);
Directive.Add(TokenType.AssemblerSemikeyword);
Directive.Add(TokenType.CdeclSemikeyword);
Directive.Add(TokenType.DispIdSemikeyword);
Directive.Add(TokenType.DynamicSemikeyword);
Directive.Add(TokenType.ExportSemikeyword);
Directive.Add(TokenType.ExternalSemikeyword);
Directive.Add(TokenType.FarSemikeyword);
Directive.Add(TokenType.FinalSemikeyword);
Directive.Add(TokenType.ForwardSemikeyword);
Directive.Add(TokenType.InlineKeyword);
Directive.Add(TokenType.LocalSemikeyword);
Directive.Add(TokenType.MessageSemikeyword);
Directive.Add(TokenType.NearSemikeyword);
Directive.Add(TokenType.OverloadSemikeyword);
Directive.Add(TokenType.OverrideSemikeyword);
Directive.Add(TokenType.PascalSemikeyword);
Directive.Add(TokenType.RegisterSemikeyword);
Directive.Add(TokenType.ReintroduceSemikeyword);
Directive.Add(TokenType.SafecallSemikeyword);
Directive.Add(TokenType.StaticSemikeyword);
Directive.Add(TokenType.StdcallSemikeyword);
Directive.Add(TokenType.VarArgsSemikeyword);
Directive.Add(TokenType.VirtualSemikeyword);
// also includes PortabilityDirective, see below
ExportsSpecifier = new TokenSet("'index' or 'name'");
ExportsSpecifier.Add(TokenType.IndexSemikeyword);
ExportsSpecifier.Add(TokenType.NameSemikeyword);
ForDirection = new TokenSet("'to' or 'downto'");
ForDirection.Add(TokenType.ToKeyword);
ForDirection.Add(TokenType.DownToKeyword);
ForwardableType = new TokenSet("forwardable type");
ForwardableType.Add(TokenType.ClassKeyword);
ForwardableType.Add(TokenType.DispInterfaceKeyword);
ForwardableType.Add(TokenType.InterfaceKeyword);
InitSection = new TokenSet("initialization section");
InitSection.Add(TokenType.AsmKeyword);
InitSection.Add(TokenType.BeginKeyword);
InitSection.Add(TokenType.InitializationKeyword);
InitSection.Add(TokenType.EndKeyword);
InterfaceType = new TokenSet("interface type");
InterfaceType.Add(TokenType.InterfaceKeyword);
InterfaceType.Add(TokenType.DispInterfaceKeyword);
Keyword = new TokenSet("keyword");
Keyword.Add(TokenType.AndKeyword);
Keyword.Add(TokenType.ArrayKeyword);
Keyword.Add(TokenType.AsKeyword);
Keyword.Add(TokenType.AsmKeyword);
Keyword.Add(TokenType.BeginKeyword);
Keyword.Add(TokenType.CaseKeyword);
Keyword.Add(TokenType.ClassKeyword);
Keyword.Add(TokenType.ConstKeyword);
Keyword.Add(TokenType.ConstructorKeyword);
Keyword.Add(TokenType.DestructorKeyword);
Keyword.Add(TokenType.DispInterfaceKeyword);
Keyword.Add(TokenType.DivKeyword);
Keyword.Add(TokenType.DoKeyword);
Keyword.Add(TokenType.DownToKeyword);
Keyword.Add(TokenType.ElseKeyword);
Keyword.Add(TokenType.EndKeyword);
Keyword.Add(TokenType.ExceptKeyword);
Keyword.Add(TokenType.ExportsKeyword);
Keyword.Add(TokenType.FileKeyword);
Keyword.Add(TokenType.FinalizationKeyword);
Keyword.Add(TokenType.FinallyKeyword);
Keyword.Add(TokenType.ForKeyword);
Keyword.Add(TokenType.FunctionKeyword);
Keyword.Add(TokenType.GotoKeyword);
Keyword.Add(TokenType.IfKeyword);
Keyword.Add(TokenType.ImplementationKeyword);
Keyword.Add(TokenType.InKeyword);
Keyword.Add(TokenType.InheritedKeyword);
Keyword.Add(TokenType.InitializationKeyword);
Keyword.Add(TokenType.InlineKeyword);
Keyword.Add(TokenType.InterfaceKeyword);
Keyword.Add(TokenType.IsKeyword);
Keyword.Add(TokenType.LabelKeyword);
Keyword.Add(TokenType.LibraryKeyword);
Keyword.Add(TokenType.ModKeyword);
Keyword.Add(TokenType.NilKeyword);
Keyword.Add(TokenType.NotKeyword);
Keyword.Add(TokenType.ObjectKeyword);
Keyword.Add(TokenType.OfKeyword);
Keyword.Add(TokenType.OrKeyword);
Keyword.Add(TokenType.PackedKeyword);
Keyword.Add(TokenType.ProcedureKeyword);
Keyword.Add(TokenType.ProgramKeyword);
Keyword.Add(TokenType.PropertyKeyword);
Keyword.Add(TokenType.RaiseKeyword);
Keyword.Add(TokenType.RecordKeyword);
Keyword.Add(TokenType.RepeatKeyword);
Keyword.Add(TokenType.ResourceStringKeyword);
Keyword.Add(TokenType.SetKeyword);
Keyword.Add(TokenType.ShlKeyword);
Keyword.Add(TokenType.ShrKeyword);
Keyword.Add(TokenType.StringKeyword);
Keyword.Add(TokenType.ThenKeyword);
Keyword.Add(TokenType.ThreadVarKeyword);
Keyword.Add(TokenType.ToKeyword);
Keyword.Add(TokenType.TryKeyword);
Keyword.Add(TokenType.TypeKeyword);
Keyword.Add(TokenType.UnitKeyword);
Keyword.Add(TokenType.UntilKeyword);
Keyword.Add(TokenType.UsesKeyword);
Keyword.Add(TokenType.VarKeyword);
Keyword.Add(TokenType.WhileKeyword);
Keyword.Add(TokenType.WithKeyword);
Keyword.Add(TokenType.XorKeyword);
MethodType = new TokenSet("method heading");
MethodType.Add(TokenType.ConstructorKeyword);
MethodType.Add(TokenType.DestructorKeyword);
MethodType.Add(TokenType.FunctionKeyword);
MethodType.Add(TokenType.ProcedureKeyword);
MethodType.Add(TokenType.OperatorSemikeyword);
MulOp = new TokenSet("multiplication operator");
MulOp.Add(TokenType.TimesSign);
MulOp.Add(TokenType.DivideBySign);
MulOp.Add(TokenType.DivKeyword);
MulOp.Add(TokenType.AndKeyword);
MulOp.Add(TokenType.ModKeyword);
MulOp.Add(TokenType.ShlKeyword);
MulOp.Add(TokenType.ShrKeyword);
ParameterizedPropertyDirective = new TokenSet("property directive");
ParameterizedPropertyDirective.Add(TokenType.DefaultSemikeyword);
ParameterizedPropertyDirective.Add(TokenType.DispIdSemikeyword);
ParameterizedPropertyDirective.Add(TokenType.ImplementsSemikeyword);
ParameterizedPropertyDirective.Add(TokenType.IndexSemikeyword);
ParameterizedPropertyDirective.Add(TokenType.ReadSemikeyword);
ParameterizedPropertyDirective.Add(TokenType.StoredSemikeyword);
ParameterizedPropertyDirective.Add(TokenType.WriteSemikeyword);
ParameterlessPropertyDirective = new TokenSet("property directive");
ParameterlessPropertyDirective.Add(TokenType.NoDefaultSemikeyword);
ParameterlessPropertyDirective.Add(TokenType.ReadOnlySemikeyword);
ParameterlessPropertyDirective.Add(TokenType.WriteOnlySemikeyword);
ParameterModifier = new TokenSet("parameter modifier");
ParameterModifier.Add(TokenType.ConstKeyword);
ParameterModifier.Add(TokenType.OutSemikeyword);
ParameterModifier.Add(TokenType.VarKeyword);
PortabilityDirective = new TokenSet("portability directive");
PortabilityDirective.Add(TokenType.PlatformSemikeyword);
PortabilityDirective.Add(TokenType.DeprecatedSemikeyword);
PortabilityDirective.Add(TokenType.LibraryKeyword);
PortabilityDirective.Add(TokenType.ExperimentalSemikeyword);
Program = new TokenSet("program");
Program.Add(TokenType.ProgramKeyword);
Program.Add(TokenType.LibraryKeyword);
RelOp = new TokenSet("relational operator");
RelOp.Add(TokenType.EqualSign);
RelOp.Add(TokenType.GreaterThan);
RelOp.Add(TokenType.LessThan);
RelOp.Add(TokenType.LessOrEqual);
RelOp.Add(TokenType.GreaterOrEqual);
RelOp.Add(TokenType.NotEqual);
RelOp.Add(TokenType.InKeyword);
RelOp.Add(TokenType.IsKeyword);
RelOp.Add(TokenType.AsKeyword);
Semikeyword = new TokenSet("semikeyword");
Semikeyword.Add(TokenType.AbsoluteSemikeyword);
Semikeyword.Add(TokenType.AbstractSemikeyword);
Semikeyword.Add(TokenType.AssemblerSemikeyword);
Semikeyword.Add(TokenType.AssemblySemikeyword);
Semikeyword.Add(TokenType.AtSemikeyword);
Semikeyword.Add(TokenType.AutomatedSemikeyword);
Semikeyword.Add(TokenType.CdeclSemikeyword);
Semikeyword.Add(TokenType.ContainsSemikeyword);
Semikeyword.Add(TokenType.DefaultSemikeyword);
Semikeyword.Add(TokenType.DeprecatedSemikeyword);
Semikeyword.Add(TokenType.DispIdSemikeyword);
Semikeyword.Add(TokenType.DynamicSemikeyword);
Semikeyword.Add(TokenType.ExperimentalSemikeyword);
Semikeyword.Add(TokenType.ExportSemikeyword);
Semikeyword.Add(TokenType.ExternalSemikeyword);
Semikeyword.Add(TokenType.FarSemikeyword);
Semikeyword.Add(TokenType.FinalSemikeyword);
Semikeyword.Add(TokenType.ForwardSemikeyword);
Semikeyword.Add(TokenType.HelperSemikeyword);
Semikeyword.Add(TokenType.ImplementsSemikeyword);
Semikeyword.Add(TokenType.IndexSemikeyword);
Semikeyword.Add(TokenType.LocalSemikeyword);
Semikeyword.Add(TokenType.MessageSemikeyword);
Semikeyword.Add(TokenType.NameSemikeyword);
Semikeyword.Add(TokenType.NearSemikeyword);
Semikeyword.Add(TokenType.NoDefaultSemikeyword);
Semikeyword.Add(TokenType.OnSemikeyword);
Semikeyword.Add(TokenType.OperatorSemikeyword);
Semikeyword.Add(TokenType.OutSemikeyword);
Semikeyword.Add(TokenType.OverloadSemikeyword);
Semikeyword.Add(TokenType.OverrideSemikeyword);
Semikeyword.Add(TokenType.PackageSemikeyword);
Semikeyword.Add(TokenType.PascalSemikeyword);
Semikeyword.Add(TokenType.PlatformSemikeyword);
Semikeyword.Add(TokenType.PrivateSemikeyword);
Semikeyword.Add(TokenType.ProtectedSemikeyword);
Semikeyword.Add(TokenType.PublicSemikeyword);
Semikeyword.Add(TokenType.PublishedSemikeyword);
Semikeyword.Add(TokenType.ReadSemikeyword);
Semikeyword.Add(TokenType.ReadOnlySemikeyword);
Semikeyword.Add(TokenType.RegisterSemikeyword);
Semikeyword.Add(TokenType.ReintroduceSemikeyword);
Semikeyword.Add(TokenType.RequiresSemikeyword);
Semikeyword.Add(TokenType.ResidentSemikeyword);
Semikeyword.Add(TokenType.SafecallSemikeyword);
Semikeyword.Add(TokenType.SealedSemikeyword);
Semikeyword.Add(TokenType.StaticSemikeyword);
Semikeyword.Add(TokenType.StdcallSemikeyword);
Semikeyword.Add(TokenType.StoredSemikeyword);
Semikeyword.Add(TokenType.StrictSemikeyword);
Semikeyword.Add(TokenType.UnsafeSemikeyword);
Semikeyword.Add(TokenType.VarArgsSemikeyword);
Semikeyword.Add(TokenType.VirtualSemikeyword);
Semikeyword.Add(TokenType.WriteSemikeyword);
Semikeyword.Add(TokenType.WriteOnlySemikeyword);
UnaryOperator = new TokenSet("unary operator");
UnaryOperator.Add(TokenType.AtSign);
UnaryOperator.Add(TokenType.InheritedKeyword);
UnaryOperator.Add(TokenType.MinusSign);
UnaryOperator.Add(TokenType.NotKeyword);
UnaryOperator.Add(TokenType.PlusSign);
Uses = new TokenSet("uses clause");
Uses.Add(TokenType.UsesKeyword);
Uses.Add(TokenType.ContainsSemikeyword);
VarHeader = new TokenSet("var section");
VarHeader.Add(TokenType.VarKeyword);
VarHeader.Add(TokenType.ThreadVarKeyword);
VisibilitySingleWord = new TokenSet("'private', 'protected', 'public', or 'published'");
VisibilitySingleWord.Add(TokenType.PrivateSemikeyword);
VisibilitySingleWord.Add(TokenType.ProtectedSemikeyword);
VisibilitySingleWord.Add(TokenType.PublicSemikeyword);
VisibilitySingleWord.Add(TokenType.PublishedSemikeyword);
Ident = new TokenSet("identifier");
Ident.Add(TokenType.Identifier);
Ident.AddRange(Semikeyword);
IdentNoVisibility = new TokenSet("identifier no visibility");
IdentNoVisibility.AddRange(Ident);
IdentNoVisibility.RemoveRange(VisibilitySingleWord);
IdentNoVisibility.Remove(TokenType.StrictSemikeyword);
Directive.AddRange(PortabilityDirective);
Particle = new TokenSet("expression");
Particle.Add(TokenType.FileKeyword);
Particle.Add(TokenType.NilKeyword);
Particle.Add(TokenType.Number);
Particle.Add(TokenType.OpenBracket);
Particle.Add(TokenType.OpenParenthesis);
Particle.Add(TokenType.StringKeyword);
Particle.Add(TokenType.StringLiteral);
Particle.AddRange(Ident);
Expression = new TokenSet("expression");
Expression.AddRange(Particle);
Expression.AddRange(UnaryOperator);
Expression.Add(TokenType.FunctionKeyword);
Expression.Add(TokenType.ProcedureKeyword);
ExtendedIdent = new TokenSet("identifier (including keyword)");
ExtendedIdent.AddRange(Ident);
ExtendedIdent.AddRange(Keyword);
LabelId = new TokenSet("label");
LabelId.Add(TokenType.Number);
LabelId.AddRange(Ident);
Parameter = new TokenSet("parameter");
Parameter.AddRange(Ident);
Parameter.AddRange(ParameterModifier);
SimpleParameterType = new TokenSet("parameter type");
SimpleParameterType.Add(TokenType.FileKeyword);
SimpleParameterType.Add(TokenType.StringKeyword);
SimpleParameterType.AddRange(Ident);
Visibility = new TokenSet("visibility specifier");
Visibility.Add(TokenType.StrictSemikeyword);
Visibility.AddRange(VisibilitySingleWord);
}
private void ParseEnumMember(TypeExpression typeExpression, List<ITypeDeclarationMember> members, TokenSet followers)
//^ requires this.currentToken == Token.LeftBracket || Parser.IdentifierOrNonReservedKeyword[this.currentToken];
//^ ensures followers[this.currentToken] || this.currentToken == Token.EndOfFile;
{
SourceLocationBuilder sctx = new SourceLocationBuilder(this.scanner.SourceLocationOfLastScannedToken);
List<SourceCustomAttribute>/*?*/ attributes = this.ParseAttributes(followers|Parser.AttributeOrTypeDeclarationStart|Parser.IdentifierOrNonReservedKeyword);
if (!Parser.IdentifierOrNonReservedKeyword[this.currentToken])
this.HandleError(Error.ExpectedIdentifier);
NameDeclaration name = this.ParseNameDeclaration();
Expression/*?*/ initializer = null;
if (this.currentToken == Token.Assign) {
this.GetNextToken();
initializer = this.ParseExpression(followers);
}
EnumMember member = new EnumMember(attributes, typeExpression, name, initializer, sctx);
members.Add(member);
this.SkipTo(followers);
}
private void ParseNamespaceBody(List<INamespaceDeclarationMember> members, List<Ast.SourceCustomAttribute>/*?*/ sourceAttributes, TokenSet followers) {
tryAgain:
this.ParseExternalAliasDirectives(members, followers|Parser.AttributeOrNamespaceOrTypeDeclarationStart|Token.Using|Token.EndOfFile);
this.ParseUsingDirectives(members, followers|Parser.AttributeOrNamespaceOrTypeDeclarationStart|Token.Extern|Token.EndOfFile);
if (this.currentToken == Token.Extern) {
this.HandleError(Error.ExternAfterElements);
goto tryAgain;
}
if (sourceAttributes != null)
this.ParseAttributes(ref sourceAttributes, true, followers|Parser.NamespaceOrTypeDeclarationStart);
if (this.currentToken != Token.EndOfFile)
this.ParseNamespaceMemberDeclarations(members, followers);
members.TrimExcess();
}
private void ParseTypeMembers(SourceLocationBuilder sctx, IName typeName, List<ITypeDeclarationMember> members, TokenSet followers)
//^ ensures followers[this.currentToken] || this.currentToken == Token.EndOfFile;
{
TokenSet followersOrTypeMemberStart = followers|Parser.TypeMemberStart;
for (; ; ) {
SourceLocationBuilder tctx = new SourceLocationBuilder(this.scanner.SourceLocationOfLastScannedToken);
List<SourceCustomAttribute>/*?*/ attributes = this.ParseAttributes(followersOrTypeMemberStart);
List<ModifierToken> modifiers = this.ParseModifiers();
switch (this.currentToken) {
case Token.Class:
this.ParseNestedClassDeclaration(members, attributes, this.ConvertToTypeDeclarationFlags(modifiers), tctx, followersOrTypeMemberStart);
break;
case Token.Interface:
this.ParseNestedInterfaceDeclaration(members, attributes, this.ConvertToTypeDeclarationFlags(modifiers), tctx, followersOrTypeMemberStart);
break;
case Token.Struct:
this.ParseNestedStructDeclaration(members, attributes, this.ConvertToTypeDeclarationFlags(modifiers), tctx, followersOrTypeMemberStart);
break;
case Token.Enum:
this.ParseNestedEnumDeclaration(members, attributes, this.ConvertToTypeDeclarationFlags(modifiers), tctx, followersOrTypeMemberStart);
break;
case Token.Delegate:
this.ParseNestedDelegateDeclaration(members, attributes, this.ConvertToTypeDeclarationFlags(modifiers), tctx, followersOrTypeMemberStart);
break;
case Token.Const:
this.ParseConst(members, attributes, modifiers, tctx, followersOrTypeMemberStart);
break;
case Token.Invariant:
goto default;
//this.ParseInvariant(attributes, modifierTokens, modifierContexts, tctx, followersOrTypeMemberStart);
//break;
case Token.Bool:
case Token.Decimal:
case Token.Sbyte:
case Token.Byte:
case Token.Short:
case Token.Ushort:
case Token.Int:
case Token.Uint:
case Token.Long:
case Token.Ulong:
case Token.Char:
case Token.Float:
case Token.Double:
case Token.Object:
case Token.String:
case Token.Void:
case Token.Identifier:
this.ParseConstructorOrFieldOrMethodOrPropertyOrStaticInitializer(typeName, members, attributes, modifiers, tctx, followersOrTypeMemberStart);
break;
case Token.Event:
this.ParseEvent(members, attributes, modifiers, tctx, followersOrTypeMemberStart);
break;
case Token.Operator:
case Token.Explicit:
case Token.Implicit:
this.ParseOperator(members, attributes, modifiers, null, tctx, followersOrTypeMemberStart);
break;
case Token.BitwiseNot:
this.ParseDestructor(typeName, members, attributes, modifiers, tctx, followersOrTypeMemberStart);
break;
default:
if (Parser.IdentifierOrNonReservedKeyword[this.currentToken]) goto case Token.Identifier;
sctx.UpdateToSpan(this.scanner.SourceLocationOfLastScannedToken);
this.SkipTo(followers);
return;
}
}
}
private void ParseNestedEnumDeclaration(List<ITypeDeclarationMember> namespaceMembers, List<SourceCustomAttribute>/*?*/ attributes, TypeDeclaration.Flags flags, SourceLocationBuilder sctx, TokenSet followers)
//^ requires this.currentToken == Token.Enum;
//^ ensures followers[this.currentToken] || this.currentToken == Token.EndOfFile;
{
this.GetNextToken();
if (!Parser.IdentifierOrNonReservedKeyword[this.currentToken])
this.HandleError(Error.ExpectedIdentifier);
NameDeclaration name = this.ParseNameDeclaration();
TypeExpression/*?*/ underlyingType = null;
if (this.currentToken == Token.Colon) {
this.GetNextToken();
if (this.currentToken != Token.EndOfFile)
underlyingType = this.ParseTypeExpression(false, false, followers|Token.LeftBrace);
}
List<ITypeDeclarationMember> members = new List<ITypeDeclarationMember>();
NestedEnumDeclaration type = new NestedEnumDeclaration(attributes, flags, name, underlyingType, members, sctx);
namespaceMembers.Add(type);
this.ParseRestOfEnum(sctx, type, members, followers);
}
//^ [Pure]
public static TokenSet operator |(TokenSet ts, Token t){
TokenSet result = new TokenSet();
int i = (int)t;
if (i < 64){
result.bits0 = ts.bits0 | (1ul << i);
result.bits1 = ts.bits1;
result.bits2 = ts.bits2;
result.bits3 = ts.bits3;
}else if (i < 128){
result.bits0 = ts.bits0;
result.bits1 = ts.bits1 | (1ul << (i-64));
result.bits2 = ts.bits2;
result.bits3 = ts.bits3;
}else if (i < 192){
result.bits0 = ts.bits0;
result.bits1 = ts.bits1;
result.bits2 = ts.bits2 | (1ul << (i-128));
result.bits3 = ts.bits3;
}else{
result.bits0 = ts.bits0;
result.bits1 = ts.bits1;
result.bits2 = ts.bits2;
result.bits3 = ts.bits3 | (1ul << (i-192));
}
return result;
}
static Parser(){
AddOneOrSubtractOne = new TokenSet();
AddOneOrSubtractOne |= Token.AddOne;
AddOneOrSubtractOne |= Token.SubtractOne;
AddOrRemoveOrModifier = new TokenSet();
AddOrRemoveOrModifier |= Token.Add;
AddOrRemoveOrModifier |= Token.Remove;
AddOrRemoveOrModifier |= Token.New;
AddOrRemoveOrModifier |= Token.Public;
AddOrRemoveOrModifier |= Token.Protected;
AddOrRemoveOrModifier |= Token.Internal;
AddOrRemoveOrModifier |= Token.Private;
AddOrRemoveOrModifier |= Token.Abstract;
AddOrRemoveOrModifier |= Token.Sealed;
AddOrRemoveOrModifier |= Token.Static;
AddOrRemoveOrModifier |= Token.Readonly;
AddOrRemoveOrModifier |= Token.Volatile;
AddOrRemoveOrModifier |= Token.Virtual;
AddOrRemoveOrModifier |= Token.Override;
AddOrRemoveOrModifier |= Token.Extern;
AddOrRemoveOrModifier |= Token.Unsafe;
AssignmentOperators = new TokenSet();
AssignmentOperators |= Token.PlusAssign;
AssignmentOperators |= Token.Assign;
AssignmentOperators |= Token.BitwiseAndAssign;
AssignmentOperators |= Token.BitwiseOrAssign;
AssignmentOperators |= Token.BitwiseXorAssign;
AssignmentOperators |= Token.DivideAssign;
AssignmentOperators |= Token.LeftShiftAssign;
AssignmentOperators |= Token.MultiplyAssign;
AssignmentOperators |= Token.RemainderAssign;
AssignmentOperators |= Token.RightShiftAssign;
AssignmentOperators |= Token.SubtractAssign;
AttributeOrTypeDeclarationStart = new TokenSet();
AttributeOrTypeDeclarationStart |= Token.LeftBracket;
AttributeOrTypeDeclarationStart |= Token.New;
AttributeOrTypeDeclarationStart |= Token.Partial;
AttributeOrTypeDeclarationStart |= Token.Unsafe;
AttributeOrTypeDeclarationStart |= Token.Public;
AttributeOrTypeDeclarationStart |= Token.Internal;
AttributeOrTypeDeclarationStart |= Token.Abstract;
AttributeOrTypeDeclarationStart |= Token.Sealed;
AttributeOrTypeDeclarationStart |= Token.Static;
AttributeOrTypeDeclarationStart |= Token.Class;
AttributeOrTypeDeclarationStart |= Token.Delegate;
AttributeOrTypeDeclarationStart |= Token.Enum;
AttributeOrTypeDeclarationStart |= Token.Interface;
AttributeOrTypeDeclarationStart |= Token.Struct;
CaseOrDefaultOrRightBrace = new TokenSet();
CaseOrDefaultOrRightBrace |= Token.Case;
CaseOrDefaultOrRightBrace |= Token.Default;
CaseOrDefaultOrRightBrace |= Token.RightBrace;
CaseOrColonOrDefaultOrRightBrace = CaseOrDefaultOrRightBrace;
CaseOrColonOrDefaultOrRightBrace |= Token.Colon;
CatchOrFinally = new TokenSet();
CatchOrFinally |= Token.Catch;
CatchOrFinally |= Token.Finally;
ContractStart = new TokenSet();
ContractStart |= Token.Requires;
ContractStart |= Token.Modifies;
ContractStart |= Token.Ensures;
ContractStart |= Token.Throws;
EndOfFile = new TokenSet();
EndOfFile |= Token.EndOfFile;
GetOrLeftBracketOrSetOrModifier = new TokenSet();
GetOrLeftBracketOrSetOrModifier |= Token.Get;
GetOrLeftBracketOrSetOrModifier |= Token.LeftBracket;
GetOrLeftBracketOrSetOrModifier |= Token.Set;
GetOrLeftBracketOrSetOrModifier |= Token.New;
GetOrLeftBracketOrSetOrModifier |= Token.Public;
GetOrLeftBracketOrSetOrModifier |= Token.Protected;
GetOrLeftBracketOrSetOrModifier |= Token.Internal;
GetOrLeftBracketOrSetOrModifier |= Token.Private;
GetOrLeftBracketOrSetOrModifier |= Token.Abstract;
GetOrLeftBracketOrSetOrModifier |= Token.Sealed;
GetOrLeftBracketOrSetOrModifier |= Token.Static;
GetOrLeftBracketOrSetOrModifier |= Token.Readonly;
GetOrLeftBracketOrSetOrModifier |= Token.Volatile;
GetOrLeftBracketOrSetOrModifier |= Token.Virtual;
GetOrLeftBracketOrSetOrModifier |= Token.Override;
GetOrLeftBracketOrSetOrModifier |= Token.Extern;
GetOrLeftBracketOrSetOrModifier |= Token.Unsafe;
IdentifierOrNonReservedKeyword = new TokenSet();
IdentifierOrNonReservedKeyword |= Token.Identifier;
IdentifierOrNonReservedKeyword |= Token.Acquire;
IdentifierOrNonReservedKeyword |= Token.Add;
IdentifierOrNonReservedKeyword |= Token.Alias;
IdentifierOrNonReservedKeyword |= Token.Assert;
IdentifierOrNonReservedKeyword |= Token.Assume;
IdentifierOrNonReservedKeyword |= Token.Count;
IdentifierOrNonReservedKeyword |= Token.Ensures;
IdentifierOrNonReservedKeyword |= Token.Exists;
IdentifierOrNonReservedKeyword |= Token.Expose;
IdentifierOrNonReservedKeyword |= Token.Forall;
IdentifierOrNonReservedKeyword |= Token.Get;
IdentifierOrNonReservedKeyword |= Token.Modifies;
IdentifierOrNonReservedKeyword |= Token.Old;
IdentifierOrNonReservedKeyword |= Token.Otherwise;
IdentifierOrNonReservedKeyword |= Token.Partial;
IdentifierOrNonReservedKeyword |= Token.Read;
IdentifierOrNonReservedKeyword |= Token.Remove;
IdentifierOrNonReservedKeyword |= Token.Requires;
IdentifierOrNonReservedKeyword |= Token.Set;
IdentifierOrNonReservedKeyword |= Token.Throws;
IdentifierOrNonReservedKeyword |= Token.Unique;
IdentifierOrNonReservedKeyword |= Token.Value;
IdentifierOrNonReservedKeyword |= Token.Var;
IdentifierOrNonReservedKeyword |= Token.Write;
IdentifierOrNonReservedKeyword |= Token.Yield;
IdentifierOrNonReservedKeyword |= Token.Where;
InfixOperators = new TokenSet();
InfixOperators |= Token.PlusAssign;
InfixOperators |= Token.As;
InfixOperators |= Token.Assign;
InfixOperators |= Token.BitwiseAnd;
InfixOperators |= Token.BitwiseAndAssign;
InfixOperators |= Token.BitwiseOr;
InfixOperators |= Token.BitwiseOrAssign;
InfixOperators |= Token.BitwiseXor;
InfixOperators |= Token.BitwiseXorAssign;
InfixOperators |= Token.Conditional;
InfixOperators |= Token.Divide;
InfixOperators |= Token.DivideAssign;
InfixOperators |= Token.Equal;
InfixOperators |= Token.GreaterThan;
InfixOperators |= Token.GreaterThanOrEqual;
InfixOperators |= Token.Is;
//InfixOperators |= Token.Iff;
//InfixOperators |= Token.Implies;
InfixOperators |= Token.LeftShift;
InfixOperators |= Token.LeftShiftAssign;
InfixOperators |= Token.LessThan;
InfixOperators |= Token.LessThanOrEqual;
InfixOperators |= Token.LogicalAnd;
InfixOperators |= Token.LogicalOr;
//InfixOperators |= Token.Maplet;
InfixOperators |= Token.Multiply;
InfixOperators |= Token.MultiplyAssign;
InfixOperators |= Token.NotEqual;
InfixOperators |= Token.NullCoalescing;
InfixOperators |= Token.Plus;
//InfixOperators |= Token.Range;
InfixOperators |= Token.Remainder;
InfixOperators |= Token.RemainderAssign;
InfixOperators |= Token.RightShift;
InfixOperators |= Token.RightShiftAssign;
InfixOperators |= Token.Subtract;
InfixOperators |= Token.SubtractAssign;
InfixOperators |= Token.Arrow;
TypeStart = new TokenSet();
TypeStart |= Parser.IdentifierOrNonReservedKeyword;
TypeStart |= Token.Bool;
TypeStart |= Token.Decimal;
TypeStart |= Token.Sbyte;
TypeStart |= Token.Byte;
TypeStart |= Token.Short;
TypeStart |= Token.Ushort;
TypeStart |= Token.Int;
TypeStart |= Token.Uint;
TypeStart |= Token.Long;
TypeStart |= Token.Ulong;
TypeStart |= Token.Char;
TypeStart |= Token.Float;
TypeStart |= Token.Double;
TypeStart |= Token.Object;
TypeStart |= Token.String;
TypeStart |= Token.LeftBracket;
TypeStart |= Token.LeftParenthesis;
ParameterTypeStart = new TokenSet();
ParameterTypeStart |= Parser.TypeStart;
ParameterTypeStart |= Token.Ref;
ParameterTypeStart |= Token.Out;
ParameterTypeStart |= Token.Params;
PrimaryStart = new TokenSet();
PrimaryStart |= Parser.IdentifierOrNonReservedKeyword;
PrimaryStart |= Token.This;
PrimaryStart |= Token.Base;
PrimaryStart |= Token.Value;
PrimaryStart |= Token.New;
PrimaryStart |= Token.Typeof;
PrimaryStart |= Token.Sizeof;
PrimaryStart |= Token.Stackalloc;
PrimaryStart |= Token.Checked;
PrimaryStart |= Token.Unchecked;
PrimaryStart |= Token.HexLiteral;
PrimaryStart |= Token.IntegerLiteral;
PrimaryStart |= Token.StringLiteral;
PrimaryStart |= Token.CharLiteral;
PrimaryStart |= Token.RealLiteral;
PrimaryStart |= Token.Null;
PrimaryStart |= Token.False;
PrimaryStart |= Token.True;
PrimaryStart |= Token.Bool;
PrimaryStart |= Token.Decimal;
PrimaryStart |= Token.Sbyte;
PrimaryStart |= Token.Byte;
PrimaryStart |= Token.Short;
PrimaryStart |= Token.Ushort;
PrimaryStart |= Token.Int;
PrimaryStart |= Token.Uint;
PrimaryStart |= Token.Long;
PrimaryStart |= Token.Ulong;
PrimaryStart |= Token.Char;
PrimaryStart |= Token.Float;
PrimaryStart |= Token.Double;
PrimaryStart |= Token.Object;
PrimaryStart |= Token.String;
PrimaryStart |= Token.LeftParenthesis;
ProtectionModifier = new TokenSet();
ProtectionModifier |= Token.Public;
ProtectionModifier |= Token.Protected;
ProtectionModifier |= Token.Internal;
ProtectionModifier |= Token.Private;
NamespaceOrTypeDeclarationStart = new TokenSet();
NamespaceOrTypeDeclarationStart |= Token.Partial;
NamespaceOrTypeDeclarationStart |= Token.Unsafe;
NamespaceOrTypeDeclarationStart |= Token.Public;
NamespaceOrTypeDeclarationStart |= Token.Internal;
NamespaceOrTypeDeclarationStart |= Token.Abstract;
NamespaceOrTypeDeclarationStart |= Token.Sealed;
NamespaceOrTypeDeclarationStart |= Token.Static;
NamespaceOrTypeDeclarationStart |= Token.Namespace;
NamespaceOrTypeDeclarationStart |= Token.Class;
NamespaceOrTypeDeclarationStart |= Token.Delegate;
NamespaceOrTypeDeclarationStart |= Token.Enum;
NamespaceOrTypeDeclarationStart |= Token.Interface;
NamespaceOrTypeDeclarationStart |= Token.Struct;
AttributeOrNamespaceOrTypeDeclarationStart = AttributeOrTypeDeclarationStart;
AttributeOrNamespaceOrTypeDeclarationStart |= Token.Namespace;
AttributeOrNamespaceOrTypeDeclarationStart |= Token.Private; //For error recovery
AttributeOrNamespaceOrTypeDeclarationStart |= Token.Protected; //For error recovery
RightParenthesisOrSemicolon = new TokenSet();
RightParenthesisOrSemicolon |= Token.RightParenthesis;
RightParenthesisOrSemicolon |= Token.Semicolon;
TypeMemberStart = new TokenSet();
TypeMemberStart |= Token.LeftBracket;
TypeMemberStart |= Token.LeftParenthesis;
TypeMemberStart |= Token.LeftBrace;
TypeMemberStart |= Token.New;
TypeMemberStart |= Token.Partial;
TypeMemberStart |= Token.Public;
TypeMemberStart |= Token.Protected;
TypeMemberStart |= Token.Internal;
TypeMemberStart |= Token.Private;
TypeMemberStart |= Token.Abstract;
TypeMemberStart |= Token.Sealed;
TypeMemberStart |= Token.Static;
TypeMemberStart |= Token.Readonly;
TypeMemberStart |= Token.Volatile;
TypeMemberStart |= Token.Virtual;
TypeMemberStart |= Token.Override;
TypeMemberStart |= Token.Extern;
TypeMemberStart |= Token.Unsafe;
TypeMemberStart |= Token.Const;
TypeMemberStart |= Parser.IdentifierOrNonReservedKeyword;
TypeMemberStart |= Token.Event;
TypeMemberStart |= Token.This;
TypeMemberStart |= Token.Operator;
TypeMemberStart |= Token.BitwiseNot;
TypeMemberStart |= Token.Static;
TypeMemberStart |= Token.Class;
TypeMemberStart |= Token.Delegate;
TypeMemberStart |= Token.Enum;
TypeMemberStart |= Token.Interface;
TypeMemberStart |= Token.Struct;
TypeMemberStart |= Token.Bool;
TypeMemberStart |= Token.Decimal;
TypeMemberStart |= Token.Sbyte;
TypeMemberStart |= Token.Byte;
TypeMemberStart |= Token.Short;
TypeMemberStart |= Token.Ushort;
TypeMemberStart |= Token.Int;
TypeMemberStart |= Token.Uint;
TypeMemberStart |= Token.Long;
TypeMemberStart |= Token.Ulong;
TypeMemberStart |= Token.Char;
TypeMemberStart |= Token.Float;
TypeMemberStart |= Token.Double;
TypeMemberStart |= Token.Object;
TypeMemberStart |= Token.String;
TypeMemberStart |= Token.Void;
TypeMemberStart |= Token.Invariant;
TypeOperator = new TokenSet();
TypeOperator |= Token.LeftBracket;
TypeOperator |= Token.Multiply;
TypeOperator |= Token.Plus;
TypeOperator |= Token.Conditional;
TypeOperator |= Token.LogicalNot;
TypeOperator |= Token.BitwiseAnd;
UnaryStart = new TokenSet();
UnaryStart |= Parser.IdentifierOrNonReservedKeyword;
UnaryStart |= Token.LeftParenthesis;
UnaryStart |= Token.LeftBracket;
UnaryStart |= Token.This;
UnaryStart |= Token.Base;
UnaryStart |= Token.Value;
UnaryStart |= Token.AddOne;
UnaryStart |= Token.SubtractOne;
UnaryStart |= Token.New;
UnaryStart |= Token.Default;
UnaryStart |= Token.Typeof;
UnaryStart |= Token.Sizeof;
UnaryStart |= Token.Stackalloc;
UnaryStart |= Token.Delegate;
UnaryStart |= Token.Checked;
UnaryStart |= Token.Unchecked;
UnaryStart |= Token.HexLiteral;
UnaryStart |= Token.IntegerLiteral;
UnaryStart |= Token.StringLiteral;
UnaryStart |= Token.CharLiteral;
UnaryStart |= Token.RealLiteral;
UnaryStart |= Token.Null;
UnaryStart |= Token.False;
UnaryStart |= Token.True;
UnaryStart |= Token.Bool;
UnaryStart |= Token.Decimal;
UnaryStart |= Token.Sbyte;
UnaryStart |= Token.Byte;
UnaryStart |= Token.Short;
UnaryStart |= Token.Ushort;
UnaryStart |= Token.Int;
UnaryStart |= Token.Uint;
UnaryStart |= Token.Long;
UnaryStart |= Token.Ulong;
UnaryStart |= Token.Char;
UnaryStart |= Token.Float;
UnaryStart |= Token.Double;
UnaryStart |= Token.Object;
UnaryStart |= Token.String;
UnaryStart |= Token.Plus;
UnaryStart |= Token.BitwiseNot;
UnaryStart |= Token.LogicalNot;
UnaryStart |= Token.Multiply;
UnaryStart |= Token.Subtract;
UnaryStart |= Token.AddOne;
UnaryStart |= Token.SubtractOne;
UnaryStart |= Token.Multiply;
UnaryStart |= Token.BitwiseAnd;
StatementStart = new TokenSet();
StatementStart |= Parser.UnaryStart;
StatementStart |= Token.LeftBrace;
StatementStart |= Token.Semicolon;
StatementStart |= Token.Acquire;
StatementStart |= Token.Assert;
StatementStart |= Token.Assume;
StatementStart |= Token.If;
StatementStart |= Token.Switch;
StatementStart |= Token.While;
StatementStart |= Token.Do;
StatementStart |= Token.For;
StatementStart |= Token.Foreach;
StatementStart |= Token.While;
StatementStart |= Token.Break;
StatementStart |= Token.Continue;
StatementStart |= Token.Goto;
StatementStart |= Token.Return;
StatementStart |= Token.Throw;
StatementStart |= Token.Yield;
StatementStart |= Token.Try;
StatementStart |= Token.Catch; //Not really, but helps error recovery
StatementStart |= Token.Finally; //Not really, but helps error recovery
StatementStart |= Token.Checked;
StatementStart |= Token.Unchecked;
StatementStart |= Token.Read;
StatementStart |= Token.Write;
StatementStart |= Token.Expose;
StatementStart |= Token.Fixed;
StatementStart |= Token.Lock;
StatementStart |= Token.Unsafe;
StatementStart |= Token.Using;
StatementStart |= Token.Const;
StatementStart |= Token.Delegate;
StatementStart |= Token.Void;
Term = new TokenSet();
Term |= Token.ArgList;
Term |= Token.MakeRef;
Term |= Token.RefType;
Term |= Token.RefValue;
Term |= Token.Base;
Term |= Token.Checked;
Term |= Token.Default;
Term |= Token.Delegate;
Term |= Token.False;
Term |= Token.New;
Term |= Token.Null;
Term |= Token.Sizeof;
Term |= Token.This;
Term |= Token.True;
Term |= Token.Typeof;
Term |= Token.Unchecked;
Term |= Token.Identifier;
Term |= Token.IntegerLiteral;
Term |= Token.RealLiteral;
Term |= Token.StringLiteral;
Term |= Token.CharLiteral;
Term |= Token.LeftParenthesis;
Predefined = new TokenSet();
Predefined |= Token.Bool;
Predefined |= Token.Decimal;
Predefined |= Token.Sbyte;
Predefined |= Token.Byte;
Predefined |= Token.Short;
Predefined |= Token.Ushort;
Predefined |= Token.Int;
Predefined |= Token.Uint;
Predefined |= Token.Long;
Predefined |= Token.Ulong;
Predefined |= Token.Char;
Predefined |= Token.Float;
Predefined |= Token.Double;
Predefined |= Token.Object;
Predefined |= Token.String;
Predefined |= Token.Void;
UnaryOperator = new TokenSet();
UnaryOperator |= Token.Base;
UnaryOperator |= Token.Default;
UnaryOperator |= Token.Sizeof;
UnaryOperator |= Token.This;
UnaryOperator |= Token.Typeof;
UnaryOperator |= Token.BitwiseAnd;
UnaryOperator |= Token.Plus;
UnaryOperator |= Token.Subtract;
UnaryOperator |= Token.Multiply;
UnaryOperator |= Token.BitwiseNot;
UnaryOperator |= Token.LogicalNot;
UnaryOperator |= Token.AddOne;
UnaryOperator |= Token.SubtractOne;
NullableTypeNonFollower = Term | Predefined | UnaryOperator;
TypeArgumentListNonFollower = NullableTypeNonFollower;
//TypeArgumentListNonFollower[Token.LeftParenthesis] = false;
CastFollower = IdentifierOrNonReservedKeyword;
CastFollower |= Token.LeftParenthesis;
CastFollower |= Token.This;
CastFollower |= Token.Base;
CastFollower |= Token.Value;
CastFollower |= Token.AddOne;
CastFollower |= Token.SubtractOne;
CastFollower |= Token.New;
CastFollower |= Token.Default;
CastFollower |= Token.Typeof;
CastFollower |= Token.Sizeof;
CastFollower |= Token.Stackalloc;
CastFollower |= Token.Delegate;
CastFollower |= Token.Checked;
CastFollower |= Token.Unchecked;
CastFollower |= Token.HexLiteral;
CastFollower |= Token.IntegerLiteral;
CastFollower |= Token.StringLiteral;
CastFollower |= Token.CharLiteral;
CastFollower |= Token.RealLiteral;
CastFollower |= Token.Null;
CastFollower |= Token.False;
CastFollower |= Token.True;
CastFollower |= Token.Bool;
CastFollower |= Token.Decimal;
CastFollower |= Token.Sbyte;
CastFollower |= Token.Byte;
CastFollower |= Token.Short;
CastFollower |= Token.Ushort;
CastFollower |= Token.Int;
CastFollower |= Token.Uint;
CastFollower |= Token.Long;
CastFollower |= Token.Ulong;
CastFollower |= Token.Char;
CastFollower |= Token.Float;
CastFollower |= Token.Double;
CastFollower |= Token.Object;
CastFollower |= Token.String;
CastFollower |= Token.BitwiseNot;
CastFollower |= Token.LogicalNot;
CastFollower |= Token.Delegate;
}
private void ParseBaseTypes(List<TypeExpression> baseTypes, TokenSet followers)
//^ ensures followers[this.currentToken] || this.currentToken == Token.EndOfFile;
{
if (this.currentToken == Token.Colon) {
this.GetNextToken();
TokenSet baseTypeStart = Parser.IdentifierOrNonReservedKeyword|Parser.Predefined;
while (baseTypeStart[this.currentToken]) {
//^ assume this.currentToken != Token.EndOfFile;
baseTypes.Add(this.ParseTypeExpression(false, false, followers|Token.Comma));
if (this.currentToken != Token.Comma) break;
this.GetNextToken();
}
}
this.SkipTo(followers);
}
private void ParseGenericTypeParameters(List<Ast.GenericTypeParameterDeclaration> genericParameters, TokenSet followers) {
if (this.currentToken != Token.LessThan) return;
this.GetNextToken();
while (this.currentToken != Token.GreaterThan && this.currentToken != Token.Colon && this.currentToken != Token.LeftBrace && this.currentToken != Token.EndOfFile) {
List<SourceCustomAttribute>/*?*/ attributes = this.ParseAttributes(followers|Parser.IdentifierOrNonReservedKeyword);
if (!Parser.IdentifierOrNonReservedKeyword[this.currentToken])
this.HandleError(Error.ExpectedIdentifier);
NameDeclaration name = this.ParseNameDeclaration();
genericParameters.Add(new SpecSharpGenericTypeParameterDeclaration(attributes, name, (ushort)genericParameters.Count));
if (this.currentToken != Token.Comma) break;
this.GetNextToken();
}
if (this.currentToken == Token.RightShift)
this.currentToken = Token.GreaterThan;
else
this.SkipOverTo(Token.GreaterThan, followers);
}
private void ParseRestOfEnum(SourceLocationBuilder sctx, TypeDeclaration type, List<ITypeDeclarationMember> members, TokenSet followers)
//^ ensures followers[this.currentToken] || this.currentToken == Token.EndOfFile;
{
TypeExpression texpr = new NamedTypeExpression(new SimpleName(type.Name, type.Name.SourceLocation, false));
this.Skip(Token.LeftBrace);
while (this.currentToken == Token.LeftBracket || Parser.IdentifierOrNonReservedKeyword[this.currentToken]){
this.ParseEnumMember(texpr, members, followers|Token.Comma|Token.RightBrace);
if (this.currentToken == Token.RightBrace) break;
this.Skip(Token.Comma);
if (this.currentToken == Token.RightBrace) break;
}
sctx.UpdateToSpan(this.scanner.SourceLocationOfLastScannedToken);
this.Skip(Token.RightBrace);
if (this.currentToken == Token.Semicolon)
this.GetNextToken();
this.SkipTo(followers);
}
//^ [Pure]
public static TokenSet operator|(TokenSet ts1, TokenSet ts2) {
TokenSet result = new TokenSet();
result.bits0 = ts1.bits0 | ts2.bits0;
result.bits1 = ts1.bits1 | ts2.bits1;
result.bits2 = ts1.bits2 | ts2.bits2;
result.bits3 = ts1.bits3 | ts2.bits3;
return result;
}
private void ParseAttributes(ref List<SourceCustomAttribute>/*?*/ sourceAttributes, bool globalAttributes, TokenSet followers) {
while (this.currentToken == Token.LeftBracket) {
int position = this.scanner.CurrentDocumentPosition();
this.GetNextToken();
AttributeTargets target = this.ParseAttributeTarget();
if (globalAttributes) {
if (target != AttributeTargets.Assembly && target != AttributeTargets.Module) {
this.scanner.RestoreDocumentPosition(position);
this.currentToken = Token.None;
this.GetNextToken();
return;
}
}
while (true) {
Expression expr = this.ParseExpression(followers|Token.Comma|Token.RightBracket);
MethodCall/*?*/ mcall = expr as MethodCall;
if (mcall != null && (mcall.MethodExpression is SimpleName || mcall.MethodExpression is QualifiedName || mcall.MethodExpression is AliasQualifiedName)) {
AttributeTypeExpression type = new AttributeTypeExpression(mcall.MethodExpression);
List<Expression> arguments = new List<Expression>(mcall.OriginalArguments);
bool seenNamedArgument = false;
for (int i = 0, n = arguments.Count; i < n; i++) {
Assignment/*?*/ assignment = arguments[i] as Assignment;
if (assignment == null) {
if (seenNamedArgument)
this.HandleError(arguments[i].SourceLocation, Error.NamedArgumentExpected);
continue;
}
SimpleName/*?*/ name = assignment.Target.Expression as SimpleName;
if (name == null) {
this.HandleError(assignment.Target.SourceLocation, Error.ExpectedIdentifier);
name = new SimpleName(Dummy.Name, assignment.Target.SourceLocation, false);
}
seenNamedArgument = true;
arguments[i] = new NamedArgument(name, assignment.Source, assignment.SourceLocation);
}
if (sourceAttributes == null) sourceAttributes = new List<SourceCustomAttribute>(1);
sourceAttributes.Add(new SourceCustomAttribute(target, type, arguments, mcall.SourceLocation));
} else if (expr is SimpleName || expr is QualifiedName || expr is AliasQualifiedName) {
AttributeTypeExpression type = new AttributeTypeExpression(expr);
if (sourceAttributes == null) sourceAttributes = new List<SourceCustomAttribute>(1);
sourceAttributes.Add(new SourceCustomAttribute(target, type, new List<Expression>(0), expr.SourceLocation));
} else {
this.HandleError(expr.SourceLocation, Error.ExpectedIdentifier);
}
if (this.currentToken != Token.Comma) break;
this.GetNextToken();
}
this.Skip(Token.RightBracket);
}
if (sourceAttributes != null) sourceAttributes.TrimExcess();
}
private void ParseNestedStructDeclaration(List<ITypeDeclarationMember> typeMembers, List<SourceCustomAttribute>/*?*/ attributes, TypeDeclaration.Flags flags, SourceLocationBuilder sctx, TokenSet followers)
//^ requires this.currentToken == Token.Struct;
//^ ensures followers[this.currentToken] || this.currentToken == Token.EndOfFile;
{
this.GetNextToken();
if (!Parser.IdentifierOrNonReservedKeyword[this.currentToken])
this.HandleError(Error.ExpectedIdentifier);
NameDeclaration name = this.ParseNameDeclaration();
List<Ast.GenericTypeParameterDeclaration> genericParameters = new List<Ast.GenericTypeParameterDeclaration>();
List<TypeExpression> baseTypes = new List<TypeExpression>();
List<ITypeDeclarationMember> members = new List<ITypeDeclarationMember>();
NestedStructDeclaration type = new NestedStructDeclaration(attributes, flags, name, genericParameters, baseTypes, members, sctx);
typeMembers.Add(type);
this.ParseRestOfTypeDeclaration(sctx, type, genericParameters, baseTypes, members, followers);
}
private void ParseNestedDelegateDeclaration(List<ITypeDeclarationMember> typeMembers, List<SourceCustomAttribute>/*?*/ attributes, TypeDeclaration.Flags flags, SourceLocationBuilder sctx, TokenSet followers)
//^ requires this.currentToken == Token.Delegate;
//^ ensures followers[this.currentToken] || this.currentToken == Token.EndOfFile;
{
this.GetNextToken();
TypeExpression returnType = this.ParseTypeExpression(false, false, followers|Token.LeftParenthesis|Token.Semicolon|Parser.IdentifierOrNonReservedKeyword);
if (!Parser.IdentifierOrNonReservedKeyword[this.currentToken])
this.HandleError(Error.ExpectedIdentifier);
NameDeclaration name = this.ParseNameDeclaration();
List<Ast.GenericTypeParameterDeclaration> genericParameters = new List<Ast.GenericTypeParameterDeclaration>();
List<Ast.ParameterDeclaration> parameters = new List<Ast.ParameterDeclaration>();
SignatureDeclaration signature = new SignatureDeclaration(returnType, parameters, sctx);
NestedDelegateDeclaration type = new NestedDelegateDeclaration(attributes, flags, name, genericParameters, signature, sctx);
typeMembers.Add(type);
this.ParseGenericTypeParameters(genericParameters, followers|Token.LeftParenthesis|Token.Where|Token.Semicolon);
this.ParseParameters(parameters, Token.RightParenthesis, followers|Token.Where|Token.Semicolon, sctx);
this.ParseGenericTypeParameterConstraintsClauses(genericParameters, followers|Token.Semicolon);
sctx.UpdateToSpan(this.scanner.SourceLocationOfLastScannedToken);
if (this.currentToken == Token.Semicolon)
this.GetNextToken();
this.SkipTo(followers);
}
private void ParseRestOfTypeDeclaration(SourceLocationBuilder sctx, TypeDeclaration type, List<Ast.GenericTypeParameterDeclaration> genericParameters,
List<TypeExpression> baseTypes, List<ITypeDeclarationMember> members, TokenSet followers)
//^ ensures followers[this.currentToken] || this.currentToken == Token.EndOfFile;
{
this.ParseGenericTypeParameters(genericParameters, followers|Token.Colon|Token.LeftBrace|Token.Where);
this.ParseBaseTypes(baseTypes, followers|Token.LeftBrace|Token.Where);
this.ParseGenericTypeParameterConstraintsClauses(genericParameters, followers|Token.LeftBrace);
this.Skip(Token.LeftBrace);
this.ParseTypeMembers(sctx, type.Name, members, followers|Token.RightBrace);
ISourceLocation tokLoc = this.scanner.SourceLocationOfLastScannedToken;
//^ assume tokLoc.SourceDocument == sctx.SourceDocument;
sctx.UpdateToSpan(tokLoc);
this.Skip(Token.RightBrace);
if (this.currentToken == Token.Semicolon)
this.GetNextToken();
this.SkipTo(followers);
}
private List<SourceCustomAttribute>/*?*/ ParseAttributes(TokenSet followers) {
List<SourceCustomAttribute>/*?*/ result = null;
this.ParseAttributes(ref result, false, followers);
this.SkipTo(followers);
return result;
}
