1 # This file is part of NIT (http://www.nitlanguage.org).
3 # Copyright 2014 Frédéric Vachon <fredvac@gmail.com>
4 # Copyright 2015 Alexis Laferrière <alexis.laf@xymus.net>
6 # Licensed under the Apache License, Version 2.0 (the "License");
7 # you may not use this file except in compliance with the License.
8 # You may obtain a copy of the License at
10 # http://www.apache.org/licenses/LICENSE-2.0
12 # Unless required by applicable law or agreed to in writing, software
13 # distributed under the License is distributed on an "AS IS" BASIS,
14 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 # See the License for the specific language governing permissions and
16 # limitations under the License.
18 # Services to generate extern class `in "Java"`
25 # Path to the output file
28 # Model of Java class being wrapped
31 # Comment out methods with unknown (unwrapped) types
32 var comment_unknown_types
: Bool
34 # Generate stub classes for unknown types used in the generated module
35 var stub_for_unknown_types
: Bool
38 var file_out
: Writer = new FileWriter.open
(file_name
) is lazy
, writable
40 # Name of the Nit module to generate
41 var module_name
: nullable String is lazy
do
42 if file_name
.file_extension
== "nit" then
43 # Output file ends with .nit, we expect it to be a valid name
44 return file_name
.basename
(".nit")
48 # Generate the Nit module into `file_out`
52 file_out
.write license
55 var module_name
= module_name
56 if module_name
!= null then file_out
.write
"module {module_name}\n"
60 var imports
= new HashSet[String]
61 imports
.add
"import java\n"
62 for key
, jclass
in model
.classes
do
63 for import_
in jclass
.imports
do imports
.add
"import android::{import_}\n"
65 file_out
.write imports
.join
("\n")
68 for key
, jclass
in model
.classes
do
69 # Skip anonymous classes
70 if jclass
.class_type
.is_anonymous
then continue
72 # Skip classes with an invalid name at the Java language level
73 if jclass
.class_type
.extern_equivalent
.has
("-") then continue
75 generate_class_header
(jclass
.class_type
)
77 for id
, signatures
in jclass
.methods
do
78 for signature
in signatures
do if not signature
.is_static
then
79 generate_method
(jclass
, id
, id
, signature
.return_type
, signature
.params
)
85 for constructor
in jclass
.constructors
do
86 var complex
= jclass
.constructors
.length
!= 1 and constructor
.params
.not_empty
87 var base_name
= if complex
then "from" else ""
88 var name
= jclass
.nit_name_for
(base_name
, constructor
.params
, complex
, false)
90 generate_constructor
(jclass
, constructor
, name
)
94 for id
, attribute
in jclass
.attributes
do if not attribute
.is_static
then
95 generate_getter_setter
(jclass
, id
, attribute
)
99 generate_jni_services jclass
.class_type
102 file_out
.write
"end\n\n"
104 # Static functions as top-level methods
105 var static_functions_prefix
= jclass
.class_type
.extern_name
.to_snake_case
106 for id
, signatures
in jclass
.methods
do
107 for signature
in signatures
do if signature
.is_static
then
108 var nit_id
= static_functions_prefix
+ "_" + id
109 generate_method
(jclass
, id
, nit_id
, signature
.return_type
, signature
.params
, is_static
=true)
114 # Static attributes as top-level getters and setters
115 for id
, attribute
in jclass
.attributes
do if attribute
.is_static
then
116 generate_getter_setter
(jclass
, id
, attribute
)
120 for d
in [1..opt_arrays
.value
] do
121 generate_primitive_array
(jclass
, d
)
125 if stub_for_unknown_types
then
126 for jtype
, nit_type
in model
.unknown_types
do
127 generate_unknown_class_header
(jtype
)
133 # License for the header of the generated Nit module
135 # This file is part of NIT (http://www.nitlanguage.org).
137 # Licensed under the Apache License, Version 2.0 (the "License");
138 # you may not use this file except in compliance with the License.
139 # You may obtain a copy of the License at
141 # http://www.apache.org/licenses/LICENSE-2.0
143 # Unless required by applicable law or agreed to in writing, software
144 # distributed under the License is distributed on an "AS IS" BASIS,
145 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
146 # See the License for the specific language governing permissions and
147 # limitations under the License.
149 # This code has been generated using `jwrapper`
152 private fun generate_class_header
(jtype
: JavaType)
154 var nit_type
= model
.java_to_nit_type
(jtype
)
155 file_out
.write
"# Java class: {jtype}\n"
156 file_out
.write
"extern class {nit_type} in \"Java\
" `\{ {jtype.extern_equivalent} `\}\n"
157 file_out
.write
"\tsuper JavaObject\n\n"
160 private fun generate_unknown_class_header
(jtype
: JavaType)
162 var nit_type
= jtype
.extern_name
164 file_out
.write
"extern class {nit_type} in \"Java\
" `\{ {jtype.extern_equivalent} `\}\n"
165 file_out
.write
"\tsuper JavaObject\n\nend\n"
168 private fun generate_method
(java_class
: JavaClass, java_method_id
, method_id
: String,
169 java_return_type
: JavaType, java_params
: Array[JavaType], is_static
: nullable Bool)
171 var java_args
= new Array[String]
172 var nit_params
= new Array[String]
178 for jparam
in java_params
do
179 var nit_type
= model
.java_to_nit_type
(jparam
)
181 if not nit_type
.is_known
and comment_unknown_types
then c
= "#"
182 if jparam
.is_vararg
then c
= "#"
184 java_args
.add
"{jparam.param_cast}{nit_id}{nit_id_no}"
185 nit_params
.add
"{nit_id}{nit_id_no}: {nit_type}"
191 method_id
= method_id
.to_nit_method_name
192 method_id
= java_class
.nit_name_for
(method_id
, java_params
, java_class
.methods
[java_method_id
].length
> 1, is_static
== true)
194 # Build the signature
195 var nit_signature
= new Array[String]
196 nit_signature
.add
"fun {method_id}"
197 if not java_params
.is_empty
then nit_signature
.add
"({nit_params.join(", ")})"
200 var return_type
= null
201 if not java_return_type
.is_void
then
202 return_type
= model
.java_to_nit_type
(java_return_type
)
204 if not return_type
.is_known
and comment_unknown_types
then c
= "#"
205 if java_return_type
.is_vararg
then c
= "#"
207 nit_signature
.add
": " + return_type
.to_s
210 # Build the call in Java
212 if is_static
== true then
213 java_call
= java_class
.class_type
.package_name
214 else java_call
= "self"
215 java_call
+= ".{java_method_id}({java_args.join(", ")})"
217 if return_type
!= null then java_call
= "return {java_return_type.return_cast}" + java_call
221 if is_static
== true then t
= ""
226 {{{t}}}# Java implementation: {{{java_return_type}}} {{{java_class}}}.{{{java_method_id}}}({{{java_params.join(", ")}}})
227 {{{ct}}}{{{nit_signature.join}}} in "Java" `{
228 {{{ct}}} {{{java_call}}};
233 # Generate getter and setter to access an attribute, of field
234 private fun generate_getter_setter
(java_class
: JavaClass, java_id
: String,
235 attribute
: JavaAttribute)
237 var java_type
= attribute
.java_type
238 var nit_type
= model
.java_to_nit_type
(java_type
)
241 if attribute
.is_static
then nit_id
= java_class
.class_type
.extern_name
.to_snake_case
+ "_" + nit_id
242 nit_id
= nit_id
.to_nit_method_name
243 nit_id
= java_class
.nit_name_for
(nit_id
, [java_type
], false, attribute
.is_static
)
246 if not nit_type
.is_known
and comment_unknown_types
then c
= "#"
247 if java_type
.is_vararg
then c
= "#"
250 if attribute
.is_static
then
251 recv
= java_class
.class_type
.package_name
256 if attribute
.is_static
then t
= ""
260 {{{t}}}# Java getter: {{{java_class}}}.{{{java_id}}}
261 {{{ct}}}fun {{{nit_id}}}: {{{nit_type}}} in "Java" `{
262 {{{ct}}} return {{{recv}}}.{{{java_id}}};
265 {{{t}}}# Java setter: {{{java_class}}}.{{{java_id}}}
266 {{{ct}}}fun {{{nit_id}}}=(value: {{{nit_type}}}) in "Java" `{
267 {{{ct}}} {{{recv}}}.{{{java_id}}} = value;
273 # Generate getter and setter to access an attribute, of field
274 private fun generate_constructor
(java_class
: JavaClass, constructor
: JavaConstructor, name
: String)
277 var nit_params_s
= ""
278 var java_params_s
= ""
280 if constructor
.params
.not_empty
then
281 var nit_params
= new Array[String]
282 var java_params
= new Array[String]
284 for java_type
in constructor
.params
do
286 java_params
.add
"{java_type.param_cast}{param_id}"
288 var nit_type
= model
.java_to_nit_type
(java_type
)
289 nit_params
.add
"{param_id}: {nit_type}"
290 param_id
= param_id
.successor
(1)
292 if not nit_type
.is_known
and comment_unknown_types
then c
= "#"
293 if java_type
.is_vararg
then c
= "#"
296 nit_params_s
= "(" + nit_params
.join
(", ") + ")"
297 java_params_s
= java_params
.join
(", ")
301 # Java constructor: {{{java_class}}}
302 {{{c}}} new {{{name}}}{{{nit_params_s}}} in "Java" `{
303 {{{c}}} return new {{{java_class.class_type.package_name}}}({{{java_params_s}}});
309 private fun generate_primitive_array
(java_class
: JavaClass, dimensions
: Int)
311 var base_java_type
= java_class
.class_type
312 var java_type
= base_java_type
.clone
313 java_type
.array_dimension
= dimensions
315 var base_nit_type
= model
.java_to_nit_type
(base_java_type
)
316 var nit_type
= model
.java_to_nit_type
(java_type
)
319 # Java primitive array: {{{java_type}}}
320 extern class {{{nit_type}}} in "Java" `{ {{{java_type.extern_equivalent}}} `}
321 super AbstractJavaArray[{{{base_nit_type}}}]
323 # Get a new array of the given `size`
324 new(size: Int) in "Java" `{ return new {{{base_java_type}}}[(int)size]; `}
326 redef fun [](i) in "Java" `{ return self[(int)i]; `}
328 redef fun []=(i, e) in "Java" `{ self[(int)i] = e; `}
330 redef fun length in "Java" `{ return self.length; `}
333 generate_jni_services
(java_type
)
340 # Generate JNI related services
342 # For now, mostly avoid issue #845, but more services could be generated as needed.
343 private fun generate_jni_services
(java_type
: JavaType)
345 var nit_type
= model
.java_to_nit_type
(java_type
)
348 redef fun new_global_ref import sys, Sys.jni_env `{
349 Sys sys = {{{nit_type}}}_sys(self);
350 JNIEnv *env = Sys_jni_env(sys);
351 return (*env)->NewGlobalRef(env, self);
354 redef fun pop_from_local_frame_with_env(jni_env) `{
355 return (*jni_env)->PopLocalFrame(jni_env, self);
362 # List of Nit keywords
364 # These may also be keywords in Java, but there they would be used capitalized.
365 private var nit_keywords
= new HashSet[String].from
(["abort", "abstract", "and", "assert",
366 "break", "class", "continue", "do", "else", "end", "enum", "extern", "false", "implies",
367 "import", "init", "interface", "intrude", "if", "in", "is", "isa", "isset", "for", "label",
368 "loop", "module", "new", "not", "null", "nullable", "or", "package", "private",
369 "protected", "public", "return", "self", "super", "then", "true", "type", "var", "while",
372 "class_name", "get_time", "hash", "inspect", "inspect_head", "is_same_type",
373 "is_same_instance", "object_id", "output", "output_class_name", "sys", "to_s",
375 # Pointer or JavaObject methods
378 # Name of methods used at the top-level
380 # Used by `JavaClass::nit_name_for` with static properties.
381 private var top_level_used_names
= new HashSet[String]
386 # Convert the Java method name `self` to the Nit style
388 # * Converts to snake case
389 # * Strips `Get` and `Set`
390 # * Add suffix `=` to setters
391 fun to_nit_method_name
: String
393 var name
= self.to_snake_case
395 # Strip the '_' prefix
396 while name
.has_prefix
("_") do name
= name
.substring
(1, name
.length-1
)
398 # Escape Nit keywords
399 if nit_keywords
.has
(name
) then name
+= "_"
401 # If the name starts by something other than a letter, prefix with `java_`
402 if not name
.chars
.first
.is_letter
then name
= "java_" + name
404 name
= name
.replace
("$", "_")
410 redef class JavaClass
411 # Property names used in this class
412 private var used_names
= new HashSet[String]
414 # Get an available property name for the Java property with `name` and parameters
416 # If `use_parameters_name` then expect that there will be conflicts,
417 # so use the types of `parameters` to build the name.
418 private fun nit_name_for
(name
: String, parameters
: Array[JavaType], use_parameters_name
: Bool, is_static
: Bool): String
420 # Append the name of each parameter
421 if use_parameters_name
then
422 for param
in parameters
do
423 name
+= "_" + param
.id
427 # Set of property names, local or top-level
430 used_names
= sys
.top_level_used_names
431 else used_names
= self.used_names
433 # As a last resort, append numbers to the name
436 while used_names
.has
(name
) do
437 name
= base_name
+ count
.to_s