OLD | NEW |
1 # Copyright 2014 The Chromium Authors. All rights reserved. | 1 # Copyright 2014 The Chromium Authors. All rights reserved. |
2 # Use of this source code is governed by a BSD-style license that can be | 2 # Use of this source code is governed by a BSD-style license that can be |
3 # found in the LICENSE file. | 3 # found in the LICENSE file. |
4 | 4 |
5 """Generates java source files from a mojom.Module.""" | 5 """Generates java source files from a mojom.Module.""" |
6 | 6 |
7 import argparse | 7 import argparse |
8 import os | 8 import os |
9 import re | 9 import re |
10 | 10 |
11 from jinja2 import contextfilter | |
12 | |
13 import mojom.generate.generator as generator | 11 import mojom.generate.generator as generator |
14 import mojom.generate.module as mojom | 12 import mojom.generate.module as mojom |
15 from mojom.generate.template_expander import UseJinja | 13 from mojom.generate.template_expander import UseJinja |
16 | 14 |
17 | 15 |
18 GENERATOR_PREFIX = 'java' | 16 GENERATOR_PREFIX = 'java' |
19 | 17 |
20 _spec_to_java_type = { | 18 _spec_to_java_type = { |
21 'b': 'boolean', | 19 'b': 'boolean', |
22 'd': 'double', | 20 'd': 'double', |
(...skipping 34 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
57 uccc = UpperCamelCase(name) | 55 uccc = UpperCamelCase(name) |
58 return uccc[0].lower() + uccc[1:] | 56 return uccc[0].lower() + uccc[1:] |
59 | 57 |
60 def ConstantStyle(name): | 58 def ConstantStyle(name): |
61 components = NameToComponent(name) | 59 components = NameToComponent(name) |
62 if components[0] == 'k': | 60 if components[0] == 'k': |
63 components = components[1:] | 61 components = components[1:] |
64 return '_'.join([x.upper() for x in components]) | 62 return '_'.join([x.upper() for x in components]) |
65 | 63 |
66 def GetNameForElement(element): | 64 def GetNameForElement(element): |
67 if isinstance(element, (mojom.Enum, | 65 if (isinstance(element, mojom.Enum) or |
68 mojom.Interface, | 66 isinstance(element, mojom.Interface) or |
69 mojom.Struct)): | 67 isinstance(element, mojom.Struct)): |
70 return UpperCamelCase(element.name) | 68 return UpperCamelCase(element.name) |
71 if isinstance(element, mojom.InterfaceRequest): | 69 if (isinstance(element, mojom.Method) or |
72 return GetNameForElement(element.kind) | 70 isinstance(element, mojom.Parameter) or |
73 if isinstance(element, (mojom.Method, | 71 isinstance(element, mojom.Field)): |
74 mojom.Parameter, | |
75 mojom.Field)): | |
76 return CamelCase(element.name) | 72 return CamelCase(element.name) |
77 if isinstance(element, mojom.EnumValue): | 73 if isinstance(element, mojom.EnumValue): |
78 return (UpperCamelCase(element.enum_name) + '.' + | 74 return (UpperCamelCase(element.enum_name) + '.' + |
79 ConstantStyle(element.name)) | 75 ConstantStyle(element.name)) |
80 if isinstance(element, (mojom.NamedValue, | 76 if (isinstance(element, mojom.NamedValue) or |
81 mojom.Constant)): | 77 isinstance(element, mojom.Constant)): |
82 return ConstantStyle(element.name) | 78 return ConstantStyle(element.name) |
83 raise Exception("Unexpected element: " % element) | 79 raise Exception("Unexpected element: " % element) |
84 | 80 |
85 def ParseStringAttribute(attribute): | 81 def ParseStringAttribute(attribute): |
86 assert isinstance(attribute, basestring) | 82 assert isinstance(attribute, basestring) |
87 return attribute | 83 return attribute |
88 | 84 |
89 def GetPackage(module): | 85 def GetPackage(module): |
90 if 'JavaPackage' in module.attributes: | 86 if 'JavaPackage' in module.attributes: |
91 return ParseStringAttribute(module.attributes['JavaPackage']) | 87 return ParseStringAttribute(module.attributes['JavaPackage']) |
92 # Default package. | 88 # Default package. |
93 return "org.chromium.mojom." + module.namespace | 89 return "org.chromium.mojom." + module.namespace |
94 | 90 |
95 def GetNameForKind(context, kind): | 91 def GetNameForKind(kind): |
96 def _GetNameHierachy(kind): | 92 def _GetNameHierachy(kind): |
97 hierachy = [] | 93 hierachy = [] |
98 if kind.parent_kind: | 94 if kind.parent_kind: |
99 hierachy = _GetNameHierachy(kind.parent_kind) | 95 hierachy = _GetNameHierachy(kind.parent_kind) |
100 hierachy.append(GetNameForElement(kind)) | 96 hierachy.append(kind.name) |
101 return hierachy | 97 return hierachy |
102 | 98 |
103 module = context.resolve('module') | 99 elements = [GetPackage(kind.module)] |
104 elements = [] | |
105 if GetPackage(module) != GetPackage(kind.module): | |
106 elements += [GetPackage(kind.module)] | |
107 elements += _GetNameHierachy(kind) | 100 elements += _GetNameHierachy(kind) |
108 return '.'.join(elements) | 101 return '.'.join(elements) |
109 | 102 |
110 @contextfilter | 103 def GetJavaType(kind): |
111 def GetJavaType(context, kind): | |
112 if isinstance(kind, (mojom.Struct, mojom.Interface)): | 104 if isinstance(kind, (mojom.Struct, mojom.Interface)): |
113 return GetNameForKind(context, kind) | 105 return GetNameForKind(kind) |
114 if isinstance(kind, mojom.InterfaceRequest): | 106 if isinstance(kind, mojom.Array): |
115 return GetNameForKind(context, kind.kind) | 107 return "%s[]" % GetJavaType(kind.kind) |
116 if isinstance(kind, (mojom.Array, mojom.FixedArray)): | |
117 return "%s[]" % GetJavaType(context, kind.kind) | |
118 if isinstance(kind, mojom.Enum): | 108 if isinstance(kind, mojom.Enum): |
119 return "int" | 109 return "int" |
120 return _spec_to_java_type[kind.spec] | 110 return _spec_to_java_type[kind.spec] |
121 | 111 |
122 def IsHandle(kind): | 112 def ExpressionToText(token): |
123 return kind.spec[0] == 'h' | |
124 | |
125 @contextfilter | |
126 def DefaultValue(context, field): | |
127 assert field.default | |
128 if isinstance(field.kind, mojom.Struct): | |
129 assert field.default == "default" | |
130 return "new %s()" % GetJavaType(context, field.kind) | |
131 return "(%s) %s" % (GetJavaType(context, field.kind), | |
132 ExpressionToText(context, field.default)) | |
133 | |
134 @contextfilter | |
135 def ExpressionToText(context, token): | |
136 def _TranslateNamedValue(named_value): | 113 def _TranslateNamedValue(named_value): |
137 entity_name = GetNameForElement(named_value) | 114 entity_name = GetNameForElement(named_value) |
138 if named_value.parent_kind: | 115 if named_value.parent_kind: |
139 return GetJavaType(context, named_value.parent_kind) + '.' + entity_name | 116 return GetJavaType(named_value.parent_kind) + '.' + entity_name |
140 # Handle the case where named_value is a module level constant: | 117 # Handle the case where named_value is a module level constant: |
141 if not isinstance(named_value, mojom.EnumValue): | 118 if not isinstance(named_value, mojom.EnumValue): |
142 entity_name = (GetConstantsMainEntityName(named_value.module) + '.' + | 119 entity_name = (GetConstantsMainEntityName(named_value.module) + '.' + |
143 entity_name) | 120 entity_name) |
144 if GetPackage(named_value.module) == GetPackage(context.resolve('module')): | |
145 return entity_name | |
146 return GetPackage(named_value.module) + '.' + entity_name | 121 return GetPackage(named_value.module) + '.' + entity_name |
147 | 122 |
148 if isinstance(token, mojom.NamedValue): | 123 if isinstance(token, mojom.NamedValue): |
149 return _TranslateNamedValue(token) | 124 return _TranslateNamedValue(token) |
150 # Add Long suffix to all number literals. | 125 # Add Long suffix to all number literals. |
151 if re.match('^[0-9]+$', token): | 126 if re.match('^[0-9]+$', token): |
152 return token + 'L' | 127 return token + 'L' |
153 return token | 128 return token |
154 | 129 |
155 def GetConstantsMainEntityName(module): | 130 def GetConstantsMainEntityName(module): |
156 if 'JavaConstantsClassName' in module.attributes: | 131 if 'JavaConstantsClassName' in module.attributes: |
157 return ParseStringAttribute(module.attributes['JavaConstantsClassName']) | 132 return ParseStringAttribute(module.attributes['JavaConstantsClassName']) |
158 # This constructs the name of the embedding classes for module level constants | 133 # This constructs the name of the embedding classes for module level constants |
159 # by extracting the mojom's filename and prepending it to Constants. | 134 # by extracting the mojom's filename and prepending it to Constants. |
160 return (UpperCamelCase(module.path.split('/')[-1].rsplit('.', 1)[0]) + | 135 return (UpperCamelCase(module.path.split('/')[-1].rsplit('.', 1)[0]) + |
161 'Constants') | 136 'Constants') |
162 | 137 |
163 class Generator(generator.Generator): | 138 class Generator(generator.Generator): |
164 | 139 |
165 java_filters = { | 140 java_filters = { |
166 "default_value": DefaultValue, | |
167 "expression_to_text": ExpressionToText, | 141 "expression_to_text": ExpressionToText, |
168 "is_handle": IsHandle, | |
169 "java_type": GetJavaType, | 142 "java_type": GetJavaType, |
170 "name": GetNameForElement, | 143 "name": GetNameForElement, |
171 } | 144 } |
172 | 145 |
173 def GetJinjaExports(self): | 146 def GetJinjaExports(self): |
174 return { | 147 return { |
175 "module": self.module, | 148 "module": self.module, |
176 "package": GetPackage(self.module), | 149 "package": GetPackage(self.module), |
177 } | 150 } |
178 | 151 |
179 @UseJinja("java_templates/enum.java.tmpl", filters=java_filters) | 152 @UseJinja("java_templates/enum.java.tmpl", filters=java_filters, |
| 153 lstrip_blocks=True, trim_blocks=True) |
180 def GenerateEnumSource(self, enum): | 154 def GenerateEnumSource(self, enum): |
181 exports = self.GetJinjaExports() | 155 exports = self.GetJinjaExports() |
182 exports.update({"enum": enum}) | 156 exports.update({"enum": enum}) |
183 return exports | 157 return exports |
184 | 158 |
185 @UseJinja("java_templates/struct.java.tmpl", filters=java_filters) | 159 @UseJinja("java_templates/constants.java.tmpl", filters=java_filters, |
186 def GenerateStructSource(self, struct): | 160 lstrip_blocks=True, trim_blocks=True) |
187 exports = self.GetJinjaExports() | |
188 exports.update({"struct": struct}) | |
189 return exports | |
190 | |
191 @UseJinja("java_templates/constants.java.tmpl", filters=java_filters) | |
192 def GenerateConstantsSource(self, module): | 161 def GenerateConstantsSource(self, module): |
193 exports = self.GetJinjaExports() | 162 exports = self.GetJinjaExports() |
194 exports.update({"main_entity": GetConstantsMainEntityName(module), | 163 exports.update({"main_entity": GetConstantsMainEntityName(module), |
195 "constants": module.constants}) | 164 "constants": module.constants}) |
196 return exports | 165 return exports |
197 | 166 |
198 def GenerateFiles(self, unparsed_args): | 167 def GenerateFiles(self, unparsed_args): |
199 parser = argparse.ArgumentParser() | 168 parser = argparse.ArgumentParser() |
200 parser.add_argument("--java_output_directory", dest="java_output_directory") | 169 parser.add_argument("--java_output_directory", dest="java_output_directory") |
201 args = parser.parse_args(unparsed_args) | 170 args = parser.parse_args(unparsed_args) |
202 if self.output_dir and args.java_output_directory: | 171 if self.output_dir and args.java_output_directory: |
203 self.output_dir = os.path.join(args.java_output_directory, | 172 self.output_dir = os.path.join(args.java_output_directory, |
204 GetPackage(self.module).replace('.', '/')) | 173 GetPackage(self.module).replace('.', '/')) |
205 if not os.path.exists(self.output_dir): | 174 if not os.path.exists(self.output_dir): |
206 try: | 175 try: |
207 os.makedirs(self.output_dir) | 176 os.makedirs(self.output_dir) |
208 except: | 177 except: |
209 # Ignore errors on directory creation. | 178 # Ignore errors on directory creation. |
210 pass | 179 pass |
211 | 180 |
212 for enum in self.module.enums: | 181 for enum in self.module.enums: |
213 self.Write(self.GenerateEnumSource(enum), | 182 self.Write(self.GenerateEnumSource(enum), |
214 "%s.java" % GetNameForElement(enum)) | 183 "%s.java" % GetNameForElement(enum)) |
215 | 184 |
216 for struct in self.module.structs: | |
217 self.Write(self.GenerateStructSource(struct), | |
218 "%s.java" % GetNameForElement(struct)) | |
219 | |
220 if self.module.constants: | 185 if self.module.constants: |
221 self.Write(self.GenerateConstantsSource(self.module), | 186 self.Write(self.GenerateConstantsSource(self.module), |
222 "%s.java" % GetConstantsMainEntityName(self.module)) | 187 "%s.java" % GetConstantsMainEntityName(self.module)) |
223 | |
224 def GetJinjaParameters(self): | |
225 return { | |
226 'lstrip_blocks': True, | |
227 'trim_blocks': True, | |
228 } | |
229 | |
230 def GetGlobals(self): | |
231 return { | |
232 'module': self.module, | |
233 } | |
OLD | NEW |