1 /*
2 * Copyright (c) 2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "c_interface_code_emitter.h"
17 #include "util/file.h"
18 #include "util/logger.h"
19
20 namespace OHOS {
21 namespace Idl {
ResolveDirectory(const std::string & targetDirectory)22 bool CInterfaceCodeEmitter::ResolveDirectory(const std::string &targetDirectory)
23 {
24 if (ast_->GetASTFileType() == ASTFileType::AST_IFACE || ast_->GetASTFileType() == ASTFileType::AST_ICALLBACK) {
25 directory_ = GetFileParentPath(targetDirectory);
26 } else {
27 return false;
28 }
29
30 if (!File::CreateParentDir(directory_)) {
31 Logger::E("CInterfaceCodeEmitter", "Create '%s' failed!", directory_.c_str());
32 return false;
33 }
34
35 return true;
36 }
37
EmitCode()38 void CInterfaceCodeEmitter::EmitCode()
39 {
40 switch (mode_) {
41 case GenMode::LOW: {
42 EmitLowModeInterfaceHeaderFile();
43 break;
44 }
45 case GenMode::PASSTHROUGH:
46 case GenMode::IPC:
47 case GenMode::KERNEL: {
48 EmitInterfaceHeaderFile();
49 break;
50 }
51 default:
52 break;
53 }
54 }
55
EmitLowModeInterfaceHeaderFile()56 void CInterfaceCodeEmitter::EmitLowModeInterfaceHeaderFile()
57 {
58 std::string filePath =
59 File::AdapterPath(StringHelper::Format("%s/%s.h", directory_.c_str(), FileName(interfaceName_).c_str()));
60 File file(filePath, File::WRITE);
61 StringBuilder sb;
62
63 EmitLicense(sb);
64 EmitHeadMacro(sb, interfaceFullName_);
65 sb.Append("\n");
66 EmitImportInclusions(sb);
67 sb.Append("\n");
68 EmitHeadExternC(sb);
69 sb.Append("\n");
70 EmitInterfaceVersionMacro(sb);
71 if (!interface_->IsSerializable()) {
72 sb.Append("\n");
73 EmitPreDeclaration(sb);
74 }
75 sb.Append("\n");
76 EmitInterfaceDefinition(sb);
77 if (!interface_->IsSerializable()) {
78 sb.Append("\n");
79 EmitLowModeExternalMethod(sb);
80 }
81 sb.Append("\n");
82 EmitTailExternC(sb);
83 sb.Append("\n");
84 EmitTailMacro(sb, interfaceFullName_);
85
86 std::string data = sb.ToString();
87 file.WriteData(data.c_str(), data.size());
88 file.Flush();
89 file.Close();
90 }
91
EmitLowModeExternalMethod(StringBuilder & sb) const92 void CInterfaceCodeEmitter::EmitLowModeExternalMethod(StringBuilder &sb) const
93 {
94 sb.AppendFormat(
95 "inline struct %s *%sGet(const char *serviceName)\n", interfaceName_.c_str(), interfaceName_.c_str());
96 sb.Append("{\n");
97 sb.Append(TAB).AppendFormat(
98 "return (struct %s *)DevSvcManagerClntGetService(serviceName);\n", interfaceName_.c_str());
99 sb.Append("}\n");
100 }
101
EmitInterfaceHeaderFile()102 void CInterfaceCodeEmitter::EmitInterfaceHeaderFile()
103 {
104 std::string filePath =
105 File::AdapterPath(StringHelper::Format("%s/%s.h", directory_.c_str(), FileName(interfaceName_).c_str()));
106 File file(filePath, File::WRITE);
107 StringBuilder sb;
108
109 EmitLicense(sb);
110 EmitHeadMacro(sb, interfaceFullName_);
111 sb.Append("\n");
112 EmitImportInclusions(sb);
113 sb.Append("\n");
114 EmitHeadExternC(sb);
115 if (!Options::GetInstance().DoPassthrough()) {
116 sb.Append("\n");
117 EmitPreDeclaration(sb);
118 }
119 sb.Append("\n");
120 EmitInterfaceDesc(sb);
121 sb.Append("\n");
122 EmitInterfaceVersionMacro(sb);
123 if (!Options::GetInstance().DoPassthrough()) {
124 sb.Append("\n");
125 EmitInterfaceBuffSizeMacro(sb);
126 sb.Append("\n");
127 EmitInterfaceMethodCommands(sb, "");
128 }
129 sb.Append("\n");
130 EmitInterfaceDefinition(sb);
131 EmitExternalMethod(sb);
132 EmitTailExternC(sb);
133 sb.Append("\n");
134 EmitTailMacro(sb, interfaceFullName_);
135
136 std::string data = sb.ToString();
137 file.WriteData(data.c_str(), data.size());
138 file.Flush();
139 file.Close();
140 }
141
EmitImportInclusions(StringBuilder & sb)142 void CInterfaceCodeEmitter::EmitImportInclusions(StringBuilder &sb)
143 {
144 HeaderFile::HeaderFileSet headerFiles;
145
146 GetStdlibInclusions(headerFiles);
147 GetImportInclusions(headerFiles);
148 GetHeaderOtherLibInclusions(headerFiles);
149
150 for (const auto &file : headerFiles) {
151 sb.AppendFormat("%s\n", file.ToString().c_str());
152 }
153 }
154
GetHeaderOtherLibInclusions(HeaderFile::HeaderFileSet & headerFiles) const155 void CInterfaceCodeEmitter::GetHeaderOtherLibInclusions(HeaderFile::HeaderFileSet &headerFiles) const
156 {
157 headerFiles.emplace(HeaderFileType::OTHER_MODULES_HEADER_FILE, "hdf_base");
158 if (!Options::GetInstance().DoGenerateKernelCode()) {
159 headerFiles.emplace(HeaderFileType::C_STD_HEADER_FILE, "stdint");
160 headerFiles.emplace(HeaderFileType::C_STD_HEADER_FILE, "stdbool");
161 }
162 }
163
EmitPreDeclaration(StringBuilder & sb) const164 void CInterfaceCodeEmitter::EmitPreDeclaration(StringBuilder &sb) const
165 {
166 sb.Append("struct HdfRemoteService;\n");
167 }
168
EmitInterfaceDesc(StringBuilder & sb) const169 void CInterfaceCodeEmitter::EmitInterfaceDesc(StringBuilder &sb) const
170 {
171 sb.AppendFormat("#define %s \"%s\"\n", EmitDescMacroName().c_str(), interfaceFullName_.c_str());
172 }
173
EmitInterfaceVersionMacro(StringBuilder & sb) const174 void CInterfaceCodeEmitter::EmitInterfaceVersionMacro(StringBuilder &sb) const
175 {
176 sb.AppendFormat("#define %s %u\n", majorVerName_.c_str(), ast_->GetMajorVer());
177 sb.AppendFormat("#define %s %u\n", minorVerName_.c_str(), ast_->GetMinorVer());
178 }
179
EmitInterfaceDefinition(StringBuilder & sb)180 void CInterfaceCodeEmitter::EmitInterfaceDefinition(StringBuilder &sb)
181 {
182 sb.AppendFormat("struct %s {\n", interfaceName_.c_str());
183 if (mode_ == GenMode::LOW && !interface_->IsSerializable()) {
184 sb.Append(TAB).Append("struct HdfRemoteService *service;\n\n");
185 }
186 EmitInterfaceMethods(sb, TAB);
187 sb.Append("};\n");
188 }
189
EmitInterfaceMethods(StringBuilder & sb,const std::string & prefix) const190 void CInterfaceCodeEmitter::EmitInterfaceMethods(StringBuilder &sb, const std::string &prefix) const
191 {
192 for (const auto &method : interface_->GetMethodsBySystem(Options::GetInstance().GetSystemLevel())) {
193 EmitInterfaceMethod(method, sb, prefix);
194 sb.Append("\n");
195 }
196
197 EmitInterfaceMethod(interface_->GetVersionMethod(), sb, prefix);
198 if (mode_ == GenMode::IPC) {
199 sb.Append("\n");
200 EmitAsObjectMethod(sb, TAB);
201 }
202 }
203
EmitInterfaceMethod(const AutoPtr<ASTMethod> & method,StringBuilder & sb,const std::string & prefix) const204 void CInterfaceCodeEmitter::EmitInterfaceMethod(
205 const AutoPtr<ASTMethod> &method, StringBuilder &sb, const std::string &prefix) const
206 {
207 if (method->GetParameterNumber() == 0) {
208 sb.Append(prefix).AppendFormat(
209 "int32_t (*%s)(struct %s *self);\n", method->GetName().c_str(), interfaceName_.c_str());
210 } else {
211 StringBuilder paramStr;
212 paramStr.Append(prefix).AppendFormat(
213 "int32_t (*%s)(struct %s *self, ", method->GetName().c_str(), interfaceName_.c_str());
214 for (size_t i = 0; i < method->GetParameterNumber(); i++) {
215 AutoPtr<ASTParameter> param = method->GetParameter(i);
216 EmitInterfaceMethodParameter(param, paramStr, "");
217 if (i + 1 < method->GetParameterNumber()) {
218 paramStr.Append(", ");
219 }
220 }
221
222 paramStr.Append(");");
223 sb.Append(SpecificationParam(paramStr, prefix + TAB));
224 sb.Append("\n");
225 }
226 }
227
EmitAsObjectMethod(StringBuilder & sb,const std::string & prefix) const228 void CInterfaceCodeEmitter::EmitAsObjectMethod(StringBuilder &sb, const std::string &prefix) const
229 {
230 sb.Append(prefix).AppendFormat("struct HdfRemoteService* (*AsObject)(struct %s *self);\n", interfaceName_.c_str());
231 }
232
EmitExternalMethod(StringBuilder & sb) const233 void CInterfaceCodeEmitter::EmitExternalMethod(StringBuilder &sb) const
234 {
235 if (Options::GetInstance().DoPassthrough() && interface_->IsSerializable()) {
236 return;
237 }
238
239 sb.Append("\n");
240 EmitInterfaceGetMethodDecl(sb);
241 sb.Append("\n");
242 EmitInterfaceReleaseMethodDecl(sb);
243 }
244
EmitInterfaceGetMethodDecl(StringBuilder & sb) const245 void CInterfaceCodeEmitter::EmitInterfaceGetMethodDecl(StringBuilder &sb) const
246 {
247 if (mode_ == GenMode::KERNEL) {
248 sb.AppendFormat("struct %s *%sGet(void);\n", interfaceName_.c_str(), interfaceName_.c_str());
249 sb.Append("\n");
250 sb.AppendFormat(
251 "struct %s *%sGetInstance(const char *instanceName);\n", interfaceName_.c_str(), interfaceName_.c_str());
252 return;
253 }
254
255 if (interface_->IsSerializable()) {
256 sb.Append("// no external method used to create client object, it only support ipc mode\n");
257 sb.AppendFormat("struct %s *%sGet(struct HdfRemoteService *remote);\n", interfaceName_.c_str(),
258 interfaceName_.c_str());
259 } else {
260 sb.Append("// external method used to create client object, it support ipc and passthrought mode\n");
261 sb.AppendFormat("struct %s *%sGet(bool isStub);\n", interfaceName_.c_str(), interfaceName_.c_str());
262 sb.AppendFormat("struct %s *%sGetInstance(const char *serviceName, bool isStub);\n", interfaceName_.c_str(),
263 interfaceName_.c_str());
264 }
265 }
266
EmitInterfaceReleaseMethodDecl(StringBuilder & sb) const267 void CInterfaceCodeEmitter::EmitInterfaceReleaseMethodDecl(StringBuilder &sb) const
268 {
269 if (mode_ == GenMode::KERNEL) {
270 sb.AppendFormat("void %sRelease(struct %s *instance);\n", interfaceName_.c_str(), interfaceName_.c_str());
271 return;
272 }
273
274 if (interface_->IsCallback()) {
275 sb.Append("// external method used to release client object, it support ipc and passthrought mode\n");
276 sb.AppendFormat("void %sRelease(struct %s *instance);\n", interfaceName_.c_str(),
277 interfaceName_.c_str());
278 } else if (interface_->IsSerializable()) {
279 sb.Append("// external method used to release client object, it support ipc and passthrought mode\n");
280 sb.AppendFormat("void %sRelease(struct %s *instance, bool isStub);\n", interfaceName_.c_str(),
281 interfaceName_.c_str());
282 } else {
283 sb.Append("// external method used to create release object, it support ipc and passthrought mode\n");
284 sb.AppendFormat("void %sRelease(struct %s *instance, bool isStub);\n", interfaceName_.c_str(),
285 interfaceName_.c_str());
286 sb.AppendFormat("void %sReleaseInstance(const char *serviceName, struct %s *instance, bool isStub);\n",
287 interfaceName_.c_str(), interfaceName_.c_str());
288 }
289 }
290 } // namespace Idl
291 } // namespace OHOS