private static void addTypeMembers(PackageBodyNode packageBody, List <TypeMemberNode> types)
{
if (packageBody != null)
{
foreach (var m in packageBody.getMembers())
{
switch (m.PackageMemberKind)
{
case Package:
var p = (PackageDeclarationNode)m;
if (p.Body != null)
{
addTypeMembers(p.Body, types);
}
break;
case Class:
var c = (ClassDeclarationNode)m;
addTypeMembers(c, types);
break;
case Interface:
case Delegate:
types.add((TypeMemberNode)m);
break;
}
}
}
}
private void translate(PackageBodyNode packageBody)
{
foreach (var m in packageBody.Members)
{
switch (m.PackageMemberKind)
{
case Package:
var packageDeclaration = (PackageDeclarationNode)m;
translate(packageDeclaration.Body);
break;
case Class:
translate((ClassDeclarationNode)m);
break;
}
}
}
public void enterPackage(Iterable <String> names, PackageBodyNode body)
{
packageNames = packageNames.concat(names);
packageInfos.add(body.getUserData(typeof(PackageInfo)));
}
private void setBaseTypes(PackageBodyNode packageBody) {
var packageName = context.MemberResolver.getCurrentPackage();
var packageInfo = new PackageInfo();
packageBody.addUserData(packageInfo);
foreach (var usingDirective in packageBody.UsingDirectives) {
if (usingDirective.AliasLength != 0) {
var name = context.getIdentifier(usingDirective.AliasOffset, usingDirective.AliasLength);
if (packageInfo.memberInfos.containsKey(name) || packageInfo.packageAliases.containsKey(name)) {
context.addWarning(CompileErrorId.MultipleUsingDirective, usingDirective, name);
}
var typeInfo = CompilerHelper.resolveTypeReference(context, packageName, usingDirective.TypeOrPackage, false, true);
if (typeInfo != null) {
packageInfo.memberInfos[name] = MemberInfo.getInfo(typeInfo);
} else {
var pname = CompilerHelper.getName(context, usingDirective.TypeOrPackage);
if (context.MemberResolver.TypeFinder.packageExists(pname)) {
packageInfo.packageAliases[name] = pname;
} else {
context.addError(CompileErrorId.UnresolvedTypeName, usingDirective,
MemberResolver.getPackageName(pname).replace('/', '.'));
}
}
} else {
var pname = CompilerHelper.getFullName(context, usingDirective.TypeOrPackage);
if (packageInfo.packages.contains(pname)) {
context.addWarning(CompileErrorId.MultipleUsingDirective, usingDirective, pname.replace('/', '.'));
} else {
packageInfo.packages.add(pname);
}
}
}
context.MemberResolver.usingDirective(packageInfo.memberInfos, packageInfo.packages, packageInfo.packageAliases);
foreach (var member in packageBody.Members) {
switch (member.PackageMemberKind) {
case Package:
setBaseTypes((PackageDeclarationNode)member);
break;
case Class:
setClassBaseTypes((ClassDeclarationNode)member);
break;
case Interface:
setInterfaceBaseTypes((InterfaceDeclarationNode)member);
break;
case Delegate:
setDelegateBaseTypes((DelegateDeclarationNode)member);
break;
default:
throw new Exception("Internal error: unhandled member kind: " + member.PackageMemberKind);
}
}
}
private void defineTypes(String packageName, PackageBodyNode packageBody) {
foreach (var member in packageBody.Members) {
switch (member.PackageMemberKind) {
case Package:
defineTypes(packageName, (PackageDeclarationNode)member);
break;
case Class:
defineClass(packageName, (ClassDeclarationNode)member);
break;
case Interface:
defineInterface(packageName, (InterfaceDeclarationNode)member);
break;
case Delegate:
defineDelegate(packageName, (DelegateDeclarationNode)member);
break;
default:
throw new Exception("Internal error: unhandled member kind: " + member.PackageMemberKind);
}
}
}
private void generateAnnotations(PackageBodyNode packageBody, bool annotationTypesOnly) {
var packageInfo = packageBody.getUserData(typeof(PackageInfo));
context.MemberResolver.usingDirective(packageInfo.memberInfos, packageInfo.packages, packageInfo.packageAliases);
foreach (var member in packageBody.Members) {
switch (member.PackageMemberKind) {
case Package:
generateAnnotations((PackageDeclarationNode)member, annotationTypesOnly);
break;
case Class:
generateClassAnnotations((ClassDeclarationNode)member, annotationTypesOnly);
break;
case Interface:
generateInterfaceAnnotations((InterfaceDeclarationNode)member, annotationTypesOnly);
break;
case Delegate:
generateDelegateAnnotations((DelegateDeclarationNode)member, annotationTypesOnly);
break;
default:
throw new Exception("Internal error: unhandled member kind: " + member.PackageMemberKind);
}
}
}
public void enterPackage(Iterable<String> names, PackageBodyNode body) {
packageNames = packageNames.concat(names);
packageInfos.add(body.getUserData(typeof(PackageInfo)));
}
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;
}
private void translate(PackageBodyNode packageBody) {
foreach (var m in packageBody.Members) {
switch (m.PackageMemberKind) {
case Package:
var packageDeclaration = (PackageDeclarationNode)m;
translate(packageDeclaration.Body);
break;
case Class:
translate((ClassDeclarationNode)m);
break;
}
}
}
private void print(PackageBodyNode packageBody, int indent, StringBuilder sb) {
var indentText = buildIndentText(indent);
if (packageBody.UsingDirectives.size() > 0) {
foreach (var ud in packageBody.UsingDirectives) {
sb.append(indentText);
sb.append("using ");
if (ud.AliasLength > 0) {
sb.append(new String(text, ud.AliasOffset, ud.AliasLength));
sb.append(" = ");
}
print(ud.TypeOrPackage, sb);
sb.append(";\r\n");
}
sb.append("\r\n");
}
foreach (var m in packageBody.Members) {
switch (m.PackageMemberKind) {
case Package:
var packageDeclaration = (PackageDeclarationNode)m;
sb.append(indentText);
sb.append("package ");
var first = true;
foreach (var id in packageDeclaration.Identifiers) {
if (first) {
first = false;
} else {
sb.append(".");
}
sb.append(new String(text, id.Offset, id.Length));
}
sb.append(" {\r\n");
if (packageDeclaration.Body != null) {
print(packageDeclaration.Body, indent + 1, sb);
}
sb.append(indentText);
sb.append("}\r\n");
break;
case Class:
print((ClassDeclarationNode)m, indent, sb);
break;
case Interface:
print((InterfaceDeclarationNode)m, indent, sb);
break;
case Delegate:
print((DelegateDeclarationNode)m, indent, sb);
break;
default:
throw new RuntimeException("Package member not supported: " + m.PackageMemberKind);
}
}
}
