1 /*
2 * Copyright (C) 2015 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include "xml/XmlUtil.h"
18
19 #include <algorithm>
20 #include <string>
21
22 #include "util/Maybe.h"
23 #include "util/Util.h"
24 #include "xml/XmlDom.h"
25
26 using ::android::StringPiece;
27
28 namespace aapt {
29 namespace xml {
30
BuildPackageNamespace(const StringPiece & package,bool private_reference)31 std::string BuildPackageNamespace(const StringPiece& package, bool private_reference) {
32 std::string result = private_reference ? kSchemaPrivatePrefix : kSchemaPublicPrefix;
33 result.append(package.data(), package.size());
34 return result;
35 }
36
ExtractPackageFromNamespace(const std::string & namespace_uri)37 Maybe<ExtractedPackage> ExtractPackageFromNamespace(
38 const std::string& namespace_uri) {
39 if (util::StartsWith(namespace_uri, kSchemaPublicPrefix)) {
40 StringPiece schema_prefix = kSchemaPublicPrefix;
41 StringPiece package = namespace_uri;
42 package = package.substr(schema_prefix.size(), package.size() - schema_prefix.size());
43 if (package.empty()) {
44 return {};
45 }
46 return ExtractedPackage{package.to_string(), false /* is_private */};
47
48 } else if (util::StartsWith(namespace_uri, kSchemaPrivatePrefix)) {
49 StringPiece schema_prefix = kSchemaPrivatePrefix;
50 StringPiece package = namespace_uri;
51 package = package.substr(schema_prefix.size(), package.size() - schema_prefix.size());
52 if (package.empty()) {
53 return {};
54 }
55 return ExtractedPackage{package.to_string(), true /* is_private */};
56
57 } else if (namespace_uri == kSchemaAuto) {
58 return ExtractedPackage{std::string(), true /* is_private */};
59 }
60 return {};
61 }
62
ResolvePackage(const IPackageDeclStack * decl_stack,Reference * in_ref)63 void ResolvePackage(const IPackageDeclStack* decl_stack, Reference* in_ref) {
64 if (in_ref->name) {
65 if (Maybe<ExtractedPackage> transformed_package =
66 decl_stack->TransformPackageAlias(in_ref->name.value().package)) {
67 ExtractedPackage& extracted_package = transformed_package.value();
68 in_ref->name.value().package = std::move(extracted_package.package);
69
70 // If the reference was already private (with a * prefix) and the
71 // namespace is public, we keep the reference private.
72 in_ref->private_reference |= extracted_package.private_namespace;
73 }
74 }
75 }
76
77 namespace {
78
79 class ToolsNamespaceRemover : public Visitor {
80 public:
81 using Visitor::Visit;
82
Visit(Element * el)83 void Visit(Element* el) override {
84 auto new_end =
85 std::remove_if(el->namespace_decls.begin(), el->namespace_decls.end(),
86 [](const NamespaceDecl& decl) -> bool { return decl.uri == kSchemaTools; });
87 el->namespace_decls.erase(new_end, el->namespace_decls.end());
88
89 auto new_attr_end = std::remove_if(
90 el->attributes.begin(), el->attributes.end(),
91 [](const Attribute& attr) -> bool { return attr.namespace_uri == kSchemaTools; });
92 el->attributes.erase(new_attr_end, el->attributes.end());
93
94 Visitor::Visit(el);
95 }
96 };
97
98 } // namespace
99
StripAndroidStudioAttributes(Element * el)100 void StripAndroidStudioAttributes(Element* el) {
101 ToolsNamespaceRemover remover;
102 el->Accept(&remover);
103 }
104
105 } // namespace xml
106 } // namespace aapt
107