src/literal.nit

   1 # This file is part of NIT ( http://www.nitlanguage.org ).
   2 #
   3 # Copyright 2012 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 # Parsing of literal values in the abstract syntax tree.
  18 module literal
  19
  20 import parser
  21 import toolcontext
  22 import phase
  23
  24 import modelbuilder #FIXME useless
  25
  26 redef class ToolContext
  27         var literal_phase: Phase = new LiteralPhase(self, null)
  28 end
  29
  30 private class LiteralPhase
  31         super Phase
  32
  33         redef fun process_nmodule(nmodule) do nmodule.do_literal(toolcontext)
  34 end
  35
  36 redef class AModule
  37         # Visit the module to compute the real value of the literal-related node of the AST.
  38         # Warnings and errors are displayed on the toolcontext.
  39         fun do_literal(toolcontext: ToolContext)
  40         do
  41                 var v = new LiteralVisitor(toolcontext)
  42                 v.enter_visit(self)
  43         end
  44 end
  45
  46 private class LiteralVisitor
  47         super Visitor
  48
  49         var toolcontext: ToolContext
  50
  51         init(toolcontext: ToolContext)
  52         do
  53                 self.toolcontext = toolcontext
  54         end
  55
  56         redef fun visit(n)
  57         do
  58                 n.accept_literal(self)
  59                 n.visit_all(self)
  60         end
  61 end
  62
  63 redef class ANode
  64         private fun accept_literal(v: LiteralVisitor) do end
  65 end
  66
  67 redef class AIntExpr
  68         # The value of the literal int once computed.
  69         var value: nullable Int
  70         redef fun accept_literal(v)
  71         do
  72                 self.value = self.n_number.text.to_i
  73         end
  74 end
  75
  76 redef class AFloatExpr
  77         # The value of the literal float once computed.
  78         var value: nullable Float
  79         redef fun accept_literal(v)
  80         do
  81                 self.value = self.n_float.text.to_f
  82         end
  83 end
  84
  85 redef class ACharExpr
  86         # The value of the literal char once computed.
  87         var value: nullable Char
  88         redef fun accept_literal(v)
  89         do
  90                 var txt = self.n_char.text.unescape_nit
  91                 if txt.length != 3 then
  92                         v.toolcontext.error(self.hot_location, "Invalid character literal {txt}")
  93                         return
  94                 end
  95                 self.value = txt[1]
  96         end
  97 end
  98
  99 redef class AStringFormExpr
 100         # The value of the literal string once computed.
 101         var value: nullable String
 102         redef fun accept_literal(v)
 103         do
 104                 var txt = self.n_string.text
 105                 var skip = 1
 106                 if txt[0] == txt[1] and txt.length >= 6 then skip = 3
 107                 self.value = txt.substring(skip, txt.length-(2*skip)).unescape_nit
 108         end
 109 end
 110
 111 redef class String
 112         # Return a string where Nit escape sequences are transformed.
 113         #
 114         # Example:
 115         #     var s = "\\n"
 116         #     print s.length # -> 2
 117         #     var u = s.unescape_nit
 118         #     print s.length # -> 1
 119         #     print s[0].ascii # -> 10 (the ASCII value of the "new line" character)
 120         fun unescape_nit: String
 121         do
 122                 var res = new Buffer.with_capacity(self.length)
 123                 var was_slash = false
 124                 for c in self do
 125                         if not was_slash then
 126                                 if c == '\\' then
 127                                         was_slash = true
 128                                 else
 129                                         res.add(c)
 130                                 end
 131                                 continue
 132                         end
 133                         was_slash = false
 134                         if c == 'n' then
 135                                 res.add('\n')
 136                         else if c == 'r' then
 137                                 res.add('\r')
 138                         else if c == 't' then
 139                                 res.add('\t')
 140                         else if c == '0' then
 141                                 res.add('\0')
 142                         else
 143                                 res.add(c)
 144                         end
 145                 end
 146                 return res.to_s
 147         end
 148 end