void buildPackageDocumentation(String packageName, PackageDeclarationNode packageDeclaration) {
var comment = ParserHelper.decodeDocumentation(context.Text, packageDeclaration.DocumentationOffset,
packageDeclaration.DocumentationLength);
memberKind = null;
node = packageDeclaration;
appendDocumentation("N:" + packageName, comment);
}
void buildPackageDocumentation(String packageName, PackageDeclarationNode packageDeclaration)
{
var comment = ParserHelper.decodeDocumentation(context.Text, packageDeclaration.DocumentationOffset,
packageDeclaration.DocumentationLength);
memberKind = null;
node = packageDeclaration;
appendDocumentation("N:" + packageName, comment);
}
private void setBaseTypes(PackageDeclarationNode packageDeclaration) {
if (packageDeclaration.Body != null) {
foreach (var identifier in packageDeclaration.Identifiers) {
context.MemberResolver.enterPackage(context.getIdentifier(identifier.Offset, identifier.Length));
}
try {
setBaseTypes(packageDeclaration.Body);
} finally {
for (int i = packageDeclaration.Identifiers.size() - 1; i >= 0; --i) {
context.MemberResolver.leavePackage();
}
}
}
}
private String getPackageName(String outerPackage, PackageDeclarationNode packageDeclaration, char separator) {
var sb = new StringBuilder();
var first = true;
if (!Helper.isNullOrEmpty(outerPackage)) {
sb.append(outerPackage);
first = false;
}
foreach (var identifier in packageDeclaration.Identifiers) {
if (first) {
first = false;
} else {
sb.append(separator);
}
var id = context.getIdentifier(identifier.Offset, identifier.Length);
sb.append(id);
identifier.addUserData(id);
}
return sb.toString();
}
private void defineTypes(String packageName, PackageDeclarationNode packageDeclaration) {
if (packageDeclaration.Body != null) {
defineTypes(getPackageName(packageName, packageDeclaration, '/'), packageDeclaration.Body);
}
}
private void generateAnnotations(PackageDeclarationNode packageDeclaration, bool annotationTypesOnly) {
if (packageDeclaration.Body != null) {
foreach (var identifier in packageDeclaration.Identifiers) {
context.MemberResolver.enterPackage(context.getIdentifier(identifier.Offset, identifier.Length));
}
if (!annotationTypesOnly && packageDeclaration.Annotations.size() > 0) {
validateAnnotationSection(packageDeclaration.Annotations, ElementType.PACKAGE);
var packageInfoName = context.MemberResolver.getCurrentPackage() + "/package-info";
if (!context.TypeSystem.typeExists(packageInfoName)) {
var t = context.TypeSystem.defineType(packageInfoName);
context.TypeBuilders.add(t);
t.setInterface(true);
t.setAbstract(true);
t.setBaseType(context.TypeSystem.ObjectType);
}
var packageInfo = context.TypeSystem.getType(packageInfoName);
if (packageInfo instanceof TypeBuilder) {
bytecodeGenerator.generateAnnotationsBytecode(packageDeclaration.Annotations, (TypeBuilder)packageInfo);
} else {
context.addError(CompileErrorId.PackageAnnotatedExternally, packageDeclaration);
}
}
try {
generateAnnotations(packageDeclaration.Body, annotationTypesOnly);
} finally {
for (int i = packageDeclaration.Identifiers.size() - 1; i >= 0; --i) {
context.MemberResolver.leavePackage();
}
}
}
private PackageBodyNode parsePackageBody(bool global, int startPosition) {
var result = new PackageBodyNode { StartPosition = startPosition };
startPosition = scanner.StartPosition;
while (lexicalUnit == LexicalUnit.Keyword && scanner.Keyword == Keyword.Using) {
if (!isIdentifier(nextLexicalUnit(true))) {
throw error(ParseErrorId.IdentifierExpected);
}
var usingDirective = new UsingDirectiveNode { StartPosition = startPosition };
setScannerState(usingDirective);
result.UsingDirectives.add(usingDirective);
int sp = scanner.StartPosition;
int len = getLexicalUnitLength();
var restorePoint = this.createRestorePoint();
if (nextLexicalUnit(true) == LexicalUnit.Assign) {
usingDirective.AliasOffset = sp;
usingDirective.AliasLength = len;
nextLexicalUnit(true);
} else {
restore(restorePoint);
}
usingDirective.TypeOrPackage = parsePackageOrTypeName(true);
usingDirective.EndPosition = parseSemiColon(false, false);
}
var done = false;
var modifiers = EnumSet.noneOf(typeof(Modifier));
var annotations = new ArrayList<AnnotationSectionNode>();
do {
switch (lexicalUnit) {
case Keyword:
case ContextualKeyword:
switch (scanner.Keyword) {
case Package:
if (modifiers.size() > 0) {
addError(ParseErrorId.PackageWithModifiers);
modifiers.clear();
}
var ns = new PackageDeclarationNode { StartPosition = scanner.StartPosition };
if (docCommentEndPosition > 0) {
ns.DocumentationOffset = docCommentStartPosition;
ns.DocumentationLength = docCommentEndPosition - docCommentStartPosition;
docCommentEndPosition = 0;
}
setScannerState(ns);
ns.Annotations.addAll(annotations);
annotations.clear();
do {
if (!isIdentifier(nextLexicalUnit(true))) {
throw error(ParseErrorId.IdentifierExpected);
}
var part = new SourceCodePartNode { Offset = scanner.StartPosition, Length = getLexicalUnitLength() };
setScannerState(part);
ns.Identifiers.add(part);
} while (nextLexicalUnit(true) == LexicalUnit.Dot);
if (lexicalUnit != LexicalUnit.OpenBrace) {
throw error(ParseErrorId.OpenBraceExpected);
}
startPosition = scanner.StartPosition;
if (nextLexicalUnit(true) != LexicalUnit.CloseBrace) {
ns.Body = parsePackageBody(false, startPosition);
}
if (lexicalUnit != LexicalUnit.CloseBrace) {
throw error(ParseErrorId.CloseBraceExpected);
}
ns.EndPosition = scanner.EndPosition;
if (nextLexicalUnit(false) == LexicalUnit.SemiColon) {
nextLexicalUnit(false);
}
result.Members.add(ns);
break;
case Public:
if (modifiers.size() == 0) {
startPosition = scanner.StartPosition;
}
addModifier(modifiers, Modifier.Public);
nextLexicalUnit(true);
break;
case Protected:
if (modifiers.size() == 0) {
startPosition = scanner.StartPosition;
}
addModifier(modifiers, Modifier.Protected);
nextLexicalUnit(true);
break;
case Private:
if (modifiers.size() == 0) {
startPosition = scanner.StartPosition;
}
addModifier(modifiers, Modifier.Private);
nextLexicalUnit(true);
break;
case Abstract:
if (modifiers.size() == 0) {
startPosition = scanner.StartPosition;
}
addModifier(modifiers, Modifier.Abstract);
nextLexicalUnit(true);
break;
case Final:
if (modifiers.size() == 0) {
startPosition = scanner.StartPosition;
}
addModifier(modifiers, Modifier.Final);
nextLexicalUnit(true);
break;
case Static:
if (modifiers.size() == 0) {
startPosition = scanner.StartPosition;
}
addModifier(modifiers, Modifier.Static);
nextLexicalUnit(true);
break;
case Strictfp:
if (modifiers.size() == 0) {
startPosition = scanner.StartPosition;
}
addModifier(modifiers, Modifier.Strictfp);
nextLexicalUnit(true);
break;
case Partial:
if (modifiers.size() == 0) {
startPosition = scanner.StartPosition;
}
switch (nextLexicalUnit(true)) {
case Keyword:
switch (scanner.Keyword) {
case Class:
nextLexicalUnit(true);
result.Members.add(parseClass(annotations, modifiers, false, true, startPosition));
modifiers.clear();
annotations.clear();
break;
case Interface:
nextLexicalUnit(true);
result.Members.add(parseInterface(annotations, modifiers, true, startPosition));
modifiers.clear();
annotations.clear();
break;
case Enum:
nextLexicalUnit(true);
result.Members.add(parseClass(annotations, modifiers, true, true, startPosition));
modifiers.clear();
annotations.clear();
break;
default:
throw error(ParseErrorId.ClassInterfaceEnumExpected);
}
break;
default:
throw error(ParseErrorId.ClassInterfaceEnumExpected);
}
break;
case Class:
if (modifiers.size() == 0) {
startPosition = scanner.StartPosition;
}
nextLexicalUnit(true);
result.Members.add(parseClass(annotations, modifiers, false, false, startPosition));
modifiers.clear();
annotations.clear();
break;
case Interface:
if (modifiers.size() == 0) {
startPosition = scanner.StartPosition;
}
nextLexicalUnit(true);
result.Members.add(parseInterface(annotations, modifiers, false, startPosition));
modifiers.clear();
annotations.clear();
break;
case Enum:
if (modifiers.size() == 0) {
startPosition = scanner.StartPosition;
}
nextLexicalUnit(true);
result.Members.add(parseClass(annotations, modifiers, true, false, startPosition));
modifiers.clear();
annotations.clear();
break;
case Delegate:
if (modifiers.size() == 0) {
startPosition = scanner.StartPosition;
}
nextLexicalUnit(true);
result.Members.add(parseDelegate(annotations, modifiers, startPosition));
modifiers.clear();
annotations.clear();
break;
default:
throw error(ParseErrorId.ClassInterfaceEnumDelegateExpected);
}
break;
case OpenBracket:
if (modifiers.size() > 0) {
throw error(ParseErrorId.ClassInterfaceEnumDelegateExpected);
}
annotations.add(parseAnnotationSection());
break;
case CloseBrace:
if (global) {
throw error(ParseErrorId.ClassInterfaceEnumDelegateExpected);
} else {
if (modifiers.size() > 0 || annotations.size() > 0) {
throw error(ParseErrorId.ClassInterfaceEnumDelegateExpected);
}
done = true;
}
break;
case EndOfStream:
if (!global) {
throw error(ParseErrorId.ClassInterfaceEnumDelegateExpected);
} else {
if (modifiers.size() > 0 || annotations.size() > 0) {
throw error(ParseErrorId.ClassInterfaceEnumDelegateExpected);
}
done = true;
}
break;
default:
throw error(ParseErrorId.NoPackageMembers);
}
} while (!done);
result.EndPosition = scanner.EndPosition;
return result;
}
