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 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); } } }