# This file is part of NIT (http://www.nitlanguage.org).
#
# Copyright 2014 Frédéric Vachon <fredvac@gmail.com>
+# Copyright 2015 Alexis Laferrière <alexis.laf@xymus.net>
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# Services to generate extern class `in "Java"`
module code_generator
-intrude import types
+intrude import model
class CodeGenerator
- var file_out: OFStream
- var java_class: JavaClass
- fun code_warehouse: CodeWarehouse do return once new CodeWarehouse
+ # Path to the output file
+ var file_name: String
- init (file_name: String, jclass: JavaClass)
- do
- file_out = new OFStream.open(file_name)
- self.java_class = jclass
+ # Model of Java class being wrapped
+ var model: JavaModel
+
+ # Comment out methods with unknown (unwrapped) types
+ var comment_unknown_types: Bool
+
+ # Generate stub classes for unknown types used in the generated module
+ var stub_for_unknown_types: Bool
+
+ # Output file
+ var file_out: Writer = new FileWriter.open(file_name) is lazy, writable
+
+ # Name of the Nit module to generate
+ var module_name: nullable String is lazy do
+ if file_name.file_extension == "nit" then
+ # Output file ends with .nit, we expect it to be a valid name
+ return file_name.basename(".nit")
+ else return null
end
+ # Generate the Nit module into `file_out`
fun generate
do
- var jclass = self.java_class
+ # License
+ file_out.write license
+
+ # Module declaration
+ var module_name = module_name
+ if module_name != null then file_out.write "module {module_name}\n"
+ file_out.write "\n"
+
+ # All importations
+ var imports = new HashSet[String]
+ imports.add "import java\n"
+ for key, jclass in model.classes do
+ for import_ in jclass.imports do imports.add "import android::{import_}\n"
+ end
+ file_out.write imports.join("\n")
+ file_out.write "\n"
- file_out.write("import mnit_android\n")
- gen_class_header(jclass.name)
+ for key, jclass in model.classes do
- # Attributes generation
- for id, jtype in jclass.attributes do gen_attribute(id, jtype)
+ generate_class_header(jclass.class_type)
- for id, methods_info in jclass.methods do
- for method_info in methods_info do
- var nid = id
- if methods_info.length > 1 then nid += "{methods_info.index_of(method_info)}"
- gen_method(id, nid, method_info.return_type, method_info.params)
+ for id, signatures in jclass.methods do
+ var c = 0
+ for signature in signatures do
+ var nid = id
+ if c > 0 then nid += c.to_s
+ c += 1
+
+ generate_method(jclass, id, nid, signature.return_type, signature.params)
+ file_out.write "\n"
+ 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)
+
+ generate_constructor(jclass, constructor, name)
end
+
+ # Attributes
+ for id, java_type in jclass.attributes do
+ generate_getter_setter(jclass, id, java_type)
+ end
+
+ file_out.write "end\n\n"
end
- file_out.write("\nend")
+ if stub_for_unknown_types then
+ for jtype in model.unknown_types do
+ generate_unknown_class_header(jtype)
+ file_out.write "\n"
+ end
+ end
end
- fun gen_class_header(full_class_name: Array[String])
+ # License for the header of the generated Nit module
+ var license = """
+# This file is part of NIT (http://www.nitlanguage.org).
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# This code has been generated using `jwrapper`
+""" is writable
+
+ private fun generate_class_header(jtype: JavaType)
do
- file_out.write("extern class Native{full_class_name.last} in \"Java\" `\{ {full_class_name.join(".")} `\}\n")
- file_out.write("\tsuper JavaObject\n\tredef type SELF: Native{full_class_name.last}\n\n")
+ var nit_type = jtype.to_nit_type
+ 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"
end
- fun gen_attribute(jid: String, jtype: JavaType)
+ private fun generate_unknown_class_header(jtype: JavaType)
do
- file_out.write("\tvar {jid.to_snake_case}: {jtype.to_nit_type}\n")
+ var nit_type = jtype.extern_name
+
+ file_out.write "extern class {nit_type} in \"Java\" `\{ {jtype.to_package_name} `\}\n"
+ file_out.write "\tsuper JavaObject\n\nend\n"
end
-
- fun gen_method(jmethod_id: String, nmethod_id: String, jreturn_type: JavaType, jparam_list: Array[JavaType])
+
+ private fun generate_method(java_class: JavaClass, jmethod_id, method_id: String,
+ jreturn_type: JavaType, jparam_list: Array[JavaType])
do
var java_params = ""
var nit_params = ""
var nit_id = "arg"
var nit_id_no = 0
var nit_types = new Array[NitType]
- var comment = ""
+ var comment = ""
# Parameters
for i in [0..jparam_list.length[ do
var jparam = jparam_list[i]
var nit_type = jparam.to_nit_type
+
+ if not nit_type.is_complete then
+ if jparam.is_wrapped then
+ java_class.imports.add nit_type.mod.as(not null)
+ else
+ model.unknown_types.add jparam
+ if comment_unknown_types then
+ comment = "#"
+ else
+ nit_type = jparam.extern_name
+ end
+ end
+ end
+
var cast = ""
if not jparam.is_collection then cast = jparam.param_cast
nit_types.add(nit_type)
- nit_type.arg_id = "{nit_id}{nit_id_no}"
if i == jparam_list.length - 1 then
java_params += "{cast}{nit_id}{nit_id_no}"
end
nit_id_no += 1
- # Comment if one type is unknown
- if not nit_type.is_complete then comment = "#"
end
+ # Method documentation
+ var doc = "\t# Java implementation: {java_class}.{jmethod_id}\n"
+
# Method identifier
- var method_id = nmethod_id.to_snake_case
+ method_id = method_id.to_nit_method_name
+ method_id = java_class.nit_name_for(method_id, jparam_list, java_class.methods[jmethod_id].length > 1)
var nit_signature = new Array[String]
nit_signature.add "\tfun {method_id}"
if not jreturn_type.is_void then
return_type = jreturn_type.to_nit_type
- if not return_type.is_complete then comment = "#"
- nit_signature.add ": {return_type} "
- end
-
- file_out.write(comment + nit_signature.join(""))
-
- var param_to_copy = param_to_copy(jparam_list, nit_types)
- # Copy one parameter, the return value, one parameter and the return value or nothing
- if return_type != null then
- if return_type.is_complete and jreturn_type.is_collection then
- if param_to_copy != null then
- var rtype_couple = new Couple[JavaType, NitType](jreturn_type, return_type)
- file_out.write(code_warehouse.param_return_copy(rtype_couple, param_to_copy, jmethod_id, java_params))
+ if not return_type.is_complete then
+ if jreturn_type.is_wrapped then
+ java_class.imports.add return_type.mod.as(not null)
else
- file_out.write(code_warehouse.return_type_copy(jreturn_type, return_type, jmethod_id, java_params))
+ model.unknown_types.add jreturn_type
+ if comment_unknown_types then
+ comment = "#"
+ else
+ return_type = jreturn_type.extern_name
+ end
end
- else if param_to_copy != null then
- file_out.write(code_warehouse.param_type_copy(param_to_copy.first, param_to_copy.second, jmethod_id, java_params, true))
- else
- file_out.write(" in \"Java\" `\{\n\t\t{comment}return {jreturn_type.return_cast} recv.{jmethod_id}({java_params}); \n\t{comment}`\}\n")
- end
- else if jreturn_type.is_void then
- if param_to_copy != null then
- file_out.write(code_warehouse.param_type_copy(param_to_copy.first, param_to_copy.second, jmethod_id, java_params, false))
- else
- file_out.write(" in \"Java\" `\{\n\t\t{comment}recv.{jmethod_id}({java_params}); \n\t{comment}`\}\n")
end
- else
- file_out.write(" in \"Java\" `\{\n\t\t{comment}recv.{jmethod_id}({java_params}); \n\t{comment}`\}\n")
- end
- end
- # Only one collection type parameter can be copied
- # If there's none or more than one then `null` is returned
- fun param_to_copy(jtypes: Array[JavaType], ntypes: Array[NitType]): nullable Couple[JavaType, NitType]
- do
- var counter = 0
- var couple = null
- for i in [0..jtypes.length[ do
- if jtypes[i].is_collection and ntypes[i].is_complete then
- counter += 1
- if counter > 1 then return null
- couple = new Couple[JavaType, NitType](jtypes[i], ntypes[i])
- end
+ nit_signature.add ": {return_type} "
end
- return couple
- end
-end
-
-# Contains raw code mostly used to copy collections
-class CodeWarehouse
+ file_out.write doc
+ file_out.write comment + nit_signature.join
- # Collection as return value
- fun return_type_copy(java_type: JavaType, nit_type: NitType, jmethod_id, params_id: String): String
- do
- var narray_id = "nit_array"
- var loop_ = create_loop(java_type, nit_type, false, "java_array", narray_id)
- var imports = create_imports(nit_type, false)
-
- return """{{{imports}}} in "Java" `{
- {{{java_type.to_s}}} java_array = recv.{{{jmethod_id}}}({{{params_id}}});
- int {{{narray_id}}} = new_{{{nit_type.id}}}_of_{{{nit_type.generic_params.join("_")}}}();
-
- {{{loop_}}}
-
- return {{{narray_id}}};
- `}
- """
+ if comment == "#" then
+ file_out.write " in \"Java\" `\{\n{comment}\t\tself.{jmethod_id}({java_params});\n{comment}\t`\}\n"
+ # Methods with return type
+ else if return_type != null then
+ file_out.write " in \"Java\" `\{\n{comment}\t\treturn {jreturn_type.return_cast}self.{jmethod_id}({java_params});\n{comment}\t`\}\n"
+ # Methods without return type
+ else if jreturn_type.is_void then
+ file_out.write " in \"Java\" `\{\n{comment}\t\tself.{jmethod_id}({java_params});\n{comment}\t`\}\n"
+ # No copy
+ else
+ file_out.write " in \"Java\" `\{\n{comment}\t\tself.{jmethod_id}({java_params});\n{comment}\t`\}\n"
+ end
end
- # Collection as parameter
- fun param_type_copy(java_type: JavaType, nit_type: NitType, jmethod_id, params_id: String, has_return: Bool): String
+ # Generate getter and setter to access an attribute, of field
+ private fun generate_getter_setter(java_class: JavaClass, java_id: String, java_type: JavaType)
do
- var narray_id = "nit_array"
- var jarray_id = "java_array"
- var loop_ = create_loop(java_type, nit_type, true, jarray_id, narray_id)
- var imports = create_imports(nit_type, true)
- var jtype = java_type.to_s
- var jinstanciation = create_array_instance(java_type, nit_type, jarray_id)
- var return_str = ""
-
- if has_return then
- return_str = "return "
- end
+ var nit_type = model.java_to_nit_type(java_type)
+ var nit_id = java_id.to_nit_method_name
+ nit_id = java_class.nit_name_for(nit_id, [java_type], false)
- params_id = params_id.replace(nit_type.arg_id, jarray_id)
+ var c = ""
+ if not nit_type.is_known then c = "#"
- return """{{{imports}}} in "Java" `{
- {{{jinstanciation}}}
- int {{{narray_id}}} = new_{{{nit_type.id}}}_of_{{{nit_type.generic_params.join("_")}}}();
+ file_out.write """
+ # Java getter: {{{java_class}}}.{{{java_id}}}
+{{{c}}} fun {{{nit_id}}}: {{{nit_type}}} in "Java" `{
+{{{c}}} return self.{{{java_id}}};
+{{{c}}} `}
- {{{loop_}}}
+ # Java setter: {{{java_class}}}.{{{java_id}}}
+{{{c}}} fun {{{nit_id}}}=(value: {{{nit_type}}}) in "Java" `{
+{{{c}}} self.{{{java_id}}} = value;
+{{{c}}} `}
- {{{return_str}}}recv.{{{jmethod_id}}}({{{params_id}}});
- `}
- """
+"""
end
- # One collection parameter and the return type will be copied
- fun param_return_copy(return_types, param_types: Couple[JavaType, NitType], jmethod_id, params_id: String): String
+ # Generate getter and setter to access an attribute, of field
+ private fun generate_constructor(java_class: JavaClass, constructor: JavaConstructor, name: String)
do
- var narray_id = "nit_array"
- var narray_id2 = "nit_array2"
+ var c = ""
+ var nit_params_s = ""
+ var java_params_s = ""
- var r_jtype = return_types.first
- var r_ntype = return_types.second
+ if constructor.params.not_empty then
+ var nit_params = new Array[String]
+ var java_params = new Array[String]
+ var param_id = 'a'
+ for java_type in constructor.params do
- var p_jtype = param_types.first
- var p_ntype = param_types.second
+ java_params.add "{java_type.param_cast}{param_id}"
- var r_loop = create_loop(r_jtype, r_ntype, false, "java_array", narray_id)
- var p_loop = create_loop(p_jtype, p_ntype, true, "java_array2", narray_id2)
+ var nit_type = model.java_to_nit_type(java_type)
+ nit_params.add "{param_id}: {nit_type}"
+ param_id = param_id.successor(1)
- var imports = new Array[String]
-
- # Avoid import duplication
- if p_ntype.to_s != r_ntype.to_s then
- imports.add create_imports(p_ntype, true)
- end
+ if not nit_type.is_known then c = "#"
+ end
- imports.add create_imports(r_ntype, false)
+ nit_params_s = "(" + nit_params.join(", ") + ")"
+ java_params_s = java_params.join(", ")
+ end
- params_id = params_id.replace(p_ntype.arg_id, narray_id)
+ file_out.write """
+ # Java constructor: {{{java_class}}}
+{{{c}}} new {{{name}}}{{{nit_params_s}}} in "Java" `{
+{{{c}}} return new {{{java_class}}}({{{java_params_s}}});
+{{{c}}} `}
- var jinstanciation = create_array_instance(p_jtype, p_ntype, "java_array")
+"""
+ end
+end
- return """{{{imports.join(", ")}}} in "Java" `{
- {{{jinstanciation}}}
+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: Array[String] = ["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"]
+end
- {{{p_loop}}}
+redef class String
- {{{r_jtype.to_s}}} java_array2 = recv.{{{jmethod_id}}}({{{params_id}}});
- int {{{narray_id2}}} = new_{{{r_ntype.id}}}_of_{{{r_ntype.generic_params.join("_")}}}();
+ # Convert the Java method name `self` to the Nit style
+ #
+ # * Converts to snake case
+ # * Strips `Get` and `Set`
+ # * Add suffix `=` to setters
+ fun to_nit_method_name: String
+ do
+ var name = self.to_snake_case
+ if name.has_prefix("get_") then
+ name = name.substring_from(4)
+ else if name.has_prefix("set_") then
+ name = name.substring_from(4)
+ if nit_keywords.has(name) then name += "_"
+ name += "="
+ end
- {{{r_loop}}}
+ # Strip the '_' prefix
+ while name.has_prefix("_") do name = name.substring(1, name.length-1)
- return {{{narray_id2}}};
- `}
- """
- end
+ # Escape Nit keywords
+ if nit_keywords.has(name) then name += "_"
- private fun create_array_instance(java_type: JavaType, nit_type: NitType, jarray_id: String): String
- do
- var jtype = java_type.to_s
- var instanciation = ""
+ # If the name starts by something other than a letter, prefix with `java_`
+ if not name.chars.first.is_letter then name = "java_" + name
- if java_type.is_primitive_array then
- instanciation = "{jtype} {jarray_id} = new {java_type.full_id}[Array_of_{nit_type.generic_params[0]}_length({nit_type.arg_id})];"
- else
- instanciation = "{jtype} {jarray_id} = new {jtype}();"
- end
+ name = name.replace("$", "_")
- return instanciation
+ return name
end
+end
- private fun create_imports(nit_type: NitType, is_param: Bool): String
- do
- var imports = ""
- var ntype = nit_type.to_s
- var gen_type = nit_type.generic_params.join(", ")
+redef class JavaClass
+ # Property names used in this class
+ private var used_name = new HashSet[String]
- if not is_param then
- if nit_type.is_map then
- imports = """import {{{ntype}}}, {{{ntype}}}.[]="""
- else
- imports = """import {{{ntype}}}, {{{ntype}}}.add"""
+ # 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
+ do
+ # Append the name of each parameter
+ if use_parameters_name then
+ for param in parameters do
+ name += "_" + param.id
end
- else if nit_type.id == "Array" then
- imports = """import {{{ntype}}}.length, {{{ntype}}}.[]"""
- else if nit_type.is_map then
- imports = """import {{{ntype}}}.iterator, Iterator[{{{gen_type}}}].is_ok, Iterator[{{{gen_type}}}].next, Iterator[{{{gen_type}}}].item, Iterator[{{{gen_type}}}].key"""
- else
- imports = """import {{{ntype}}}.iterator, Iterator[{{{gen_type}}}].is_ok, Iterator[{{{gen_type}}}].next, Iterator[{{{gen_type}}}].item"""
end
-
- return imports
- end
- private fun create_loop(java_type: JavaType, nit_type: NitType, is_param: Bool, jarray_id, narray_id: String): String
- do
- var loop_header = ""
- var loop_body = ""
- var gen_type = nit_type.generic_params.join("_")
-
- if is_param then
- if java_type.is_primitive_array then
- loop_header = "for(int i=0; i < {jarray_id}.length; ++i)"
- loop_body = """\t\t\t{{{jarray_id}}}[i] = {{{java_type.param_cast}}}Array_of_{{{gen_type}}}__index({{{nit_type.arg_id}}}, i);"""
- else if nit_type.id == "Array" then
- loop_header = """int length = Array_of_{{{gen_type}}}_length({{{nit_type.arg_id}}});\n\t\tfor(int i=0; i < length; ++i)"""
- loop_body = """\t\t\t{{{jarray_id}}}.add({{{java_type.param_cast}}}Array_of_{{{gen_type}}}__index({{{narray_id}}}, i));"""
- else
- loop_header = """int itr = {{{nit_type.id}}}_of_{{{gen_type}}}_iterator({{{nit_type.arg_id}}});\n\t\twhile(Iterator_of_{{{gen_type}}}_is_ok(itr)) {"""
- if nit_type.is_map then
- var key_cast = java_type.to_cast(java_type.generic_params[0].id, true)
- var value_cast = java_type.to_cast(java_type.generic_params[1].id, true)
- loop_body = """\t\t\t{{{jarray_id}}}[{{{key_cast}}}iterator_of_{{{nit_type.id}}}_key(itr)] = {{{value_cast}}}iterator_of_{{{nit_type.id}}}_item(itr);\n\t\t\titerator_of_{{{gen_type}}}_next(itr);\n\t\t}"""
- else
- loop_body = """\t\t\t{{{jarray_id}}}.add({{{java_type.param_cast}}}iterator_of_{{{nit_type.id}}}_item(itr));\n\t\t\titerator_of_{{{gen_type}}}_next(itr);\n\t\t}"""
- end
- end
- else
- if nit_type.is_map then
- var key_cast = java_type.to_cast(java_type.generic_params[0].id, false)
- var value_cast = java_type.to_cast(java_type.generic_params[1].id, false)
- loop_header = """for (java.util.Map.Entry<{{{java_type.generic_params[0]}}}, {{{java_type.generic_params[1]}}}> e: {{{jarray_id}}})"""
- loop_body = """\t\t\t{{{nit_type.id}}}_of_{{{gen_type}}}_{{{nit_type.generic_params[1]}}}__index_assign({{{narray_id}}}, {{{key_cast}}}e.getKey(), {{{value_cast}}}e.getValue()); """
- else if java_type.is_iterable then
- loop_header = """for ({{{java_type.generic_params[0]}}} e: {{{jarray_id}}})"""
- loop_body = """\t\t\t{{{nit_type.id}}}_of_{{{gen_type}}}_add({{{narray_id}}}, {{{java_type.return_cast}}}e);"""
- else
- loop_header = "for(int i=0; i < {jarray_id}.length; ++i)"
- loop_body = """\t\t\t{{{nit_type.id}}}_of_{{{gen_type}}}_add({{{narray_id}}}, {{{java_type.return_cast}}}{{{jarray_id}}}[i]);"""
- end
+ # As a last resort, append numbers to the name
+ var base_name = name
+ var count = 1
+ while used_name.has(name) do
+ name = base_name + count.to_s
+ count += 1
end
- return loop_header + "\n" + loop_body
+ used_name.add name
+ return name
end
end
nitlanguage / nit.git / blobdiff