parser: new class SourceFile

[nit.git] / src / syntax / syntax.nit

diff --git a/src/syntax/syntax.nit b/src/syntax/syntax.nit
index 6536478..aa17066 100644 (file)
--- a/src/syntax/syntax.nit
+++ b/src/syntax/syntax.nit
@@ -20,39 +20,49 @@ package syntax
 
 import mmloader
 import mmbuilder
-import control_flow
 import typing
+import icode_generation
 
 # Loader of nit source files
 class SrcModuleLoader
-special ModuleLoader
+       super ModuleLoader
        redef type MODULE: MMSrcModule
 
-       redef meth file_type do return "nit"
+       redef fun file_type do return "nit"
 
-       redef meth parse_file(context, file, filename, name, dir)
+       redef fun parse_file(context, file, filename, name, dir)
        do
-               var lexer = new Lexer(file, filename)
+               var name_is_valid = name.to_s.length > 0 and name.to_s[0].is_lower
+               for char in name.to_s do        if not char.is_digit and not char.is_letter and not char == '_'
+               then
+                       name_is_valid = false
+                       break
+               end
+               if not name_is_valid then
+                       context.error( null, "{filename}: Error module name \"{name}\", must start with a lower case letter and contain only letters, digits and '_'." )
+               end
+
+               var source = new SourceFile(filename, file)
+               var lexer = new Lexer(source)
                var parser = new Parser(lexer)
                var node_tree = parser.parse
                if node_tree.n_base == null then
                        var err = node_tree.n_eof
-                       assert err isa PError
-                       context.error("{err.locate}: {err.message}")
-                       exit(1)
+                       assert err isa AError
+                       context.fatal_error(err.location, err.message)
                end
                var node_module = node_tree.n_base
-               assert node_module isa AModule
-               var module = new MMSrcModule(context, node_module, dir, name)
-               #module.filename = fname
-               #module.mtime = fname.file_stat.mtime
-               return module
+               assert node_module != null
+               var module_loc = new Location.with_file(source)
+               var mod = new MMSrcModule(context, node_module, dir, name, module_loc)
+               return mod
        end
 
-       redef meth process_metamodel(context, module)
+       redef fun process_metamodel(context, mod)
        do
-               module.process_supermodules(context)
-               module.process_syntax(context)
+               mod.process_supermodules(context)
+               context.info("Syntax analysis for module: {mod.name}", 2)
+               mod.process_syntax(context)
        end
 
        init do end
@@ -60,26 +70,30 @@ end
 
 redef class MMSrcModule
        # Loading and syntax analysis of super modules
-       private meth process_supermodules(tc: ToolContext)
+       private fun process_supermodules(tc: ToolContext)
        do
                node.import_super_modules(tc, self)
-               
        end
 
        # Syntax analysis and MM construction for the module
        # Require than supermodules are processed
-       private meth process_syntax(tc: ToolContext)
+       private fun process_syntax(tc: ToolContext)
        do
                do_mmbuilder(tc)
-               if tc.error_count > 0 then exit(1)
+               tc.check_errors
 
                do_typing(tc)
-               if tc.error_count > 0 then exit(1)
+               tc.check_errors
 
-               do_control_flow(tc)
-               if tc.error_count > 0 then exit(1)
+               generate_icode(tc)
+               tc.check_errors
 
+               if not tc.keep_ast then clear_ast
        end
-
 end
 
+redef class ToolContext
+       # Should the AST be preserved in source modules after syntax processing?
+       # Default is false.
+       readable writable var _keep_ast: Bool = false
+end