riml 0.2.1 → 0.2.2

data/README.md

@@ -4,12 +4,13 @@ Riml, a relaxed version of Vimscript
 ====================================
 
 Riml aims to be a superset of VimL that includes some nice features that I
-enjoy in other scripting languages, including classes, string interpolation,
-heredocs, default case-sensitive string comparison and other things most
-programmers take for granted. Also, Riml takes some liberties and provides
-some syntactic sugar for lots of VimL constructs. To see how Riml constructs
-are compiled into VimL, just take a look in this README. The left side is Riml,
-and the right side is the equivalent VimL after compilation.
+enjoy in other scripting languages: classes, string interpolation,
+heredocs, default case-sensitive string comparison, default parameters
+in functions, and other things programmers tend to take for granted. Also, Riml takes
+some liberties and provides some syntactic sugar for lots of VimL constructs.
+To see how Riml constructs are compiled to VimL, just take a look at this README.
+The left side is Riml, and the right side is the VimL after compilation.
+
 Variables
 ---------
 
@@ -19,17 +20,30 @@ Variables
       count += 1                    let s:count += 1
     end                           endwhile
 
-If you don't specify a scope modifier, it's script local by default in the
-global namespace. Within a function, variables without scope modifiers are plain
+If you don't specify a scope modifier (or namespace in Vimspeak), it's script local (s:)
+by default in the global scope. Within a function, variables without scope modifiers are plain
 old local variables.
 
 ###globally
 
     a = 3                         let s:a = 3
 
-###locally
+###locally (within function or for loop)
+
+    def exampleFunc(msg)          function! s:exampleFunc(msg)
+      a = 3                         let a = 3
+      echo msg                      echo a:msg
+    end                           endfunction
+
+    for i in expr()               for i in s:expr()
+      echo i                        echo i
+    end                           endfor
 
-    a = 3                         let a = 3
+Notice that within a function, it's unnecessary to prefix argument variables
+with 'a:'. This is, of course, unless we shadow the argument variable by creating
+our own local variable called 'msg'. In that case, we'd have to refer to the argument variable
+as 'a:msg' explicitly. Shadowing variables in Riml is considered bad practice, as it's
+much easier to just come up with unique variable names across a scope.
 
 ###Freeing memory
 
@@ -43,22 +57,82 @@ old local variables.
     callcount += 1                        let s:callcount += 1
     echo "called #{callcount} times"      echo "called " . s:callcount . " times"
 
-Comparisons
------------
+Notice in the last line of Riml there's string interpolation. This works
+in double-quoted strings and heredocs, which we'll encounter later.
+
+In Riml, you can choose to end any block with 'end', or with whatever you used
+to do in Vimscript ('endif', 'endfunction', etc...). Also, 'if' and 'unless' can
+now be used as statement modifiers:
+
+    callcount = 0 unless s:callcount?
+    callcount += 1
+    echo "called #{callcount} times"
 
