# 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 with_attributes: Bool
+ # Path to the output file
+ var file_name: String
+
+ # Model of Java class being wrapped
+ var model: JavaModel
+
+ # Comment out methods with unknown (unwrapped) types
var comment_unknown_types: Bool
- var file_out: OFStream
- var java_class: JavaClass
- var nb_params: Int
- var module_name: String
- fun code_warehouse: CodeWarehouse do return once new CodeWarehouse
- init (file_name: String, jclass: JavaClass, with_attributes, comment: Bool)
- do
- file_out = new OFStream.open(file_name)
- module_name = file_name.substring(0, file_name.search(".nit").from)
- self.java_class = jclass
- self.with_attributes = with_attributes
- self.comment_unknown_types = comment
+ # 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"
- var class_content = new Array[String]
- class_content.add(gen_class_header(jclass.class_type))
+ for key, jclass in model.classes do
- if with_attributes then
- for id, jtype in jclass.attributes do class_content.add(gen_attribute(id, jtype))
- end
+ file_out.write gen_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)}"
- class_content.add gen_method(id, nid, method_info.return_type, method_info.params)
- end
- end
- class_content.add("\nend\n")
+ 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
- var wrappers = new Array[String]
- for jtype in jclass.unknown_types do
- if jtype == jclass.class_type then continue
- wrappers.add("\n")
- wrappers.add(gen_unknown_class_header(jtype))
+ file_out.write gen_method(jclass, id, nid, signature.return_type, signature.params)
+ file_out.write "\n"
+ end
+ end
+ file_out.write "end\n\n"
end
- var imports = new Array[String]
- imports.add("import mnit_android\n")
- for import_ in jclass.imports do
- imports.add("import android::{import_}\n")
+ if stub_for_unknown_types then
+ for jtype in model.unknown_types do
+ file_out.write gen_unknown_class_header(jtype)
+ file_out.write "\n"
+ end
end
-
- file_out.write(gen_licence)
- file_out.write("module {module_name}\n")
- file_out.write(imports.join(""))
- file_out.write("\n")
- file_out.write(class_content.join(""))
- file_out.write(wrappers.join(""))
end
- fun gen_licence: String
- do
- return """# This file is part of NIT (http://www.nitlanguage.org).
-#
-# Copyright [Year] [Author name] <Author e-mail>
+ # 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.
# See the License for the specific language governing permissions and
# limitations under the License.
-# This code has been generated using `javap`
-"""
- end
+# This code has been generated using `jwrapper`
+""" is writable
fun gen_class_header(jtype: JavaType): String
do
var temp = new Array[String]
- temp.add("extern class Native{jtype.id} in \"Java\" `\{ {jtype} `\}\n")
- temp.add("\tsuper JavaObject\n\n")
+ var nit_type = jtype.to_nit_type
+ temp.add "# Java class: {jtype.to_package_name}\n"
+ temp.add "extern class {nit_type} in \"Java\" `\{ {jtype.to_package_name} `\}\n"
+ temp.add "\tsuper JavaObject\n\n"
- return temp.join("")
+ return temp.join
end
fun gen_unknown_class_header(jtype: JavaType): String
do
- var nit_type: NitType
- if jtype.extern_name.has_generic_params then
- nit_type = jtype.extern_name.generic_params.first
- else
- nit_type = jtype.extern_name
- end
+ var nit_type = jtype.extern_name
var temp = new Array[String]
temp.add("extern class {nit_type} in \"Java\" `\{ {jtype.to_package_name} `\}\n")
temp.add("\tsuper JavaObject\n\nend\n")
- return temp.join("")
+ return temp.join
end
- fun gen_attribute(jid: String, jtype: JavaType): String
- do
- return "\tvar {jid.to_nit_method_name}: {jtype.to_nit_type}\n"
- end
-
- fun gen_method(jmethod_id: String, nmethod_id: String, jreturn_type: JavaType, jparam_list: Array[JavaType]): String
+ fun gen_method(java_class: JavaClass, jmethod_id, nmethod_id: String, jreturn_type: JavaType, jparam_list: Array[JavaType]): String
do
var java_params = ""
var nit_params = ""
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
- java_class.unknown_types.add(jparam)
end
end
end
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}"
nit_id_no += 1
end
+ # Method documentation
+ var doc = "\t# Java implementation: {java_class}.{jmethod_id}\n"
+
# Method identifier
var method_id = nmethod_id.to_nit_method_name
var nit_signature = new Array[String]
if jreturn_type.is_wrapped then
java_class.imports.add return_type.mod.as(not null)
else
+ model.unknown_types.add jreturn_type
if comment_unknown_types then
comment = "#"
else
return_type = jreturn_type.extern_name
- java_class.unknown_types.add(jreturn_type)
end
end
end
var temp = new Array[String]
- temp.add(comment + nit_signature.join(""))
+ temp.add doc
+ temp.add(comment + nit_signature.join)
- # FIXME : This huge `if` block is only necessary to copy primitive arrays as long as there's no better way to do it
if comment == "#" then
- temp.add(" in \"Java\" `\{\n{comment}\t\trecv.{jmethod_id}({java_params});\n{comment}\t`\}\n")
+ temp.add(" in \"Java\" `\{\n{comment}\t\tself.{jmethod_id}({java_params});\n{comment}\t`\}\n")
# Methods with return type
else if return_type != null then
- temp.add(" in \"Java\" `\{\n{comment}\t\treturn {jreturn_type.return_cast} recv.{jmethod_id}({java_params});\n{comment}\t`\}\n")
+ temp.add(" 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
- temp.add(" in \"Java\" `\{\n{comment}\t\trecv.{jmethod_id}({java_params});\n{comment}\t`\}\n")
+ temp.add(" in \"Java\" `\{\n{comment}\t\tself.{jmethod_id}({java_params});\n{comment}\t`\}\n")
# No copy
else
- temp.add(" in \"Java\" `\{\n{comment}\t\trecv.{jmethod_id}({java_params});\n{comment}\t`\}\n")
+ temp.add(" in \"Java\" `\{\n{comment}\t\tself.{jmethod_id}({java_params});\n{comment}\t`\}\n")
end
- return temp.join("")
+ return temp.join
end
end
-# Contains raw code mostly used to copy collections
-class CodeWarehouse
-
- 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(", ")
-
- if not is_param then
- if nit_type.is_map then
- imports = """ import {{{ntype}}}, {{{ntype}}}.[]="""
- else
- imports = """ import {{{ntype}}}, {{{ntype}}}.add"""
- end
- else if nit_type.id == "Array" then
- imports = """ import {{{ntype}}}, {{{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
+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
redef class String
+
# Convert the Java method name `self` to the Nit style
#
# * Converts to snake case
# * Add suffix `=` to setters
fun to_nit_method_name: String
do
- var name
- if self.has_prefix("Get") then
- name = self.substring_from(3)
- else if self.has_prefix("Set") then
- name = self.substring_from(3)
+ 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 += "="
- else
- name = self
end
- return name.to_snake_case
+ # Strip the '_' prefix
+ while name.has_prefix("_") do name = name.substring(1, name.length-1)
+
+ # Escape Nit keywords
+ if nit_keywords.has(name) then name += "_"
+
+ # If the name starts by something other than a letter, prefix with `java_`
+ if not name.chars.first.is_letter then name = "java_" + name
+
+ name = name.replace("$", "_")
+
+ return name
end
end
nitlanguage / nit.git / blobdiff