src/modelbuilder.nit

   1 # This file is part of NIT ( http://www.nitlanguage.org ).
   2 #
   3 # Copyright 2012 Jean Privat <jean@pryen.org>
   4 #
   5 # Licensed under the Apache License, Version 2.0 (the "License");
   6 # you may not use this file except in compliance with the License.
   7 # You may obtain a copy of the License at
   8 #
   9 #     http://www.apache.org/licenses/LICENSE-2.0
  10 #
  11 # Unless required by applicable law or agreed to in writing, software
  12 # distributed under the License is distributed on an "AS IS" BASIS,
  13 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 # See the License for the specific language governing permissions and
  15 # limitations under the License.
  16
  17 module modelbuilder
  18
  19 import loader
  20 import phase
  21
  22 private import more_collections
  23
  24 ###
  25
  26 redef class ToolContext
  27         # Option --ignore-visibility
  28         var opt_ignore_visibility = new OptionBool("Do not check, and produce errors, on visibility issues", "--ignore-visibility")
  29
  30         redef init
  31         do
  32                 super
  33                 option_context.add_option(opt_ignore_visibility)
  34         end
  35
  36         # Combine module to make a single one if required.
  37         fun make_main_module(mmodules: Array[MModule]): MModule
  38         do
  39                 assert not mmodules.is_empty
  40                 var mainmodule
  41                 # We need a main module, so we build it by importing all modules
  42                 mainmodule = new MModule(modelbuilder.model, null, mmodules.first.name + "-m", new Location(mmodules.first.location.file, 0, 0, 0, 0))
  43                 mainmodule.is_fictive = true
  44                 mainmodule.first_real_mmodule = mmodules.first.first_real_mmodule
  45                 mainmodule.set_imported_mmodules(mmodules)
  46                 modelbuilder.apply_conditional_importations(mainmodule)
  47                 modelbuilder.run_phases
  48                 return mainmodule
  49         end
  50
  51         # Run `process_mainmodule` on all phases
  52         fun run_global_phases(mmodules: Array[MModule])
  53         do
  54                 if not mmodules.is_empty then
  55                         var mainmodule = make_main_module(mmodules)
  56                         for phase in phases_list do
  57                                 if phase.disabled then continue
  58                                 phase.process_mainmodule(mainmodule, mmodules)
  59                         end
  60                 end
  61
  62                 check_errors
  63                 errors_info
  64         end
  65 end
  66
  67 redef class Phase
  68         # Specific action to execute on the whole program.
  69         # Called by the `ToolContext::run_global_phases`.
  70         #
  71         # `mainmodule` is the main module of the program.
  72         # It could be an implicit module (called like the first given_mmodules).
  73         #
  74         # `given_modules` is the list of explicitely requested modules.
  75         # from the command-line for instance.
  76         #
  77         # REQUIRE: `not given_modules.is_empty`
  78         # REQUIRE: `(given_modules.length == 1) == (mainmodule == given_modules.first)`
  79         #
  80         # @toimplement
  81         fun process_mainmodule(mainmodule: MModule, given_mmodules: SequenceRead[MModule]) do end
  82 end
  83
  84
  85 redef class ModelBuilder
  86         # Run phases on all loaded modules
  87         fun run_phases
  88         do
  89                 var mmodules = parsed_modules.to_a
  90                 model.mmodule_importation_hierarchy.sort(mmodules)
  91                 var nmodules = new Array[AModule]
  92                 for mm in mmodules do
  93                         if mm.is_fictive then continue
  94                         nmodules.add(mmodule2node(mm).as(not null))
  95                 end
  96                 toolcontext.run_phases(nmodules)
  97
  98                 if toolcontext.opt_only_metamodel.value then
  99                         self.toolcontext.info("*** ONLY METAMODEL", 1)
 100                         toolcontext.quit
 101                 end
 102         end
 103
 104 end