lib: intro `Float.lerp` for simple linear interpolation

[nit.git] / src / ffi / c_compiler_options.nit

diff --git a/src/ffi/c_compiler_options.nit b/src/ffi/c_compiler_options.nit
index 1d82c0d..878785c 100644 (file)
--- a/src/ffi/c_compiler_options.nit
+++ b/src/ffi/c_compiler_options.nit
@@ -14,7 +14,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-# Offers the annotations `c_compiler_option` and `c_linker_option` to specify
+# Offers the annotations `cflags` and `ldflags` to specify
 # options for the C compiler directly or indirectly. Differs from the `pkgconfig`
 # annotation by the separation of the options between the compiler and linker.
 module c_compiler_options
@@ -22,17 +22,19 @@ module c_compiler_options
 import c
 import cpp
 private import annotation
+private import platform
 
 redef class ToolContext
-       var c_compiler_options_phase: Phase = new CCompilerOptionsPhase(self, null)
+       # Phase to find `cflags`, `ldflags` and `cppflags`
+       var cflags_phase: Phase = new CCompilerOptionsPhase(self, [platform_phase])
 end
 
 private class CCompilerOptionsPhase
        super Phase
 
-       fun compiler_annotation_name: String do return "c_compiler_option"
-       fun linker_annotation_name: String do return "c_linker_option"
-       fun cpp_compiler_annotation_name: String do return "cpp_compiler_option"
+       fun compiler_annotation_name: String do return "cflags"
+       fun linker_annotation_name: String do return "ldflags"
+       fun cpp_compiler_annotation_name: String do return "cppflags"
 
        redef fun process_annotated_node(nmoduledecl, nat)
        do
@@ -99,10 +101,10 @@ private class CCompilerOptionsPhase
                                var cmd_args = opt.command
                                var proc
                                if cmd_args.length == 1 then
-                                       proc = new IProcess.from_a(cmd_args[0], new Array[String])
+                                       proc = new ProcessReader.from_a(cmd_args[0], new Array[String])
                                else if cmd_args.length > 1 then
                                        var rest_args = cmd_args.subarray(1, cmd_args.length-1)
-                                       proc = new IProcess.from_a(cmd_args[0], rest_args)
+                                       proc = new ProcessReader.from_a(cmd_args[0], rest_args)
                                else abort
 
                                # wait for its completion
@@ -128,35 +130,45 @@ private class CCompilerOptionsPhase
                        end
                end
 
-               # retreive module
+               # Retrieve module
                var mmodule = nmoduledecl.parent.as(AModule).mmodule.as(not null)
 
+               # Get target platform from annotation on annotation
+               var platform = ""
+
+               ## Is there an imported platform?
+               var target_platform = mmodule.target_platform
+               if target_platform != null then
+                       platform = target_platform.name or else ""
+               end
+
+               ## Is the platform declared explicitly?
+               var annots = nat.n_annotations
+               if annots != null then
+                       var items = annots.n_items
+                       if items.length > 1 then
+                               modelbuilder.error(annots, "Annotation error: `annotation_name` accepts only a single annotation, the platform name")
+                               return
+                       end
+                       assert items.length == 1
+
+                       var item = items.first
+                       platform = item.name
+               end
+
+               # Store the flags in the module
                for opt in simplified_options do
-                       var cmd = opt.option
+                       var arg = opt.option
                        if annotation_name == compiler_annotation_name then
-                               process_c_compiler_annotation(mmodule, cmd)
+                               mmodule.cflags.add_one(platform, arg)
                        else if annotation_name == linker_annotation_name then
-                               process_c_linker_annotation(mmodule, cmd)
+                               mmodule.ldflags.add_one(platform, arg)
                        else if annotation_name == cpp_compiler_annotation_name then
-                               process_cpp_compiler_annotation(mmodule, cmd)
+                               mmodule.cppflags.add_one(platform, arg)
                        else abort
                end
        end
 
-       fun process_c_compiler_annotation(mmodule: MModule, opt: String)
-       do
-               mmodule.c_compiler_options = "{mmodule.c_compiler_options} {opt}"
-       end
-
-       fun process_c_linker_annotation(mmodule: MModule, opt: String)
-       do
-               mmodule.c_linker_options = "{mmodule.c_linker_options} {opt}"
-       end
-
-       fun process_cpp_compiler_annotation(mmodule: MModule, opt: String)
-       do
-               mmodule.cpp_compiler_options = "{mmodule.cpp_compiler_options} {opt}"
-       end
 end
 
 abstract class CCompilerOption
@@ -166,7 +178,6 @@ class DirectCCompilerOption
        super CCompilerOption
 
        var option: String
-       init (opt: String) do option = opt
 end
 
 class ExecCCompilerOption
@@ -174,10 +185,4 @@ class ExecCCompilerOption
 
        var command: Array[String]
        var exec_node: ACallExpr
-
-       init (command: Array[String], exec_node: ACallExpr)
-       do
-               self.command = command
-               self.exec_node = exec_node
-       end
 end