src/ffi/c_compiler_options.nit

   1 # This file is part of NIT ( http://www.nitlanguage.org ).
   2 #
   3 # Copyright 2013 Alexis Laferrière <alexis.laf@xymus.net>
   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 # Offers the annotations `cflags` and `ldflags` to specify
  18 # options for the C compiler directly or indirectly. Differs from the `pkgconfig`
  19 # annotation by the separation of the options between the compiler and linker.
  20 module c_compiler_options
  21
  22 import c
  23 import cpp
  24 private import annotation
  25
  26 redef class ToolContext
  27         var cflags_phase: Phase = new CCompilerOptionsPhase(self, null)
  28 end
  29
  30 private class CCompilerOptionsPhase
  31         super Phase
  32
  33         fun compiler_annotation_name: String do return "cflags"
  34         fun linker_annotation_name: String do return "ldflags"
  35         fun cpp_compiler_annotation_name: String do return "cppflags"
  36
  37         redef fun process_annotated_node(nmoduledecl, nat)
  38         do
  39                 # Skip if we are not interested
  40                 var annotation_name = nat.name
  41                 if annotation_name != compiler_annotation_name and
  42                    annotation_name != linker_annotation_name and
  43                    annotation_name != cpp_compiler_annotation_name then return
  44
  45                 # Do some validity checks and print errors if the annotation is used incorrectly
  46                 var modelbuilder = toolcontext.modelbuilder
  47
  48                 if not nmoduledecl isa AModuledecl then
  49                         modelbuilder.error(nat, "Syntax error: only the declaration of modules may use \"{annotation_name}\".")
  50                         return
  51                 end
  52
  53                 var args = nat.n_args
  54                 if args.is_empty then
  55                         modelbuilder.error(nat, "Syntax error: \"{annotation_name}\" expects at least one argument.")
  56                         return
  57                 end
  58
  59                 var options = new Array[CCompilerOption]
  60                 for expr in args do
  61                         if expr isa AStringFormExpr then
  62                                 var text = expr.collect_text
  63                                 text = text.substring(1, text.length-2)
  64                                 var opt = new DirectCCompilerOption(text)
  65                                 options.add(opt)
  66                         else if expr isa ACallExpr then
  67                                 # We support calls to "exec" only
  68                                 var exec_args = expr.n_args.to_a
  69                                 if expr.n_id.text != "exec" or exec_args.is_empty then
  70                                         modelbuilder.error(nat, "Syntax error: \"{annotation_name}\" accepts only calls to `exec` with the command as arguments.")
  71                                         return
  72                                 end
  73
  74                                 var exec_args_as_strings = new Array[String]
  75                                 for exec_arg in exec_args do
  76                                         if not exec_arg isa AStringFormExpr then
  77                                                 modelbuilder.error(nat, "Syntax error: calls to `exec` expects the arguments to be String literals.")
  78                                                 return
  79                                         else
  80                                                 var arg_string = exec_arg.collect_text
  81                                                 arg_string = arg_string.substring(1, arg_string.length-2)
  82                                                 exec_args_as_strings.add(arg_string)
  83                                         end
  84                                 end
  85
  86                                 var opt = new ExecCCompilerOption(exec_args_as_strings, expr)
  87                                 options.add(opt)
  88                         else
  89                                 modelbuilder.error(nat, "Syntax error: \"{annotation_name}\" expects its arguments to be the name of the package as String literals.")
  90                                 return
  91                         end
  92                 end
  93
  94                 # process calls to external command
  95                 var simplified_options = new Array[DirectCCompilerOption]
  96                 for opt in options do
  97                         if opt isa ExecCCompilerOption then
  98                                 # prepare to execute command
  99                                 var cmd_args = opt.command
 100                                 var proc
 101                                 if cmd_args.length == 1 then
 102                                         proc = new IProcess.from_a(cmd_args[0], new Array[String])
 103                                 else if cmd_args.length > 1 then
 104                                         var rest_args = cmd_args.subarray(1, cmd_args.length-1)
 105                                         proc = new IProcess.from_a(cmd_args[0], rest_args)
 106                                 else abort
 107
 108                                 # wait for its completion
 109                                 proc.wait
 110
 111                                 # check result
 112                                 var status = proc.status
 113                                 if status != 0 then
 114                                         modelbuilder.error(opt.exec_node, "Annotation error: Something went wrong executing the argument of annotation \"{annotation_name}\", make sure the command is valid.")
 115                                         return
 116                                 end
 117
 118                                 # process result
 119                                 var result = proc.read_all.replace("\n", " ")
 120                                 if result.is_empty then
 121                                         modelbuilder.error(opt.exec_node, "Annotation error: Got no result from the command, make sure it is valid.")
 122                                         return
 123                                 end
 124                                 simplified_options.add(new DirectCCompilerOption(result))
 125                         else
 126                                 assert opt isa DirectCCompilerOption
 127                                 simplified_options.add(opt)
 128                         end
 129                 end
 130
 131                 # retreive module
 132                 var mmodule = nmoduledecl.parent.as(AModule).mmodule.as(not null)
 133
 134                 for opt in simplified_options do
 135                         var cmd = opt.option
 136                         if annotation_name == compiler_annotation_name then
 137                                 process_c_compiler_annotation(mmodule, cmd)
 138                         else if annotation_name == linker_annotation_name then
 139                                 process_c_linker_annotation(mmodule, cmd)
 140                         else if annotation_name == cpp_compiler_annotation_name then
 141                                 process_cpp_compiler_annotation(mmodule, cmd)
 142                         else abort
 143                 end
 144         end
 145
 146         fun process_c_compiler_annotation(mmodule: MModule, opt: String)
 147         do
 148                 mmodule.cflags = "{mmodule.cflags} {opt}"
 149         end
 150
 151         fun process_c_linker_annotation(mmodule: MModule, opt: String)
 152         do
 153                 mmodule.ldflags = "{mmodule.ldflags} {opt}"
 154         end
 155
 156         fun process_cpp_compiler_annotation(mmodule: MModule, opt: String)
 157         do
 158                 mmodule.cppflags = "{mmodule.cppflags} {opt}"
 159         end
 160 end
 161
 162 abstract class CCompilerOption
 163 end
 164
 165 class DirectCCompilerOption
 166         super CCompilerOption
 167
 168         var option: String
 169 end
 170
 171 class ExecCCompilerOption
 172         super CCompilerOption
 173
 174         var command: Array[String]
 175         var exec_node: ACallExpr
 176 end