-    a = "hi" == "hi"                      if ("hi" ==# "hi")
-                                            let s:a = 1
-                                          else
-                                            let s:a = 0
-                                          endif
+Here, the compiled output is the same as the previous example's. Both 'if' and
+'unless' can be used this way.
+
+Operators And Case Sensitivity
+------------------------------
+
+    if "hi" == greeting                      if "hi" ==# s:greeting
+      echo greeting                            echo s:greeting
+    end                                      end
+
+Comparisons compile to case-sensitive by default. To get case-insensitive
+comparisons, you have to explicitly use the form ending in '?' (ex: '==?').
+The only operators that don't add a '#' even though the forms exist are the
+'is' and 'isnot' operators. This is because 'is' is much different from its
+cousin 'is#', and the same is true of 'isnot'.
 
 Heredocs
 --------
 
-    msg = <<EOS                           let s:msg = "a vim heredoc! " . s:cryForJoy() . "!\n"
+    msg = <<EOS                           let s:msg = "a vim heredoc! " . s:cryForJoy() . "!\nHooray!\n"
     A vim heredoc! #{cryForJoy()}!
+    Hooray!
     EOS
 
+Riml heredocs must have the ending pattern start at the beginning
+of the line. Interpolating expressions is allowed in heredocs. Compiled
+heredocs always end with a newline.
+
+Functions
+---------
+
+    def fillSearchPat             function! s:fillSearchPat()
+      @/ = getSearchPat()           let @/ = s:getSearchPat()
+      return @/                     return @/
+    end                           endfunction
+
+When defining a function with no parameters, the parens after the function name are optional.
+
+Functions are by default prepended by 's:' unless explicitly prepended with a
+different scope modifier. Of course, you can use the old form ('function! Name()') for defining
+functions if you want, as Riml aims to be a superset of VimL. There are a few exceptions
+where Riml and VimL aren't compatible, and these differences are explained in
+the section 'Incompatibilities with VimL'.
+
+###Default Arguments
+
+    def fillSearchPat(pat = getDefaultSearchPat())        function! s:fillSearchPat(...)
+      @/ = pat                                              if get(a:000, 0, 'rimldefault') !=# 'rimldefault'
+      return @/                                               let pat = remove(a:000, 0)
+    end                                                     else
+                                                              let pat = s:getDefaultSearchPat()
+                                                            endif
+                                                            @/ = pat
+                                                            return @/
+                                                          endfunction
+
+
+Default arguments must be the last arguments given to a function, but there can be more
+than one default argument. Also, a splat argument (... or \*argName) can come after default argument(s).
+Splats will be explained in the next section.
+
+We can now call the function 'fillSearchPat' without any arguments and it will use the default
+argument. Also, if we pass the string 'rimldefault', it will use the default argument as well. This
+is useful if a function has many default arguments.
+
 Classes
 -------
 
@@ -82,7 +156,17 @@ Classes
                                                          return self.otherData
                                                        endfunction
 
-###Class with Inheritance
+Classes can only be defined once, and cannot be reopened. Public member
+functions are defined with 'defm'. If you want to create a non-public function
+inside a class, use 'def'. To create an instance of this class, simply:
+
+    obj = new MyClass('someData', 'someOtherData')
+
+In this basic example of a class, we see a \*splat variable. This is just a
+convenient way to refer to 'a:000' in a function. Splat variables are optional
+parameters and get compiled to '...'.
+
+###Class Inheritance
 
     class Translation                                  function! g:TranslationConstructor(input)
       def initialize(input)                              let translationObj = {}
@@ -108,6 +192,178 @@ Classes
 
                                                        let s:translation = g:TranslationConstructor("Bonjour!")
                                                        call s:translation.translate()
+    => "Hello!"
+
+Classes that inherit must have their superclass defined before inheritance takes place. In
+this example, 'Translation' is defined first, which is legal. Since 'Translation'
+has an initialize function and 'FrenchToEnglishTranslation' (referred to now as FET)
+doesn't, FET instances use the initialize function from 'Translation', and new
+instances must be provided with an 'input' argument on creation. Basically, if
+a class doesn't provide an initialize function, it uses its superclass's.
+
+If you look at the last line of Riml in the previous example, you'll see that
+it doesn't use Vimscript's builtin 'call' function for calling the 'translate'
+method on the translation object. Riml can figure out when 'call' is necessary,
+and will add it to the compiled Vimscript.
+
+###Using 'super'
+
+    class Car                                             function! g:CarConstructor(make, model, color)
+      def initialize(make, model, color)                    let carObj = {}
+        self.make = make                                    let carObj.make = a:make
+        self.model = model                                  let carObj.model = a:model
+        self.color = color                                  let carObj.color = a:color
+      end                                                 endfunction
+    end
+
+    class HotRod < Car                                    function! g:HotRodConstructor(make, model, color, topSpeed)
+      def initialize(make, model, color, topSpeed)          let hotRodObj = {}
+        self.topSpeed = topSpeed                            let hotRodObj.topSpeed = a:topSpeed
+        super(make, model, color)                           let carObj = g:CarConstructor(a:make, a:model, a:color)
+      end                                                   call extend(hotRodObj, carObj)
+                                                            let hotRodObj.drive = function('g:HotRod_drive')
+      defm drive                                            return hotRodObj
+        if self.topSpeed > 140                            endfunction
+          echo "Ahhhhhhh!"
+        else                                              function! g:HotRod_drive() dict
+          echo "Nice"                                       if self.topSpeed ># 140
+        end                                                   echo "Ahhhhhhh!"
+      end                                                   else
+    end                                                       echo "Nice"
+                                                            endif
+    newCar = new HotRod("chevy", "mustang", "red", 160)   endfunction
+    newCar.drive()
+                                                          let s:newCar = g:HotRodConstructor("chevy", "mustang", "red", 160)
+                                                          call s:newCar.drive()
+
+Use of 'super' is legal only within subclasses. If arguments are given, these arguments are sent
+to the superclass's function of the same name. If no arguments are given and parentheses are omitted,
+('super' as opposed to 'super()'), every single argument is passed to the superclass's function.
+This mirrors Ruby's approach.
+
+Super can be called from an initialize (constructor) function, a public member function
+('defm'), or a non-public function ('def'). An error is given during compilation if no
+superclass function with that name is defined.
+
+Compiling Riml
+--------------
+
+To compile a riml file named 'example.riml' that resides in the current
+directory:
+
+    $ riml -c example.riml
+
+This will create a new VimL file named 'example.vim'.
+
+###riml\_source
+
+It's useful to split a project into many files. For example, imagine we're creating a plugin
+called 'awesome' that does something totally awesome, and it relies on another library
+we wrote called 'my\_framework' that's also written in Riml.
+
+Somewhere in 'awesome.riml', we have the line:
+
+    riml_source 'my_framework.riml'
+
+This will compile the file 'my\_framework.riml' and create a VimL file named
+'my\_framework.vim'.
+
+In 'awesome.riml', that line will be compiled to:
+
+    source 'my_framework.vim'
+
+This process is recursive, meaning that if 'my\_framework.riml' riml\_source's other
+files, then those files will be compiled as well.
+
+In 'awesome.riml', all the classes that were available by compiling 'my\_framework.riml'
+are now available to it, so we can now subclass classes that were defined either
+in 'my\_framework.riml' itself, or any files that it riml\_source'd either directly
+or indirecty.
+
+
+###riml\_include
+
+Sometimes it's useful to have many files in development, but to include a file's contents
+into another file during the build process. This is much like the C preprocessor's #include
+directive.
+
+To include a file named 'my\_lib.riml':
+
+    riml_include 'my_lib.riml'
+
+This compiles the file and includes its content in place of the riml\_include directive itself.
+Much like riml\_sourcing, the process is recursive. If 'my\_lib.riml' includes files, these files
+are also compiled and will be part of the inclusion. Note that riml\_include does not create a
+new file like riml\_source does.
+
+Incompatibilities with VimL
+---------------------------
+
+Riml aims to be a superset of VimL, therefore any legal VimL should be legal
+Riml as well. Unfortunately, this is not 100% possible as Vim is an old and
+cryptic beast, and trying to create grammar for every possible Vim construct
+would be a nightmare. In practice, however, when I've transformed plain old vim plugins
+to be Riml-compatible, only a couple of ':' needed to be placed in strategic locations
+for it to be valid Riml. This is explained below.
+
+###Ex-literals
+
+Fortunately, there are some pretty simple rules to follow to get valid Riml.
+
+When doing anything with autocommands, normal, commands, set, ranges, etc... simply do:
+
+    :autocmd BufEnter * blahblah...
+
+That is, prepend ':' to the line. When a line starts with ':', it passes directly
+through the compiler and no transformations occur. This includes string interpolation,
+which is ignored as well.
+
+In Riml, when a line starts with ':' it's called an ex-literal.
+
+Ex-literals are necessary for the following:
+
+* autocommands
+* command definitions
+* set
+* ranges (:h cmdline-ranges)
+* normal (:h normal)
+* mappings
+* augroups
+
+Basically anything that isn't a class, number, string, list, dict, function call,
+function definition, loop or if construct, variable definition or unlet, etc...
+needs to be an ex-literal in Riml.
+
+Note that, like 'echo' which isn't a builtin function (:h functions) but is still legal
+Riml, 'execute' is also allowed as it takes a string. This is extremely useful, as we can
+now use execute with a string that allows interpolation.
+
+Imagine having to write a grammar rule for the following:
+
+    set statusline+=[%{strlen(&fenc)?&fenc:'none'}, " File encoding
+
+Since there's no string after the '+=', it makes it very hard.
+So when the compiler can't parse a file correctly, prepend those lines with
+':' and all should be well.
+
+###Abbreviations
+
+In VimL, there are abbreviations for everything; even "keywords" like 'function' can be
+abbreviated. In Riml, abbreviations are not allowed. This makes Riml much easier to read
+and understand.
+
+Everything Else That Works
+--------------------------
 
+Everything not mentioned above as illegal is legal Riml. Here's a short (non-comprehensive) list
+of constructs which are legal Riml but not mentioned in any of the examples:
 
-Coming soon: for a full list of the language's rules complete with examples, check out the Wiki
+* try/catch/finally blocks and throw
+* curly-brace variable and function names
+* while (and until) loops
+* ternary operators
+* exponents
+* line continuations
+* autoloadable variables and functions (:h autoload)
+* let unpack (:h let-unpack)
+* Much more!

data/bin/riml

@@ -38,7 +38,7 @@ module Riml
           append_filenames_to_list_if_all_exist(options.check_syntax_files, *filenames)
         end
 
-        opts.on("-t", "--source-path PATH", "Path riml uses for `riml_source` and `riml_include` to find files. Defaults to pwd.") do |path|
+        opts.on("-t", "--source-path PATH", "Colon-separated Path riml uses for `riml_source` and `riml_include` to find files. Defaults to pwd.") do |path|
           if Dir.exists?(path)
             Riml.source_path = path
           else

data/lib/ast_rewriter.rb

@@ -150,9 +150,10 @@ module Riml
           AssignNode.new('=', GetVariableNode.new(nil, dict_name), DictionaryNode.new({}))
         )
 
-        SuperToObjectExtension.new(constructor, classes, node).rewrite_on_match
+        InitializeSuperToObjectExtension.new(constructor, classes, node).rewrite_on_match
         ExtendObjectWithMethods.new(node, classes).rewrite_on_match
         SelfToDictName.new(dict_name).rewrite_on_match(constructor)
+        SuperToSuperclassFunction.new(node, classes).rewrite_on_match
 
         constructor.expressions.push(
           ReturnNode.new(GetVariableNode.new(nil, dict_name))
@@ -241,7 +242,7 @@ module Riml
         end
       end
 
-      class SuperToObjectExtension < AST_Rewriter
+      class InitializeSuperToObjectExtension < AST_Rewriter
         attr_reader :class_node
         def initialize(constructor, classes, class_node)
           super(constructor, classes)
@@ -291,6 +292,64 @@ module Riml
           false
         end
       end
+
+      # rewrites calls to 'super' in non-initialize function
+      class SuperToSuperclassFunction < AST_Rewriter
+        def match?(node)
+          return false unless SuperNode === node
+          n = node
+          n = n.parent until DefNode === n || n.nil?
+          return false if n.nil? || ast.constructor == n
+          @function_node = n
+        end
+
+        def replace(node)
+          func_scope = @function_node.scope_modifier
+          superclass = classes[ast.superclass_name]
+          while superclass && !superclass.has_function?(func_scope, superclass_func_name(superclass)) && superclass.superclass?
+            superclass = classes[superclass.superclass_name]
+          end
+          if superclass.nil? || !superclass.has_function?(func_scope, superclass_func_name(superclass))
+            raise Riml::UserFunctionNotFoundError,
+              "super was called in class #{ast.name} in " \
+              "function #{@function_node.original_name}, but there are no " \
+              "functions with this name in that class's superclass hierarchy."
+          end
+          call_node = CallNode.new(
+            nil,
+            DictGetDotNode.new(
+              GetVariableNode.new(nil, 'self'),
+              [superclass_func_name(superclass)]
+            ),
+            node.arguments
+          )
+
+          node.replace_with(call_node)
+          add_superclass_func_ref_to_constructor(superclass)
+          reestablish_parents(@function_node)
+        end
+
+        def superclass_func_name(superclass)
+          "#{superclass.name}_#{@function_node.original_name}"
+        end
+
+        def add_superclass_func_ref_to_constructor(superclass)
+          super_func_name = superclass_func_name(superclass)
+          assign_node = AssignNode.new('=',
+            DictGetDotNode.new(
+              GetVariableNode.new(nil, ast.constructor_obj_name),
+              [super_func_name]
+            ),
+            CallNode.new(
+              nil,
+              'function',
+              [StringNode.new("g:#{super_func_name}", :s)]
+            )
+          )
+          ast.constructor.expressions << assign_node
+          reestablish_parents(ast.constructor)
+        end
+      end
     end # ClassDefinitionToFunctions
 
     class ObjectInstantiationToCall < AST_Rewriter

data/lib/compiler.rb

@@ -242,10 +242,15 @@ module Riml
       private
       def scope_modifier_for_node(node)
         if node.scope
-          return "a:" if node.scope.argument_variable_names.include?(node.name)
-          return "" unless node.is_a?(CallNode)
+          if node.scope.function && DefNode === node && !node.defined_on_dictionary?
+            return "s:"
+          elsif node.scope.argument_variable_names.include?(node.name)
+            return "a:"
+          elsif !node.is_a?(CallNode)
+            return ""
+          end
         end
-        return "" if (node.is_a?(CallNode) || node.is_a?(DefNode)) && node.autoload?
+        return "" if node.respond_to?(:autoload?) && node.autoload?
         "s:"
       end
     end
@@ -376,7 +381,11 @@ module Riml
 
     class DefNodeVisitor < ScopedVisitor
       def visit(node)
-        setup_local_scope_for_descendants(node)
+        options = {}
+        if node.nested_function?
+          options[:nested_function] = true
+        end
+        setup_local_scope_for_descendants(node, options)
         super
       end
 
@@ -406,8 +415,9 @@ module Riml
       end
 
       private
-      def setup_local_scope_for_descendants(node)
-        node.expressions.accept(EstablishScopeVisitor.new(:scope => node.to_scope))
+      def setup_local_scope_for_descendants(node, options)
+        options.merge!(:scope => node.to_scope)
+        node.expressions.accept(EstablishScopeVisitor.new(options))
       end
 
       def process_parameters!(node)
@@ -430,6 +440,7 @@ module Riml
     class EstablishScopeVisitor < DrillDownVisitor
       def initialize(options)
         @scope = options[:scope]
+        @nested_function = options[:nested_function]
       end
 
       def visit(node)
@@ -437,7 +448,7 @@ module Riml
       end
 
       def establish_scope(node)
-        if node.scope
+        if node.scope && !@nested_function
           node.scope = node.scope.merge @scope
         else
           node.scope = @scope

data/lib/errors.rb

@@ -10,6 +10,7 @@ module Riml
   IncludeNotTopLevel = Class.new(RimlError)
   # bad user arguments to Riml functions
   UserArgumentError = Class.new(RimlError)
+  UserFunctionNotFoundError = Class.new(RimlError)
 
   ClassNotFound = Class.new(RimlError)
   ClassRedefinitionError = Class.new(RimlError)

data/lib/lexer.rb

@@ -33,7 +33,6 @@ module Riml
       @indent_pending = false
       @dedent_pending = false
       @one_line_conditional_end_pending = false
-      @splat_allowed = false
       @in_function_declaration = false
     end
 
@@ -149,9 +148,7 @@ module Riml
           @in_function_declaration = false unless DEFINE_KEYWORDS.include?(identifier) && @token_buf.size == 1
         end
       elsif splat = chunk[/\A(\.{3}|\*[a-zA-Z_]\w*)/]
-        raise SyntaxError, "unexpected splat, has to be enclosed in parentheses" unless @splat_allowed
         @token_buf << [:SPLAT, splat]
-        @splat_allowed = false
         @i += splat.size
       # integer (octal)
       elsif octal = chunk[/\A0[0-7]+/]
@@ -201,13 +198,13 @@ module Riml
         pattern = $1
         @i += heredoc_pattern.size
         new_chunk = get_new_chunk
-        heredoc_string = new_chunk[%r|(.+?\r?\n)(#{Regexp.escape(pattern)})|, 1]
+        heredoc_string = new_chunk[%r|(.+?\r?\n)(#{Regexp.escape(pattern)})|m, 1]
         @i += heredoc_string.size + pattern.size
         if ('"' + heredoc_string + '"') =~ INTERPOLATION_REGEX
           parts = heredoc_string.split(INTERPOLATION_SPLIT_REGEX)
           handle_interpolation(*parts)
         else
-          @token_buf << [:STRING_D, escape_double_quotes(heredoc_string)]
+          @token_buf << [:STRING_D, escape_chars!(heredoc_string)]
         end
         @lineno += heredoc_string.each_line.to_a.size
       # operators of more than 1 char
@@ -227,8 +224,6 @@ module Riml
         else
           @token_buf << [value, value]
         end
-        @splat_allowed = true  if value == '('
-        @splat_allowed = false if value == ')'
         @i += 1
         if value == ']' || value == ')' && chunk[1, 1] == '.'
           parse_dict_vals!
@@ -287,15 +282,17 @@ module Riml
         if part[0..1] == '#{' && part[-1] == '}'
           @token_buf.concat tokenize_without_moving_pos(part[2...-1])
         else
-          @token_buf << [:STRING_D, escape_double_quotes(part)]
+          @token_buf << [:STRING_D, escape_chars!(part)]
         end
         # string-concatenate all the parts unless this is the last part
         @token_buf << ['.', '.'] unless parts[i + 1].nil?
       end
     end
 
-    def escape_double_quotes(string)
-      string.gsub(/"/, '\"')
+    def escape_chars!(string)
+      string.gsub!(/"/, '\"')
+      string.gsub!(/\n/, "\\n")
+      string
     end
 
     def tokenize_without_moving_pos(code)

data/lib/nodes.rb

@@ -323,7 +323,7 @@ class RimlCommandNode  < CallNode
   def initialize(*)
     super
     if arguments.empty? || !arguments.all? { |arg| arg.is_a?(StringNode) }
-      raise Riml::UserArgumentError, "#{name.inspect} error: must pass string (name of file)"
+      raise Riml::UserArgumentError, "#{name.inspect} error: must pass string(s) (name of file(s))"
     end
   end
 
@@ -500,24 +500,38 @@ class DefNode < Struct.new(:bang, :scope_modifier, :name, :parameters, :keyword,
   include FullyNameable
   include Walkable
 
-  attr_accessor :original_name
-
   def initialize(*args)
     super
     # max number of arguments in viml
     if parameters.reject(&DEFAULT_PARAMS).size > 20
       raise Riml::UserArgumentError, "can't have more than 20 parameters for #{full_name}"
     end
+    expressions.nodes.select { |node| DefNode === node}.each do |nested_func|
+      nested_func.nested_within.unshift(self)
+    end
   end
 
   SPLAT = lambda {|arg| arg == Riml::Constants::SPLAT_LITERAL || arg[0] == "*"}
   DEFAULT_PARAMS = lambda {|p| DefaultParamNode === p}
 
+  def original_name
+    @original_name ||= name
+  end
+  attr_writer :original_name
+
   # ["arg1", "arg2"}
   def argument_variable_names
     parameters.reject(&SPLAT)
   end
 
+  def nested_within
+    @nested_within ||= []
+  end
+
+  def nested_function?
+    not nested_within.empty?
+  end
+
   # returns the splat argument or nil
   def splat
     parameters.detect(&SPLAT)
@@ -531,12 +545,16 @@ class DefNode < Struct.new(:bang, :scope_modifier, :name, :parameters, :keyword,
     end
   end
 
+  def defined_on_dictionary?
+    keyword == 'dict'
+  end
+
   def autoload?
     name.include?('#')
   end
 
   def super_node
-    expressions.detect {|n| SuperNode === n}
+    expressions.nodes.detect {|n| SuperNode === n}
   end
 
   def to_scope
@@ -604,7 +622,7 @@ class ScopeNode
     end
     self.for_node_variable_names += other.for_node_variable_names
     self.argument_variable_names -= for_node_variable_names
-    self.function = other.function if function.nil? && other.function
+    self.function = other.function
     self
   end
 end
@@ -797,13 +815,15 @@ class ClassDefinitionNode < Struct.new(:name, :superclass_name, :expressions)
   include Visitable
   include Walkable
 
+  FUNCTIONS = lambda {|expr| DefNode === expr}
+
   def superclass?
     not superclass_name.nil?
   end
 
   def constructor
-    expressions.detect do |n|
-      next(false) unless DefNode === n && (n.name == 'initialize' || n.name.match(/Constructor\Z/))
+    expressions.nodes.detect do |n|
+      next(false) unless DefNode === n && (n.name == 'initialize' || n.name == constructor_name)
       if n.instance_of?(DefMethodNode)
         Riml.warn("class #{name.inspect} has an initialize function declared with 'defm'. Please use 'def'.")
         new_node = n.to_def_node
@@ -815,6 +835,13 @@ class ClassDefinitionNode < Struct.new(:name, :superclass_name, :expressions)
   end
   alias constructor? constructor
 
+  def find_function(scope_modifier, name)
+    expressions.nodes.select(&FUNCTIONS).detect do |def_node|
+      def_node.name == name && def_node.scope_modifier == scope_modifier
+    end
+  end
+  alias has_function? find_function
+
   def constructor_name
     "#{name}Constructor"
   end

data/lib/repl.rb

@@ -69,7 +69,6 @@ module Riml
 
     def compile_unit!
       viml = Riml.compile(current_compilation_unit.join("\n"), parser, compiler).chomp
-      escape_newlines_in_strings!(viml)
       puts viml, "\n"
     rescue => e
       raise unless e.kind_of?(RimlError)
@@ -92,10 +91,6 @@ module Riml
       puts "#{e.class}: #{e}"
     end
 
-    def escape_newlines_in_strings!(viml)
-      viml.gsub!(/("[^"]*?)\n+([^"]?")/, '\1\\n\2')
-    end
-
     def exit_repl
       exit
     end

data/version.rb

@@ -1,4 +1,4 @@
 module Riml
-  # last changed: Apr. 1, 2013
-  VERSION = [0,2,1]
+  # last changed: Apr. 7, 2013
+  VERSION = [0,2,2]
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: riml
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.2.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-04-01 00:00:00.000000000 Z
+date: 2013-04-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: racc