import more_collections
import opts
import poset
-import binary::serialization
+import msgpack
import jtype_converter
end
else
# Use the prefix and the short class name
- # e.g. given the prefix Native: java.lang.String -> NativeString
+ # e.g. given the prefix Native: java.lang.String -> CString
name = prefix + id
end
end
# Short name of the class, mangled to remove `$` (e.g. `Set`)
- fun id: String do return identifier.last.replace("$", "")
+ var id: String is lazy, noserialize do return identifier.last.replace("$", "")
- # Full name of this class as used in an importation (e.g. `java.lang.Set`)
- fun package_name: String do return identifier.join(".")
+ # Full name of this class as used in java code (e.g. `java.lang.Set`)
+ var java_full_name: String is lazy, noserialize do return identifier.join(".").replace("$", ".")
+
+ # Full name of this class as used by jni (e.g. `android.graphics.BitmapFactory$Options`)
+ var jni_full_name: String is lazy, noserialize do return identifier.join(".")
# Name of this class for the extern declaration in Nit (e.g. `java.lang.Set[]`)
- fun extern_equivalent: String do return package_name + "[]" * array_dimension
+ var extern_equivalent: String is lazy, noserialize do return jni_full_name + "[]" * array_dimension
# Full name of this class with arrays and generic values (e.g. `java.lang.Set<E>[]`)
redef fun to_s do
- var id = self.package_name
+ var id = self.java_full_name
if self.is_primitive_array then
id += "[]" * array_dimension
# Comparison based on fully qualified named
redef fun ==(other) do return other isa JavaType and
- self.package_name == other.package_name and
+ self.java_full_name == other.java_full_name and
self.array_dimension == other.array_dimension
- redef fun hash do return self.package_name.hash
+ redef fun hash do return self.java_full_name.hash
end
class NitType
var identifier: String
# If this NitType was found in `lib/android`, contains the module name to import
- var mod: nullable NitModule
+ var mod: nullable NitModuleRef
# Is this type known, wrapped and available in Nit?
var is_known: Bool = true
var constructors = new Array[JavaConstructor]
# Importations from this class
- var imports = new HashSet[NitModule]
+ var imports = new HashSet[NitModuleRef]
# Interfaces implemented by this class
var implements = new HashSet[JavaType]
# All classes, from this pass and from other passes
var all_classes: HashMap[String, JavaClass] is noserialize, lazy do
var classes = new HashMap[String, JavaClass]
- classes.recover_with self.classes
+ classes.add_all self.classes
for model_path in sys.opt_load_models.value do
if not model_path.file_exists then
end
var file = model_path.to_path.open_ro
- var d = new BinaryDeserializer(file)
+ var d = new MsgPackDeserializer(file)
var model = d.deserialize
file.close
if d.errors.not_empty then
- print_error "Error: failed to deserialize model file '{model_path}' with: {d.errors.join(", ")}"
+ print_error "Error: failed to deserialize model file '{model_path}' with:\n* {d.errors.join("\n* ")}"
continue
end
continue
end
- classes.recover_with model.classes
+ classes.add_all model.classes
end
return classes
end
+ # Does this model have access to the `java.lang.Object`?
+ var knows_the_object_class: Bool = all_classes.keys.has("java.lang.Object") is lazy, noserialize
+
# Add a class in `classes`
fun add_class(jclass: JavaClass)
do
- var key = jclass.class_type.package_name
+ var key = jclass.class_type.java_full_name
classes[key] = jclass
end
end
# Is being wrapped in this pass?
- var key = jtype.package_name
+ var key = jtype.java_full_name
if classes.keys.has(key) then
if jtype.array_dimension <= opt_arrays.value then
var nit_type = new NitType(jtype.extern_name)
# Remove unavailable super classes
for super_type in super_classes.reverse_iterator do
# Is the super class available?
- if not all_classes.keys.has(super_type.package_name) then super_classes.remove(super_type)
+ if not all_classes.keys.has(super_type.java_full_name) then super_classes.remove(super_type)
end
- # If the is no explicit supers, add `java.lang.Object`
- if super_classes.is_empty and java_class.class_type != object_type then
+ # If the is no explicit supers, add `java.lang.Object` (if it is known)
+ if super_classes.is_empty and java_class.class_type != object_type and
+ knows_the_object_class then
super_classes.add object_type
end
for super_type in super_classes do
# Is the super class available?
- if not all_classes.keys.has(super_type.package_name) then continue
+ if not all_classes.keys.has(super_type.java_full_name) then continue
- var super_class = all_classes[super_type.package_name]
+ var super_class = all_classes[super_type.java_full_name]
class_hierarchy.add_edge(java_class, super_class)
end
end
end
# A Nit module, use to import the referenced extern classes
-class NitModule
+class NitModuleRef
# Relative path to the module
var path: String
# Name of the module
- var name: String is lazy do return path.basename(".nit")
+ var name: String is lazy, noserialize do return path.basename(".nit")
redef fun to_s do return self.name
- redef fun ==(other) do return other isa NitModule and self.path == other.path
+ redef fun ==(other) do return other isa NitModuleRef and self.path == other.path
redef fun hash do return self.path.hash
end
# * The value is the corresponding `NitType`.
var find_extern_class: DefaultMap[String, nullable NitType] is lazy do
var map = new DefaultMap[String, nullable NitType](null)
- var modules = new HashMap[String, NitModule]
+ var modules = new HashMap[String, NitModuleRef]
var lib_paths = opt_libs.value
if lib_paths == null then lib_paths = new Array[String]
var mod = modules.get_or_null(path)
if mod == null then
- mod = new NitModule(path)
+ mod = new NitModuleRef(path)
modules[path] = mod
end
var opt_extern_class_prefix = new OptionString("Prefix to extern classes (By default uses the full namespace)", "-p")
# Prefix used to name extern classes, if `null` use the full namespace
- var extern_class_prefix: nullable String is lazy do return opt_extern_class_prefix.value
+ var extern_class_prefix: nullable String is lazy, noserialize do return opt_extern_class_prefix.value
# Libraries to search for existing wrappers
var opt_libs = new OptionArray("Paths to libraries with wrappers of Java classes ('auto' to use the full Nit lib)", "-i")