# Layouts
-class TypingLayout[E]
- # Unic ids or each element
+class Layout[E: Object]
+ # Ids or each element
var ids: Map[E, Int] = new HashMap[E, Int]
# Fixed positions of each element in all tables
var pos: Map[E, Int] = new HashMap[E, Int]
end
-class PHTypingLayout[E]
- super TypingLayout[E]
+class PHLayout[HOLDER: Object, E: Object]
+ super Layout[E]
# Masks used by hash function
- var masks: Map[E, Int] = new HashMap[E, Int]
+ var masks: Map[HOLDER, Int] = new HashMap[HOLDER, Int]
# Positions of each element for each tables
- var hashes: Map[E, Map[E, Int]] = new HashMap[E, Map[E, Int]]
+ var hashes: Map[HOLDER, Map[E, Int]] = new HashMap[HOLDER, Map[E, Int]]
end
-class PropertyLayout[E]
+class PropertyLayout[E: Object]
# Fixed positions of each element in all tables
var pos: Map[E, Int] = new HashMap[E, Int]
end
-# Layout for resolution tables
-class ResolutionLayout
- # Unic ids for each resolved type
- var ids: Map[MType, Int] = new HashMap[MType, Int]
- # Fixed positions of resolved type
- var pos: Map[MType, Int] = new HashMap[MType, Int]
-end
-
-class PHResolutionLayout
- super ResolutionLayout
- # Masks associated to each owner of a resolution table
- var masks: Map[MClassType, Int] = new HashMap[MClassType, Int]
- # Positions of each resolvec type for resolution tables
- var hashes: Map[MClassType, Map[MType, Int]] = new HashMap[MClassType, Map[MType, Int]]
-end
-
# Builders
-abstract class TypingLayoutBuilder[E]
+abstract class TypingLayoutBuilder[E: Object]
- type LAYOUT: TypingLayout[E]
+ type LAYOUT: Layout[E]
private var mmodule: MModule
init(mmodule: MModule) do self.mmodule = mmodule
# Compute mtypes ids and position using BM
redef fun build_layout(mtypes) do
- var result = new TypingLayout[MType]
+ var result = new Layout[MType]
result.ids = self.compute_ids(mtypes)
result.pos = result.ids
return result
# Compute mtypes ids and position using BM
redef fun build_layout(mtypes) do
- var result = new TypingLayout[MType]
+ var result = new Layout[MType]
result.ids = self.compute_ids(mtypes)
result.pos = self.colorer.colorize(mtypes)
return result
class PHTypeLayoutBuilder
super TypingLayoutBuilder[MType]
- redef type LAYOUT: PHTypingLayout[MType]
+ redef type LAYOUT: PHLayout[MType, MType]
private var hasher: PerfectHasher[MType, MType]
init(mmodule: MModule, operator: PHOperator) do
- super
+ super(mmodule)
self.hasher = new PerfectHasher[MType, MType](operator)
end
# Compute mtypes ids and position using BM
redef fun build_layout(mtypes) do
- var result = new PHTypingLayout[MType]
+ var result = new PHLayout[MType, MType]
var conflicts = build_conflicts(mtypes)
result.ids = self.compute_ids(mtypes)
result.masks = self.hasher.compute_masks(conflicts, result.ids)
# Compute mclasses ids and position using BM
redef fun build_layout(mclasses) do
- var result = new TypingLayout[MClass]
+ var result = new Layout[MClass]
result.ids = self.compute_ids(mclasses)
result.pos = result.ids
return result
# Compute mclasses ids and position using BM
redef fun build_layout(mclasses) do
- var result = new TypingLayout[MClass]
+ var result = new Layout[MClass]
result.ids = self.compute_ids(mclasses)
result.pos = self.colorer.colorize(mclasses)
return result
class PHClassLayoutBuilder
super TypingLayoutBuilder[MClass]
- redef type LAYOUT: PHTypingLayout[MClass]
+ redef type LAYOUT: PHLayout[MClass, MClass]
private var hasher: PerfectHasher[MClass, MClass]
init(mmodule: MModule, operator: PHOperator) do
- super
+ super(mmodule)
self.hasher = new PerfectHasher[MClass, MClass](operator)
end
# Compute mclasses ids and position using BM
redef fun build_layout(mclasses) do
- var result = new PHTypingLayout[MClass]
+ var result = new PHLayout[MClass, MClass]
var conflicts = build_conflicts(mclasses)
result.ids = self.compute_ids(mclasses)
result.masks = self.hasher.compute_masks(conflicts, result.ids)
type LAYOUT: PropertyLayout[E]
- private var mmodule: MModule
- init(mmodule: MModule) do self.mmodule = mmodule
-
# Compute properties ids and position
fun build_layout(mclasses: Set[MClass]): LAYOUT is abstract
end
private var colorer: MPropertyColorer[E]
- init(mmodule: MModule) do
- super
- self.colorer = new MPropertyColorer[E](mmodule)
+ init(colorer: MPropertyColorer[E]) do
+ self.colorer = colorer
end
# Compute mclasses ids and position using BM
abstract class ResolutionLayoutBuilder
- type LAYOUT: ResolutionLayout
+ type LAYOUT: Layout[MType]
init do end
# Compute resolved types position using BM
redef fun build_layout(elements) do
- var result = new ResolutionLayout
+ var result = new Layout[MType]
result.ids = self.compute_ids(elements)
result.pos = result.ids
return result
# Compute resolved types colors
redef fun build_layout(elements) do
- var result = new ResolutionLayout
+ var result = new Layout[MType]
result.ids = self.compute_ids(elements)
result.pos = self.colorer.colorize(elements)
return result
class PHResolutionLayoutBuilder
super ResolutionLayoutBuilder
- redef type LAYOUT: PHResolutionLayout
+ redef type LAYOUT: PHLayout[MClassType, MType]
private var hasher: PerfectHasher[MClassType, MType]
# Compute resolved types masks and hashes
redef fun build_layout(elements) do
- var result = new PHResolutionLayout
+ var result = new PHLayout[MClassType, MType]
result.ids = self.compute_ids(elements)
result.pos = result.ids
result.masks = self.hasher.compute_masks(elements, result.ids)
end
# MProperty coloring
-private class MPropertyColorer[E: MProperty]
+abstract class MPropertyColorer[E: MProperty]
private var mmodule: MModule
private var class_colorer: MClassColorer
end
# Filter properties
- private fun properties(mclass: MClass): Set[E] do
- var properties = new HashSet[E]
+ private fun properties(mclass: MClass): Set[E] is abstract
+end
+
+# Coloring for MMethods
+class MMethodColorer
+ super MPropertyColorer[MMethod]
+
+ init(mmodule: MModule) do super
+
+ redef fun properties(mclass) do
+ var properties = new HashSet[MMethod]
+ for mprop in self.mmodule.properties(mclass) do
+ if mprop isa MMethod then properties.add(mprop)
+ end
+ return properties
+ end
+end
+
+# Coloring for MMAttributes
+class MAttributeColorer
+ super MPropertyColorer[MAttribute]
+
+ init(mmodule: MModule) do super
+
+ redef fun properties(mclass) do
+ var properties = new HashSet[MAttribute]
+ for mprop in self.mmodule.properties(mclass) do
+ if mprop isa MAttribute then properties.add(mprop)
+ end
+ return properties
+ end
+end
+
+# Coloring for MVirtualTypeProps
+class MVirtualTypePropColorer
+ super MPropertyColorer[MVirtualTypeProp]
+
+ init(mmodule: MModule) do super
+
+ redef fun properties(mclass) do
+ var properties = new HashSet[MVirtualTypeProp]
for mprop in self.mmodule.properties(mclass) do
- if mprop isa E then properties.add(mprop)
+ if mprop isa MVirtualTypeProp then properties.add(mprop)
end
return properties
end
# Perfect Hashing (PH)
# T = type of holder
# U = type of elements to hash
-private class PerfectHasher[T, U]
+private class PerfectHasher[T: Object, U: Object]
var operator: PHOperator
nitlanguage / nit.git / blobdiff