# Services to generate extern class `in "Java"`
module code_generator
+import gen_nit
+
intrude import model
class CodeGenerator
# Module declaration
var module_name = module_name
- if module_name != null then file_out.write "module {module_name}\n"
+ if module_name != null then file_out.write "module {module_name} is no_warning(\"useless-superclass\")\n"
file_out.write "\n"
# All importations
file_out.write imports.join("\n")
file_out.write "\n"
- for key, jclass in model.classes do
+ # Sort classes from top-level classes (java.lang.Object) to leaves
+ var standard_classes = new Array[JavaClass]
+ for name, jclass in model.classes do
+ if not jclass.class_type.is_anonymous then standard_classes.add jclass
+ end
+ var linearized = model.class_hierarchy.linearize(standard_classes)
- generate_class_header(jclass.class_type)
+ for jclass in linearized do
+ # Skip classes with an invalid name at the Java language level
+ if jclass.class_type.extern_equivalent.has("-") then continue
- for id, signatures in jclass.methods do
- for signature in signatures do if not signature.is_static then
- generate_method(jclass, id, id, signature.return_type, signature.params)
- file_out.write "\n"
+ generate_class_header(jclass)
+
+ if not sys.opt_no_properties.value then
+
+ for id, signatures in jclass.local_intro_methods do
+ for signature in signatures do
+ assert not signature.is_static
+ generate_method(jclass, id, id, signature.return_type, signature.params)
+ file_out.write "\n"
+ end
end
- end
- # Constructors
- for constructor in jclass.constructors do
- var complex = jclass.constructors.length != 1 and constructor.params.not_empty
- var base_name = if complex then "from" else ""
- var name = jclass.nit_name_for(base_name, constructor.params, complex)
+ # Constructors
+ for constructor in jclass.constructors do
+ var complex = jclass.constructors.length != 1 and constructor.params.not_empty
+ var base_name = if complex then "from" else ""
+ var name = jclass.nit_name_for(base_name, constructor.params, complex, false, local_only=true)
- generate_constructor(jclass, constructor, name)
- end
+ generate_constructor(jclass, constructor, name)
+ end
- # Attributes
- for id, attribute in jclass.attributes do if not attribute.is_static then
- generate_getter_setter(jclass, id, attribute)
+ # Attributes
+ for id, attribute in jclass.attributes do if not attribute.is_static then
+ generate_getter_setter(jclass, id, attribute)
+ end
end
+ # JNI services
+ generate_jni_services jclass.class_type
+
# Close the class
file_out.write "end\n\n"
- # Static functions as top-level methods
- var static_functions_prefix = jclass.class_type.extern_name.to_snake_case
- for id, signatures in jclass.methods do
- for signature in signatures do if signature.is_static then
- var nit_id = static_functions_prefix + "_" + id
- generate_method(jclass, id, nit_id, signature.return_type, signature.params, is_static=true)
- file_out.write "\n"
+ if not sys.opt_no_properties.value then
+
+ # Static functions as top-level methods
+ var static_functions_prefix = jclass.class_type.extern_name.to_snake_case
+ for id, signatures in jclass.methods do
+ for signature in signatures do if signature.is_static then
+ var nit_id = static_functions_prefix + "_" + id
+ generate_method(jclass, id, nit_id, signature.return_type, signature.params, is_static=true)
+ file_out.write "\n"
+ end
end
- end
- # Static attributes as top-level getters and setters
- for id, attribute in jclass.attributes do if attribute.is_static then
- generate_getter_setter(jclass, id, attribute)
+ # Static attributes as top-level getters and setters
+ for id, attribute in jclass.attributes do if attribute.is_static then
+ generate_getter_setter(jclass, id, attribute)
+ end
end
# Primitive arrays
file_out.write "\n"
end
end
+
+ file_out.close
+ end
+
+ # Serialize `model` to a file next to `file_name`
+ fun write_model_to_file
+ do
+ if not sys.opt_save_model.value then return
+
+ # Write the model to file next to the Nit module
+ var model_path = file_name.strip_extension + ".jwrapper.bin"
+ var model_stream = model_path.to_path.open_wo
+ var serializer = new BinarySerializer(model_stream)
+ serializer.serialize model
+ model_stream.close
end
# License for the header of the generated Nit module
# This code has been generated using `jwrapper`
""" is writable
- private fun generate_class_header(jtype: JavaType)
+ private fun generate_class_header(java_class: JavaClass)
do
- var nit_type = model.java_to_nit_type(jtype)
- file_out.write "# Java class: {jtype.to_package_name}\n"
- file_out.write "extern class {nit_type} in \"Java\" `\{ {jtype.to_package_name} `\}\n"
- file_out.write "\tsuper JavaObject\n\n"
+ var java_type = java_class.class_type
+ var nit_type = model.java_to_nit_type(java_type)
+
+ var super_java_types = new HashSet[JavaType]
+ super_java_types.add_all java_class.extends
+ super_java_types.add_all java_class.implements
+
+ var supers = new Array[String]
+ var effective_supers = 0
+ for java_super in super_java_types do
+ var nit_super = model.java_to_nit_type(java_super)
+
+ # Comment out unknown types
+ var c = ""
+ if not nit_super.is_known and comment_unknown_types then c = "# "
+
+ supers.add "{c}super {nit_super}"
+ if c != "# " then effective_supers += 1
+ end
+
+ if effective_supers == 0 then
+ if java_class.class_type.package_name == "java.lang.Object" or
+ not model.knows_the_object_class then
+ supers.add "super JavaObject"
+ else supers.add "super Java_lang_Object"
+ end
+
+ file_out.write """
+# Java class: {{{java_type}}}
+extern class {{{nit_type}}} in "Java" `{ {{{java_type.extern_equivalent}}} `}
+ {{{supers.join("\n\t")}}}
+
+"""
end
private fun generate_unknown_class_header(jtype: JavaType)
do
var nit_type = jtype.extern_name
- file_out.write "extern class {nit_type} in \"Java\" `\{ {jtype.to_package_name} `\}\n"
+ file_out.write "extern class {nit_type} in \"Java\" `\{ {jtype.extern_equivalent} `\}\n"
file_out.write "\tsuper JavaObject\n\nend\n"
end
var nit_type = model.java_to_nit_type(jparam)
if not nit_type.is_known and comment_unknown_types then c = "#"
- if jparam.is_primitive_array then c = "#"
+ if jparam.is_vararg then c = "#"
java_args.add "{jparam.param_cast}{nit_id}{nit_id_no}"
nit_params.add "{nit_id}{nit_id_no}: {nit_type}"
# Method identifier
method_id = method_id.to_nit_method_name
- method_id = java_class.nit_name_for(method_id, java_params, java_class.methods[java_method_id].length > 1)
+ method_id = java_class.nit_name_for(method_id, java_params, java_class.methods[java_method_id].length > 1, is_static == true)
# Build the signature
var nit_signature = new Array[String]
return_type = model.java_to_nit_type(java_return_type)
if not return_type.is_known and comment_unknown_types then c = "#"
- if java_return_type.is_primitive_array then c = "#"
+ if java_return_type.is_vararg then c = "#"
nit_signature.add ": " + return_type.to_s
end
# Build the call in Java
var java_call
if is_static == true then
- java_call = java_class.class_type.to_package_name
+ java_call = java_class.class_type.package_name
else java_call = "self"
java_call += ".{java_method_id}({java_args.join(", ")})"
var nit_id = java_id
if attribute.is_static then nit_id = java_class.class_type.extern_name.to_snake_case + "_" + nit_id
nit_id = nit_id.to_nit_method_name
- nit_id = java_class.nit_name_for(nit_id, [java_type], false)
+ nit_id = java_class.nit_name_for(nit_id, [java_type], false, attribute.is_static)
var c = ""
if not nit_type.is_known and comment_unknown_types then c = "#"
- if java_type.is_primitive_array then c = "#"
+ if java_type.is_vararg then c = "#"
var recv
- if attribute.is_static == true then
- recv = java_class.class_type.to_package_name
+ if attribute.is_static then
+ recv = java_class.class_type.package_name
else recv = "self"
# Tabulation
param_id = param_id.successor(1)
if not nit_type.is_known and comment_unknown_types then c = "#"
- if java_type.is_primitive_array then c = "#"
+ if java_type.is_vararg then c = "#"
end
nit_params_s = "(" + nit_params.join(", ") + ")"
file_out.write """
# Java constructor: {{{java_class}}}
{{{c}}} new {{{name}}}{{{nit_params_s}}} in "Java" `{
-{{{c}}} return new {{{java_class}}}({{{java_params_s}}});
+{{{c}}} return new {{{java_class.class_type.package_name}}}({{{java_params_s}}});
{{{c}}} `}
"""
redef fun []=(i, e) in "Java" `{ self[(int)i] = e; `}
redef fun length in "Java" `{ return self.length; `}
+
+"""
+ generate_jni_services(java_type)
+ file_out.write """
end
"""
end
+
+ # Generate JNI related services
+ #
+ # For now, mostly avoid issue #845, but more services could be generated as needed.
+ private fun generate_jni_services(java_type: JavaType)
+ do
+ var nit_type = model.java_to_nit_type(java_type)
+
+ file_out.write """
+ redef fun new_global_ref import sys, Sys.jni_env `{
+ Sys sys = {{{nit_type}}}_sys(self);
+ JNIEnv *env = Sys_jni_env(sys);
+ return (*env)->NewGlobalRef(env, self);
+ `}
+
+ redef fun pop_from_local_frame_with_env(jni_env) `{
+ return (*jni_env)->PopLocalFrame(jni_env, self);
+ `}
+"""
+ end
end
redef class Sys
# List of Nit keywords
#
# These may also be keywords in Java, but there they would be used capitalized.
- private var nit_keywords = new HashSet[String].from(["abort", "abstract", "and", "assert",
- "break", "class", "continue", "do", "else", "end", "enum", "extern", "false", "implies",
- "import", "init", "interface", "intrude", "if", "in", "is", "isa", "isset", "for", "label",
- "loop", "module", "new", "not", "null", "nullable", "or", "package", "private",
- "protected", "public", "return", "self", "super", "then", "true", "type", "var", "while",
+ private var nit_keywords: Set[String] is lazy do
+ var set = new HashSet[String]
+ set.add_all keywords
+ set.add_all methods_in_pointer
+ return set
+ end
- # Top-level methods
- "class_name", "get_time", "hash", "is_same_type", "is_same_instance", "output",
+ # Name of methods used at the top-level
+ #
+ # Used by `JavaClass::nit_name_for` with static properties.
+ private var top_level_used_names = new HashSet[String]
+
+ # Option to _not_ generate properties (static or from classes)
+ var opt_no_properties = new OptionBool("Do not wrap properties, only classes and basic services", "-n", "--no-properties")
- # Pointer or JavaObject methods
- "free"])
+ # Should the model be serialized to a file?
+ var opt_save_model = new OptionBool("Save the model next to the generated Nit module", "-s", "--save-model")
end
redef class String
redef class JavaClass
# Property names used in this class
- private var used_name = new HashSet[String]
+ private var used_names = new HashSet[String] is serialize
# Get an available property name for the Java property with `name` and parameters
#
# If `use_parameters_name` then expect that there will be conflicts,
# so use the types of `parameters` to build the name.
- private fun nit_name_for(name: String, parameters: Array[JavaType], use_parameters_name: Bool): String
+ private fun nit_name_for(name: String, parameters: Array[JavaType], use_parameters_name: Bool, is_static: Bool, local_only: nullable Bool): String
do
# Append the name of each parameter
if use_parameters_name then
for param in parameters do
- name += "_" + param.id
+ var id = param.id
+ id += "Array"*param.array_dimension
+ name += "_" + id
+ end
+ end
+
+ # Set of sets of property names, local or top-level
+ var local_used_names
+ var used_names
+ if is_static then
+ # Top-level methods
+ local_used_names = sys.top_level_used_names
+ used_names = sys.top_level_used_names
+ else if local_only == true then
+ # Local only: constructors
+ local_used_names = self.used_names
+ used_names = self.used_names
+ else
+ # Avoid conflicts with all super classes
+ local_used_names = self.used_names
+ used_names = new HashSet[String]
+ for sup in in_hierarchy.greaters do
+ used_names.add_all sup.used_names
end
end
# As a last resort, append numbers to the name
var base_name = name
var count = 1
- while used_name.has(name) do
+ while used_names.has(name) do
name = base_name + count.to_s
count += 1
end
- used_name.add name
+ local_used_names.add name
return name
end
end
nitlanguage / nit.git / blobdiff