for a in modules do
var nmodule = self.load_module(a)
if nmodule == null then continue # Skip error
- # Load imported module
- build_module_importation(nmodule)
var mmodule = nmodule.mmodule
if mmodule == null then continue # skip error
mmodules.add mmodule
return mmodules.to_a
end
- # Load recursively all modules of the group `mgroup`.
- # See `parse` for details.
- fun parse_group(mgroup: MGroup): Array[MModule]
- do
- var res = new Array[MModule]
- scan_group(mgroup)
- for mg in mgroup.in_nesting.smallers do
- for mp in mg.module_paths do
- var nmodule = self.load_module(mp.filepath)
- if nmodule == null then continue # Skip error
- # Load imported module
- build_module_importation(nmodule)
- var mmodule = nmodule.mmodule
- if mmodule == null then continue # Skip error
- res.add mmodule
- end
- end
- return res
- end
-
- # Load a bunch of modules and groups.
- #
- # Each name can be:
+ # Identify a bunch of modules and groups.
#
- # * a path to a module, a group or a directory of packages.
- # * a short name of a module or a group that are looked in the `paths` (-I)
- #
- # Then, for each entry, if it is:
- #
- # * a module, then is it parser and returned.
- # * a group then recursively all its modules are parsed.
- # * a directory of packages then all the modules of all packages are parsed.
- # * else an error is displayed.
- #
- # See `parse` for details.
- fun parse_full(names: Sequence[String]): Array[MModule]
+ # This does the same as `parse_full` but does only the identification (cf. `identify_module`)
+ fun scan_full(names: Sequence[String]): Array[MModule]
do
- var time0 = get_time
- # Parse and recursively load
- self.toolcontext.info("*** PARSE ***", 1)
- var mmodules = new ArraySet[MModule]
+ var mmodules = new Array[MModule]
for a in names do
# Case of a group (root or sub-directory)
var mgroup = self.identify_group(a)
if mgroup != null then
- mmodules.add_all parse_group(mgroup)
+ scan_group(mgroup)
+ for mg in mgroup.in_nesting.smallers do mmodules.add_all mg.mmodules
continue
end
var af = a/f
mgroup = identify_group(af)
if mgroup != null then
- mmodules.add_all parse_group(mgroup)
+ scan_group(mgroup)
+ for mg in mgroup.in_nesting.smallers do mmodules.add_all mg.mmodules
continue
end
- var mp = identify_file(af)
- if mp != null then
- var nmodule = self.load_module(af)
- if nmodule == null then continue # Skip error
- build_module_importation(nmodule)
- var mmodule = nmodule.mmodule
- if mmodule == null then continue # Skip error
+ var mmodule = identify_module(af)
+ if mmodule != null then
mmodules.add mmodule
else
self.toolcontext.info("ignore file {af}", 2)
continue
end
- var nmodule = self.load_module(a)
- if nmodule == null then continue # Skip error
- # Load imported module
- build_module_importation(nmodule)
- var mmodule = nmodule.mmodule
- if mmodule == null then continue # Skip error
+ var mmodule = identify_module(a)
+ if mmodule == null then
+ continue
+ end
+
+ mmodules.add mmodule
+ end
+ return mmodules
+ end
+
+ # Load a bunch of modules and groups.
+ #
+ # Each name can be:
+ #
+ # * a path to a module, a group or a directory of packages.
+ # * a short name of a module or a group that are looked in the `paths` (-I)
+ #
+ # Then, for each entry, if it is:
+ #
+ # * a module, then is it parsed and returned.
+ # * a group then recursively all its modules are parsed.
+ # * a directory of packages then all the modules of all packages are parsed.
+ # * else an error is displayed.
+ #
+ # See `parse` for details.
+ fun parse_full(names: Sequence[String]): Array[MModule]
+ do
+ var time0 = get_time
+ # Parse and recursively load
+ self.toolcontext.info("*** PARSE ***", 1)
+ var mmodules = new ArraySet[MModule]
+ var scans = scan_full(names)
+ for mmodule in scans do
+ var ast = mmodule.load(self)
+ if ast == null then continue # Skip error
mmodules.add mmodule
end
var time1 = get_time
end
# The rule
- var rule = new Array[Object]
+ var rule = new Array[MModule]
# First element is the goal, thus
rule.add suppath
# It means that the first module is the module to automatically import.
# The remaining modules are the conditions of the rule.
#
- # Each module is either represented by a MModule (if the module is already loaded)
- # or by a ModulePath (if the module is not yet loaded).
- #
# Rules are declared by `build_module_importation` and are applied by `apply_conditional_importations`
# (and `build_module_importation` that calls it).
#
# TODO (when the loader will be rewritten): use a better representation and move up rules in the model.
- private var conditional_importations = new Array[SequenceRead[Object]]
+ private var conditional_importations = new Array[SequenceRead[MModule]]
# Extends the current importations according to imported rules about conditional importation
fun apply_conditional_importations(mmodule: MModule)
for ci in conditional_importations do
# Check conditions
for i in [1..ci.length[ do
- var rule_element = ci[i]
- # An element of a rule is either a MModule or a ModulePath
- # We need the mmodule to resonate on the importation
- var m
- if rule_element isa MModule then
- m = rule_element
- else
- abort
- end
+ var m = ci[i]
# Is imported?
if not mmodule.in_importation.greaters.has(m) then continue label
end
# Still here? It means that all conditions modules are loaded and imported
# Identify the module to automatically import
- var suppath = ci.first.as(ModulePath)
- var sup = load_module_path(suppath)
- if sup == null then continue
+ var sup = ci.first
+ var ast = sup.load(self)
+ if ast == null then continue
# Do nothing if already imported
if mmodule.in_importation.greaters.has(sup) then continue label
var nmodule = parse(modelbuilder)
if nmodule == null then return null
+ modelbuilder.build_module_importation(nmodule)
return nmodule
end
end
nitlanguage / nit.git / blobdiff