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                 if mmodules.length == 1 then
  42                         mainmodule = mmodules.first
  43                 else
  44                         # We need a main module, so we build it by importing all modules
  45                         mainmodule = new MModule(modelbuilder.model, null, mmodules.first.name + "-m", new Location(mmodules.first.location.file, 0, 0, 0, 0))
  46                         mainmodule.is_fictive = true
  47                         mainmodule.set_imported_mmodules(mmodules)
  48                         modelbuilder.apply_conditional_importations(mainmodule)
  49                         modelbuilder.run_phases
  50                 end
  51                 return mainmodule
  52         end
  53
  54         # Run `process_mainmodule` on all phases
  55         fun run_global_phases(mmodules: Array[MModule])
  56         do
  57                 if not mmodules.is_empty then
  58                         var mainmodule = make_main_module(mmodules)
  59                         for phase in phases_list do
  60                                 if phase.disabled then continue
  61                                 phase.process_mainmodule(mainmodule, mmodules)
  62                         end
  63                 end
  64
  65                 check_errors
  66                 errors_info
  67         end
  68 end
  69
  70 redef class Phase
  71         # Specific action to execute on the whole program.
  72         # Called by the `ToolContext::run_global_phases`.
  73         #
  74         # `mainmodule` is the main module of the program.
  75         # It could be an implicit module (called like the first given_mmodules).
  76         #
  77         # `given_modules` is the list of explicitely requested modules.
  78         # from the command-line for instance.
  79         #
  80         # REQUIRE: `not given_modules.is_empty`
  81         # REQUIRE: `(given_modules.length == 1) == (mainmodule == given_modules.first)`
  82         #
  83         # @toimplement
  84         fun process_mainmodule(mainmodule: MModule, given_mmodules: SequenceRead[MModule]) do end
  85 end
  86
  87
  88 redef class ModelBuilder
  89         # Run phases on all loaded modules
  90         fun run_phases
  91         do
  92                 var mmodules = parsed_modules.to_a
  93                 model.mmodule_importation_hierarchy.sort(mmodules)
  94                 var nmodules = new Array[AModule]
  95                 for mm in mmodules do
  96                         if mm.is_fictive then continue
  97                         nmodules.add(mmodule2node(mm).as(not null))
  98                 end
  99                 toolcontext.run_phases(nmodules)
 100
 101                 if toolcontext.opt_only_metamodel.value then
 102                         self.toolcontext.info("*** ONLY METAMODEL", 1)
 103                         exit(0)
 104                 end
 105         end
 106
 107 end