src/compiling/compiling_base.nit

   1 # This file is part of NIT ( http://www.nitlanguage.org ).
   2 #
   3 # Copyright 2008 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 # Common things for NIT compilation and C generation
  18 package compiling_base
  19
  20 import syntax
  21 private import utils
  22
  23 redef class ToolContext
  24         readable writable attr _global: Bool = false
  25         readable writable attr _compdir: String
  26         readable writable attr _clibdir: String
  27         readable writable attr _bindir: String
  28         readable writable attr _output_file: String
  29         readable writable attr _boost: Bool = false
  30         readable writable attr _no_cc: Bool = false
  31         readable writable attr _ext_prefix: String
  32 end
  33
  34 # Class used to generate files.
  35 # Note that in fact it is not a visitor.
  36 # Note also that this class is unefficient and poorly designed thus requires love.
  37 class CompilerVisitor
  38         # Add a line in the current declaration block
  39         meth add_decl(s: String)
  40         do
  41                 if _indent_level >= 8 then
  42                         _ctx.decls.add("\t\t" + s)
  43                 else
  44                         _ctx.decls.add("  " * _indent_level + s)
  45                 end
  46         end
  47
  48         # Add a line in the current instr block
  49         meth add_instr(s: String)
  50         do
  51                 if _indent_level >= 8 then
  52                         _ctx.instrs.add("\t\t" + s)
  53                 else
  54                         _ctx.instrs.add("  " * _indent_level + s)
  55                 end
  56         end
  57
  58         # Return a unique new number for the instance
  59         meth new_number: Int
  60         do
  61                 var res = _number_cpt
  62                 _number_cpt = res + 1
  63                 return res
  64         end
  65         # next number for new_number
  66         attr _number_cpt: Int = 0
  67
  68         # Add an indent level.
  69         # New decl and instr will be indented.
  70         meth indent do _indent_level += 1
  71
  72         # Remove an indent level.
  73         meth unindent
  74         do
  75                 _indent_level -= 1
  76                 if _indent_level < 0 then _indent_level = 0
  77         end
  78
  79         # Return a big string containing all decl and instr
  80         redef meth to_s
  81         do
  82                 var out = new Array[String]
  83                 out.append(_ctx.decls)
  84                 out.append(_ctx.instrs)
  85                 out.add("")
  86                 return out.join("\n")
  87         end
  88
  89         # The current module processed
  90         readable writable attr _module: MMSrcModule
  91
  92         # Where instr and decl are stored
  93         readable writable attr _ctx: CContext = new CContext
  94
  95         # The current indent lever
  96         readable writable attr _indent_level: Int = 0
  97
  98         # The current ToolContext
  99         readable writable attr _tc: ToolContext
 100
 101         # Create a new CompilerVisitor based on a module
 102         init(module: MMSrcModule) do _module = module
 103 end
 104
 105 # Where instr and decl are stored for a module
 106 # Note that this class is as badly designed as CompilerVisitor
 107 class CContext
 108         readable attr _decls: Array[String] = new Array[String]
 109         readable attr _instrs: Array[String] = new Array[String]
 110
 111         meth append(c: CContext)
 112         do
 113                 _instrs.append(c.decls)
 114                 _instrs.append(c.instrs)
 115         end
 116
 117         meth merge(c: CContext)
 118         do
 119                 _decls.append(c.decls)
 120                 _instrs.append(c.instrs)
 121         end
 122
 123         init do end
 124 end
 125
 126 redef class MMGlobalProperty
 127         # C symbol refering a method inocation
 128         meth meth_call: String
 129         do
 130                 return "CALL_{intro.cname}"
 131         end
 132
 133         # C symbol refering an attribure access
 134         meth attr_access: String
 135         do
 136                 return "ATTR_{intro.cname}"
 137         end
 138 end
 139
 140 redef class MMGlobalClass
 141         # C symbol refering the identifier of the class
 142         meth id_id: String
 143         do
 144                 return "ID_{intro.name}"
 145         end
 146
 147         # C symbol refering the color of the class (for subtype tests)
 148         meth color_id: String
 149         do
 150                 return "COLOR_{intro.name}"
 151         end
 152
 153         # C symbol refering the init table position of the class (for constructor linearization)
 154         meth init_table_pos_id: String
 155         do
 156                 return "INIT_TABLE_POS_{intro.name}"
 157         end
 158 end
 159
 160 redef class MMLocalClass
 161         # Cached primitive_info result
 162         attr _primitive_info_cache: PrimitiveInfo
 163
 164         # If primitive_info result cached?
 165         attr _primitive_info_b: Bool = false
 166
 167         # Return the primitive information of the class.
 168         # Return null if the class is not primitive
 169         # FIXME: Only here since there is no universal type yet
 170         meth primitive_info: PrimitiveInfo
 171         do
 172                 if _primitive_info_b == true then return _primitive_info_cache
 173
 174                 var ctypes = once primitive_ctypes
 175                 if ctypes.has_key(name) then
 176                         _primitive_info_cache = ctypes[name]
 177                         _primitive_info_b = true
 178                         return _primitive_info_cache
 179                 end
 180                 var i = ctypes.iterator
 181                 while i.is_ok do
 182                         var n = i.key
 183                         if module.has_global_class_named(n) then
 184                                 var c = module.class_by_name(n)
 185                                 if cshe < c then
 186                                         _primitive_info_cache = i.item
 187                                         _primitive_info_b = true
 188                                         return _primitive_info_cache
 189                                 end
 190                         end
 191                         i.next
 192                 end
 193                 _primitive_info_b = true
 194                 return null
 195         end
 196
 197         # Static information of primitive types
 198         private meth primitive_ctypes: HashMap[Symbol, PrimitiveInfo]
 199         do
 200                 var res = new HashMap[Symbol, PrimitiveInfo]
 201                 var pnames = ["Int",    "Char", "Bool", "Float", "NativeString", "NativeArray", "Pointer"]
 202                 var tagged = [true,     true,   true,   false,   false,          false,         false]
 203                 var cnames = ["bigint", "char", "int",  "float", "char *",       "val_t *",     "void *"]
 204                 for i in [0..pnames.length[ do
 205                         var n = pnames[i].to_symbol
 206                         var pi = new PrimitiveInfo
 207                         pi.name = n
 208                         pi.tagged = tagged[i]
 209                         pi.cname = cnames[i]
 210                         res[n] = pi
 211                 end
 212                 return res
 213         end
 214 end
 215
 216 # Information about a primitive class
 217 class PrimitiveInfo
 218         # The name of the class
 219         readable writable attr _name: Symbol
 220
 221         # Is the class tagged (aka not boxed)
 222         readable writable attr _tagged: Bool
 223
 224         # The corresponding c type for the primitive value
 225         readable writable attr _cname: String
 226
 227         private init do end
 228 end
 229
 230 redef class MMType
 231         # The corresponding c type
 232         meth cname: String
 233         do
 234                 var pi = local_class.primitive_info
 235                 if pi == null then
 236                         return "val_t"
 237                 else
 238                         return pi.cname
 239                 end
 240         end
 241
 242         # The default c value for uninitialized types.
 243         # Return "null" for non primitive types and something more specific for primitive types
 244         meth default_cvalue: String
 245         do
 246                 var pi = local_class.primitive_info
 247                 if pi != null and pi.tagged then
 248                         return "TAG_{local_class.name}(({pi.cname})0)"
 249                 else
 250                         return "NIT_NULL"
 251                 end
 252         end
 253
 254         # Box (or tag) a primitive value
 255         # Is identity if not primitive
 256         meth boxtype(s: String): String
 257         do
 258                 var pi = local_class.primitive_info
 259                 if pi == null then
 260                         return s
 261                 else if pi.tagged then
 262                         return "TAG_{local_class.name}({s})"
 263                 else
 264                         return "BOX_{local_class.name}({s})"
 265                 end
 266         end
 267
 268         # Unbox (or untag) a primitive value
 269         # Is identity if not primitive
 270         meth unboxtype(s: String): String
 271         do
 272                 var pi = local_class.primitive_info
 273                 if pi == null then
 274                         return s
 275                 else if pi.tagged then
 276                         return "UNTAG_{local_class.name}({s})"
 277                 else
 278                         return "UNBOX_{local_class.name}({s})"
 279                 end
 280         end
 281 end
 282
 283 redef class MMLocalProperty
 284         # Cacher result of cname
 285         attr _cname_cache: String
 286
 287         # The mangled name of the method
 288         meth cname: String
 289         do
 290                 if _cname_cache == null then
 291                         _cname_cache = cmangle(module.name, local_class.name, name)
 292                 end
 293                 return _cname_cache
 294         end
 295
 296         # C macro used to get the function for the call of a super property
 297         meth super_meth_call: String
 298         do
 299                 return "CALL_SUPER_{cname}"
 300         end
 301 end
 302