public override void ExitXppclassModifiers([NotNull] XP.XppclassModifiersContext context)
{
SyntaxListBuilder modifiers = _pool.Allocate();
foreach (var m in context._Tokens)
{
SyntaxToken kw = null;
switch (m.Type)
{
case XP.STATIC:
kw = SyntaxFactory.MakeToken(SyntaxKind.InternalKeyword, m.Text);
// todo place in unique namespace
break;
case XP.FINAL:
kw = SyntaxFactory.MakeToken(SyntaxKind.SealedKeyword, m.Text);
break;
default:
break;
}
if (kw != null)
{
modifiers.AddCheckUnique(kw);
}
}
context.PutList(modifiers.ToList <SyntaxToken>());
_pool.Free(modifiers);
}
private JavaPackageDeclarationSyntax ParsePackageDeclaration(ref SyntaxListBuilder <AnnotationSyntax> pendingAnnotations)
{
if (this.IsIncrementalAndFactoryContextMatches && this.CurrentNodeKind == SyntaxKind.JavaPackageDeclaration)
{
return((JavaPackageDeclarationSyntax)this.EatNode());
}
Debug.Assert(this.CurrentToken.Kind == SyntaxKind.PackageKeyword);
var usingToken = this.EatToken(SyntaxKind.PackageKeyword);
NameSyntax name;
SyntaxToken semicolon;
if (IsPossiblePackageMemberDeclaration())
{
//We're worried about the case where someone already has a correct program
//and they've gone back to add a using directive, but have not finished the
//new directive. e.g.
//
// using
// namespace Foo {
// //...
// }
//
//If the token we see after "using" could be its own top-level construct, then
//we just want to insert a missing identifier and semicolon and then return to
//parsing at the top-level.
//
//NB: there's no way this could be true for a set of tokens that form a valid
//using directive, so there's no danger in checking the error case first.
name = WithAdditionalDiagnostics(CreateMissingIdentifierName(), GetExpectedTokenError(SyntaxKind.IdentifierToken, this.CurrentToken.Kind));
semicolon = SyntaxFactory.MissingToken(SyntaxKind.SemicolonToken);
}
else
{
name = this.ParseQualifiedName();
if (NameContainsGeneric(name))
{
// We're not allowed to have generics.
name = this.AddError(name, ErrorCode.ERR_UnexpectedGenericName);
}
if (name.IsMissing && this.PeekToken(1).Kind == SyntaxKind.SemicolonToken)
{
//if we can see a semicolon ahead, then the current token was
//probably supposed to be an identifier
name = AddTrailingSkippedSyntax(name, this.EatToken());
}
semicolon = this.EatToken(SyntaxKind.SemicolonToken);
}
return(_syntaxFactory.JavaPackageDeclaration(pendingAnnotations.ToList(), usingToken, name, semicolon));
}
private SkippedTokensTriviaSyntax FileAsTrivia(SourceText text)
{
var builder = new SyntaxListBuilder(1);
builder.Add(SyntaxFactory.BadToken(null, text.ToString(), null));
var fileAsTrivia = _syntaxFactory.SkippedTokensTrivia(builder.ToList <SyntaxToken>());
ForceEndOfFile(); // force the scanner to report that it is at the end of the input.
return(fileAsTrivia);
}
public override void ExitXppdeclareModifiers([NotNull] XP.XppdeclareModifiersContext context)
{
SyntaxListBuilder modifiers = _pool.Allocate();
bool hasFinal = false;
bool noOverRide = false;
foreach (var m in context._Tokens)
{
SyntaxToken kw = null;
switch (m.Type)
{
case XP.DEFERRED: // DEFERRED METHOD becomes ABSTRACT METHOD
kw = SyntaxFactory.MakeToken(SyntaxKind.AbstractKeyword, m.Text);
break;
case XP.FINAL: // FINAL METHOD will generate non virtual method, even when the Default Virtual is on
hasFinal = true;
break;
case XP.INTRODUCE: // INTRODUCE METHOD will generate NEW METHOD
kw = SyntaxFactory.MakeToken(SyntaxKind.NewKeyword, m.Text);
noOverRide = true;
break;
case XP.OVERRIDE: // OVERRIDE METHOD is obvious
kw = SyntaxFactory.MakeToken(SyntaxKind.OverrideKeyword, m.Text);
break;
case XP.CLASS:
kw = SyntaxFactory.MakeToken(SyntaxKind.StaticKeyword, m.Text);
break;
case XP.SYNC: // Handled later
break;
default:
break;
}
if (kw != null)
{
modifiers.AddCheckUnique(kw);
}
}
if (_options.VirtualInstanceMethods && !hasFinal)
{
modifiers.FixDefaultVirtual();
}
else if (!noOverRide && !hasFinal)
{
modifiers.FixDefaultMethod();
}
context.PutList(modifiers.ToList <SyntaxToken>());
_pool.Free(modifiers);
}
private JavaClassBodySyntax ParseJavaClassBody(SyntaxToken name)
{
// Parse class body
bool parseMembers = true;
SyntaxListBuilder <MemberDeclarationSyntax> members = default(SyntaxListBuilder <MemberDeclarationSyntax>);
try
{
var openBrace = this.EatToken(SyntaxKind.OpenBraceToken);
// ignore members if missing type name or missing open curly
if (name.IsMissing || openBrace.IsMissing)
{
parseMembers = false;
}
// even if we saw a { or think we should parse members bail out early since
// we know namespaces can't be nested inside types
if (parseMembers)
{
members = this._pool.Allocate <MemberDeclarationSyntax>();
this.ParseJavaNormalClassMembers(ref members, ref openBrace, name);
}
var closeBrace = this.EatToken(SyntaxKind.CloseBraceToken);
SyntaxToken semicolon = null;
if (this.CurrentToken.Kind == SyntaxKind.SemicolonToken)
{
semicolon = this.EatToken();
}
return(_syntaxFactory.JavaClassBody(openBrace, members.ToList(), closeBrace, semicolon));
}
finally
{
if (!members.IsNull)
{
this._pool.Free(members);
}
}
}
internal TNode ConsumeUnexpectedTokens <TNode>(TNode node) where TNode : CSharpSyntaxNode
{
if (this.CurrentToken.Kind == SyntaxKind.EndOfFileToken)
{
return(node);
}
SyntaxListBuilder <SyntaxToken> b = this._pool.Allocate <SyntaxToken>();
while (this.CurrentToken.Kind != SyntaxKind.EndOfFileToken)
{
b.Add(this.EatToken());
}
var trailingTrash = b.ToList();
this._pool.Free(b);
node = this.AddError(node, ErrorCode.ERR_UnexpectedCharacter, trailingTrash[0].ToString());
// TODO: better diagnostic?
node = this.AddTrailingSkippedSyntax(node, trailingTrash.Node);
return(node);
}
public SyntaxList <TNode> ToList()
{
return(_builder.ToList());
}
private SkippedTokensTriviaSyntax ParserErrorsAsTrivia(List <ParseErrorData> parseErrors, IDictionary <string, SourceText> includes)
{
// create one syntax token per error
// and one syntax token for the main file
// these tokens will get as many errors as needed.
// We are only includin 1 syntax error per file (1003) and one parse error (9002)
var textNode = SyntaxFactory.BadToken(null, _text.ToString(), null);
var builder = new SyntaxListBuilder(parseErrors.Count + 1);
if (!parseErrors.IsEmpty())
{
bool hasSyntaxError = false;
bool hasParserError = false;
foreach (var e in parseErrors)
{
bool add = true;
if (e.Code == ErrorCode.ERR_SyntaxError)
{
add = !hasSyntaxError;
hasSyntaxError = true;
}
else if (e.Code == ErrorCode.ERR_ParserError)
{
add = !hasParserError;
hasParserError = true;
}
if (!add)
{
continue;
}
if (e.Node != null)
{
var node = e.Node;
var key = node.SourceFileName;
int pos = node.Position;
int len = node.FullWidth;
if (node.SourceSymbol != null)
{
var sym = node.SourceSymbol as XSharpToken;
key = sym.SourceName;
pos = sym.Position;
len = sym.FullWidth;
}
if (len <= 0 || pos < 0)
{
if (e.Node.Parent != null)
{
var xNode = e.Node as IXParseTree;
pos = xNode.Position;
len = xNode.FullWidth;
}
if (pos < 0)
{
pos = 0;
}
if (len <= 0)
{
len = 1;
}
}
SourceText inc = null;
if (key != null && includes.ContainsKey(key))
{
inc = includes[key];
if (pos - 1 + len > inc.Length)
{
len = inc.Length - pos + 1;
}
}
var diag = new SyntaxDiagnosticInfo(pos, len, e.Code, e.Args);
if (inc != null)
{
var incNode = SyntaxFactory.BadToken(null, inc.ToString(), null);
incNode = incNode.WithAdditionalDiagnostics(diag);
incNode.XNode = e.Node;
builder.Add(incNode);
}
else
{
textNode = textNode.WithAdditionalDiagnostics(diag);
}
}
else
{
textNode = textNode.WithAdditionalDiagnostics(new SyntaxDiagnosticInfo(e.Code, e.Args));
}
}
}
else
{
if (_options.ParseLevel == ParseLevel.Complete)
{
textNode = textNode.WithAdditionalDiagnostics(new SyntaxDiagnosticInfo(ErrorCode.ERR_ParserError, "Unknown error"));
}
}
builder.Add(textNode);
return(_syntaxFactory.SkippedTokensTrivia(builder.ToList <SyntaxToken>()));
}
private JavaAnonymousClassInitializerExpressionSyntax ParseJavaAnonymousClassBody()
{
bool parseMembers = true;
SyntaxListBuilder <MemberDeclarationSyntax> members = default(SyntaxListBuilder <MemberDeclarationSyntax>);
try
{
var openBrace = this.EatToken(SyntaxKind.OpenBraceToken);
// ignore members if missing type name or missing open curly
if (openBrace.IsMissing)
{
parseMembers = false;
}
// even if we saw a { or think we should parse members bail out early since
// we know namespaces can't be nested inside types
if (parseMembers)
{
members = this._pool.Allocate <MemberDeclarationSyntax>();
this.ParseJavaNormalClassMembers(ref members, ref openBrace, null);
}
var closeBrace = this.EatToken(SyntaxKind.CloseBraceToken);
return(_syntaxFactory.JavaAnonymousClassInitializerExpression(openBrace, members.ToList(), closeBrace));
}
finally
{
if (!members.IsNull)
{
this._pool.Free(members);
}
}
}
private SyntaxList <SyntaxToken> decodeXppMemberModifiers(int visibility, bool isStatic, IList <IToken> tokens = null)
{
SyntaxListBuilder modifiers = _pool.Allocate();
if (isStatic)
{
modifiers.Add(SyntaxFactory.MakeToken(SyntaxKind.StaticKeyword, "CLASS"));
}
else
{
modifiers.Add(DecodeVisibility(visibility));
}
if (tokens != null)
{
foreach (var token in tokens)
{
SyntaxToken kw = null;
switch (token.Type)
{
// Member Modifiers from XppMemberModifiers rule
case XP.CLASS:
kw = SyntaxFactory.MakeToken(SyntaxKind.StaticKeyword, token.Text);
break;
case XP.STATIC:
// remove visibility modifiers
// STATIC CLASS (Visibility only in the scope of the prg).
// class becomes Internal and is added to the static globals class
kw = SyntaxFactory.MakeToken(SyntaxKind.InternalKeyword, token.Text);
var tmp = modifiers.ToList();
modifiers.Clear();
foreach (SyntaxToken mod in tmp)
{
// remove all existing visibility keywords
switch (mod.Kind)
{
case SyntaxKind.ProtectedKeyword:
case SyntaxKind.PublicKeyword:
case SyntaxKind.PrivateKeyword:
case SyntaxKind.InternalKeyword:
break;
default:
modifiers.Add(mod);
break;
}
}
break;
}
if (kw != null)
{
modifiers.AddCheckUnique(kw);
}
}
}
var result = modifiers.ToList <SyntaxToken>();
_pool.Free(modifiers);
return(result);
}
private JavaEnumBodyDeclarationsSyntax ParseJavaEnumBodyDeclarations(ref SyntaxToken openBrace, SyntaxToken name)
{
if (this.IsIncrementalAndFactoryContextMatches && this.CurrentNodeKind == SyntaxKind.JavaEnumBodyDeclarations)
{
return((JavaEnumBodyDeclarationsSyntax)this.EatNode());
}
if (this.CurrentToken.Kind == SyntaxKind.SemicolonToken)
{
var semToken = this.EatToken(SyntaxKind.SemicolonToken);
SyntaxListBuilder <MemberDeclarationSyntax> classBodyMembers = default(SyntaxListBuilder <MemberDeclarationSyntax>);
try
{
classBodyMembers = this._pool.Allocate <MemberDeclarationSyntax>();
this.ParseJavaNormalClassMembers(ref classBodyMembers, ref openBrace, name);
var enumClassBody = _syntaxFactory.JavaEnumBodyDeclarations(semToken, classBodyMembers.Count == 0 ? null : classBodyMembers.ToList());
return(enumClassBody);
}
finally
{
if (!classBodyMembers.IsNull)
{
this._pool.Free(classBodyMembers);
}
}
}
return(null);
}
