#
# Copyright 2006-2008 Floréal Morandat <morandat@lirmm.fr>
# Copyright 2008 Jean Privat <jean@pryen.org>
+# Copyright 2009 Jean-Sebastien Gelinas <calestar@gmail.com>
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# See the License for the specific language governing permissions and
# limitations under the License.
-# This package is used to load a metamodel
+# This module is used to load a metamodel
package mmloader
import metamodel
import opts
+import toolcontext
-# Global context for tools
-class ToolContext
-special MMContext
- # Number of errors
- readable var _error_count: Int = 0
-
- # Number of warnings
- readable var _warning_count: Int = 0
-
- # Display an error
- fun error(s: String)
- do
- stderr.write("{s}\n")
- _error_count = _error_count + 1
- end
-
- # Display a warning
- fun warning(s: String)
- do
- if _opt_warn.value == 0 then return
- stderr.write("{s}\n")
- if _opt_warn.value == 1 then
- _warning_count = _warning_count + 1
- else
- _error_count = _error_count + 1
- end
- end
-
- # Display an info
- meth info(s: String, level: Int)
- do
- if level <= verbose_level then
- print "{s}"
- end
- end
+redef class ToolContext
+ super MMContext
# Paths where to locate modules files
readable var _paths: Array[String] = new Array[String]
# List of module loaders
var _loaders: Array[ModuleLoader] = new Array[ModuleLoader]
-
- # Global OptionContext
- readable var _option_context: OptionContext = new OptionContext
-
- # Option --warn
- readable var _opt_warn: OptionCount = new OptionCount("Show warnings", "-W", "--warn")
# Option --path
readable var _opt_path: OptionArray = new OptionArray("Set include path for loaders (may be used more than once)", "-I", "--path")
- # Option --lop
- readable var _opt_log: OptionBool = new OptionBool("Generate various log files", "--log")
-
# Option --only-metamodel
readable var _opt_only_metamodel: OptionBool = new OptionBool("Stop after meta-model processing", "--only-metamodel")
# Option --only-parse
readable var _opt_only_parse: OptionBool = new OptionBool("Only proceed to parse step of loaders", "--only-parse")
- # Option --help
- readable var _opt_help: OptionBool = new OptionBool("Show Help (This screen)", "-h", "-?", "--help")
-
- # Option --version
- readable var _opt_version: OptionBool = new OptionBool("Show version and exit", "--version")
-
- # Option --verbose
- readable var _opt_verbose: OptionCount = new OptionCount("Verbose", "-v", "--verbose")
-
- # Verbose level
- readable var _verbose_level: Int = 0
-
- init
+ redef init
do
super
- option_context.add_option(opt_warn, opt_path, opt_log, opt_only_parse, opt_only_metamodel, opt_help, opt_version, opt_verbose)
+ option_context.add_option(opt_path, opt_only_parse, opt_only_metamodel)
end
# Parse and process the options given on the command line
- fun process_options
+ redef fun process_options
do
- # init options
- option_context.parse(args)
-
- # Set verbose level
- _verbose_level = opt_verbose.value
+ super
# Setup the paths value
paths.append(opt_path.value)
- var path_env = once ("NIT_PATH".to_symbol).environ
- if not path_env.is_empty then
+ var path_env = "NIT_PATH".environ
+ if not path_env.is_empty then
paths.append(path_env.split_with(':'))
end
- path_env = once ("NIT_DIR".to_symbol).environ
- if not path_env.is_empty then
+ path_env = "NIT_DIR".environ
+ if not path_env.is_empty then
var libname = "{path_env}/lib"
if libname.file_exists then paths.add(libname)
end
var libname = "{sys.program_name.dirname}/../lib"
- if libname.file_exists then paths.add(libname)
+ if libname.file_exists then paths.add(libname.simplify_path)
end
# Load and process a module in a directory (or a parent directory).
private fun try_to_load(module_name: Symbol, dir: MMDirectory): nullable MMModule
do
# Look in the module directory
- for m in dir.modules do
+ for m in dir.modules.values do
if m.name == module_name then return m
end
var full_name = dir.full_name_for(module_name)
if _processing_modules.has(full_name) then
# FIXME: Generate better error
- error("Error: Dependency loop for module {full_name}")
- exit(1)
- abort
+ fatal_error(null, "Error: Dependency loop for module {full_name}")
end
_processing_modules.add(full_name)
var m = l.load_and_process_module(self, module_name, dir)
end
if not filename.file_exists then
- error("Error: File {filename} not found.")
- exit(1)
+ fatal_error(null, "Error: File {filename} not found.")
abort
end
var m = try_to_load(module_name, dir)
if m != null then return m
- error("Error: {filename} is not a NIT source module.")
- exit(1)
+ fatal_error(null, "Error: {filename} is not a NIT source module.")
abort
end
# If the module is already loaded, just return it without further processing.
fun get_module(module_name: Symbol, from: nullable MMModule): MMModule
do
- var m: MMModule
if from != null then
var dir: nullable MMDirectory = from.directory
while dir != null do
if m != null then return m
end
# FIXME: Generate better error
- error("Error: No ressource found for module {module_name}.")
- exit(1)
+ fatal_error(null, "Error: No ressource found for module {module_name}.")
abort
end
end
# A load handler know how to load a specific module type
-class ModuleLoader
+interface ModuleLoader
# Type of module loaded by the loader
type MODULE: MMModule
# Try to load a new module directory
fun try_to_load_dir(dirname: Symbol, parent_dir: MMDirectory): nullable MMDirectory
do
- var fname = "{parent_dir.path}/{dirname}/"
+ var fname = "{parent_dir.path}/{dirname}"
if not fname.file_exists then return null
var dir = new MMDirectory(parent_dir.full_name_for(dirname), fname, parent_dir)
# filename is the result of can_handle
fun load_and_process_module(context: ToolContext, module_name: Symbol, dir: MMDirectory): MODULE
do
- var filename = "{dir.path}/{module_name}.{file_type}"
+ var filename = "{dir.path}/{module_name}.{file_type}".simplify_path
var m = load_module(context, module_name, dir, filename)
if not context.opt_only_parse.value then process_metamodel(context, m)
return m
end
if file.eof then
- context.error("Error: Problem in opening file {filename}")
- exit(1)
- abort
+ context.fatal_error(null, "Error: Problem in opening file {filename}")
end
var m = parse_file(context, file, filename, module_name, dir)
if file != stdin then file.close
protected fun parse_file(context: ToolContext, file: IFStream, filename: String, module_name: Symbol, dir: MMDirectory): MODULE is abstract
# Process a parsed module
- protected fun process_metamodel(context: ToolContext, module: MODULE) is abstract
-end
-
-redef class MMModule
- # Recurcivelty process an import modules
- fun import_supers_modules(names: Collection[Symbol])
- do
- var c = context
- assert c isa ToolContext
- var supers = new Array[MMModule]
- for n in names do
- var m = c.get_module(n, self)
- supers.add(m)
- end
- c.add_module(self,supers)
- end
+ protected fun process_metamodel(context: ToolContext, mod: MODULE) is abstract
end
nitlanguage / nit.git / blobdiff