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                 end
  49                 return mainmodule
  50         end
  51
  52         # Run `process_mainmodule` on all phases
  53         fun run_global_phases(mmodules: Array[MModule])
  54         do
  55                 if not mmodules.is_empty then
  56                         var mainmodule = make_main_module(mmodules)
  57                         for phase in phases_list do
  58                                 if phase.disabled then continue
  59                                 phase.process_mainmodule(mainmodule, mmodules)
  60                         end
  61                 end
  62
  63                 check_errors
  64                 errors_info
  65         end
  66 end
  67
  68 redef class Phase
  69         # Specific action to execute on the whole program.
  70         # Called by the `ToolContext::run_global_phases`.
  71         #
  72         # `mainmodule` is the main module of the program.
  73         # It could be an implicit module (called like the first given_mmodules).
  74         #
  75         # `given_modules` is the list of explicitely requested modules.
  76         # from the command-line for instance.
  77         #
  78         # REQUIRE: `not given_modules.is_empty`
  79         # REQUIRE: `(given_modules.length == 1) == (mainmodule == given_modules.first)`
  80         #
  81         # @toimplement
  82         fun process_mainmodule(mainmodule: MModule, given_mmodules: SequenceRead[MModule]) do end
  83 end
  84
  85
  86 redef class ModelBuilder
  87         # Run phases on all loaded modules
  88         fun run_phases
  89         do
  90                 var mmodules = model.mmodules.to_a
  91                 model.mmodule_importation_hierarchy.sort(mmodules)
  92                 var nmodules = new Array[AModule]
  93                 for mm in mmodules do
  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                         exit(0)
 101                 end
 102         end
 103
 104 end