esruby 0.0.0

data/resources/mruby/build/mrbgems/mruby-regexp-pcre/mrblib/string_pcre.rb

@@ -0,0 +1,333 @@
+class String
+  alias_method :old_index, :index
+  def index(pat, offs=0)
+    return old_index(pat, offs) unless pat.is_a? Regexp
+    if offs < 0
+      offs += self.size
+      return nil if offs < 0
+    end
+    m = pat.match(self, offs)
+    m ? m.begin(0) : nil
+  end
+
+  alias_method :old_sub, :sub
+  def sub(*args, &blk)
+    if args[0].class == String
+      return blk ? old_sub(*args) { |x| blk.call(x) } : old_sub(*args)
+    end
+
+    m = args[0].match(self)
+    return self if !m || m.size == 0
+    r = ''
+    r += m.pre_match
+    r += blk ? blk.call(m[0]) : args[1]
+    r.to_sub_replacement!(m)
+    r += m.post_match
+    r
+  end
+
+  alias_method :old_gsub, :gsub
+  def gsub(*args, &blk)
+    if args[0].class.to_s == 'String'
+      return blk ? old_gsub(*args) { |x| blk.call(x) } : old_gsub(*args)
+    end
+
+    r = ""
+    i = 0
+    while i <= length
+      m = args[0].match(self[i..-1])
+      break if !m || m.size == 0
+
+      r += m.pre_match
+      s = blk ? blk.call(m[0]) : args[1]
+      s.to_sub_replacement!(m)
+      r += s
+
+      if i == length
+        break
+      elsif m.end(0) > 0
+        i += m.end(0)
+      else
+        r += self[i]
+        i += 1
+      end
+    end
+    r += self[i..-1]
+    r
+  end
+
+  def =~(a)
+    begin
+      (a.class.to_s == 'String' ? Regexp.new(a.to_s) : a) =~ self
+    rescue
+      false
+    end
+  end
+
+  alias_method :old_split, :split
+  def split(*args, &blk)
+    return [] if self.empty?
+
+    if args[0].nil? or args[0].class.to_s == 'String'
+      return blk ? old_split(*args) { |x| blk.call(x) } : old_split(*args)
+    end
+
+    if args.size < 2
+      limited = false
+      limit = 0
+    else
+      limit = args[1].to_i
+
+      if limit > 0
+        return [self.dup] if limit == 1
+        limited = true
+      else
+        tail_empty = true
+        limited = false
+      end
+    end
+
+    pattern = args[0]
+    result = []
+    # case '//'
+    if pattern.source.empty?
+      index = 0
+      while true
+        break if limited and limit - result.size <= 1
+        break if index + 1 >= self.length
+
+        result << self[index]
+        index += 1
+      end
+      result << self[index..-1]
+    else
+      start = 0
+      last_match = nil
+      last_match_end = 0
+
+      while m = pattern.match(self, start)
+        break if limited and limit - result.size <= 1
+
+        unless m[0].empty? and (m.begin(0) == last_match_end)
+          result << m.pre_match[last_match_end..-1]
+          result.push(*m.captures)
+        end
+        
+        if m[0].empty?
+          start += 1
+        elsif last_match and last_match[0].empty?
+          start = m.end(0) + 1
+        else
+          start = m.end(0)
+        end
+
+        last_match = m
+        last_match_end = m.end(0) || 0
+
+        break if self.length <= start 
+      end
+
+      if last_match
+        result << last_match.post_match
+      elsif result.empty?
+        result << self.dup
+      end
+    end
+
+    # Trim (not specified in the second argument)
+    if !result.empty? and (limit.nil? || limit == 0)
+      while result.last.nil? or result.last.empty?
+        result.pop
+      end
+    end
+
+    result
+  end
+
+  alias_method :old_slice, :slice
+  alias_method :old_square_brancket, :[]
+
+  def [](*args)
+    return old_square_brancket(*args) unless args[0].class == Regexp
+
+    if args.size == 2
+      match = args[0].match(self)
+      if match
+        if args[1] == 0
+          str = match[0]
+        else
+          str = match.captures[args[1] - 1]
+        end
+        return str
+      end
+    end
+
+    match_data = args[0].match(self)
+    if match_data
+      result = match_data.to_s
+      return result
+    end
+  end
+
+  alias_method :slice, :[]
+  alias_method :old_slice!, :slice!
+  def slice!(*args)
+    return old_slice!(*args) unless args[0].class == Regexp
+
+    result = slice(*args)
+    lm = Regexp.last_match
+    self[*args] = '' if result
+    Regexp.last_match = lm
+    result
+  end
+
+  # private
+  def to_sub_replacement!(match)
+    result = ""
+    index = 0
+    while index < self.length
+      current = index
+      while current < self.length && self[current] != '\\'
+        current += 1
+      end
+      result += self[index, (current - index)]
+      break if current == self.length
+
+      if current == self.length - 1
+        result += '\\'
+        break
+      end
+      index = current + 1
+
+      cap = self[index]
+
+      case cap
+      when "&"
+        result += match[0]
+      when "`"
+        result += match.pre_match
+      when "'"
+        result += match.post_match
+      when "+"
+        result += match.captures.compact[-1].to_s
+      when /[0-9]/
+        result += match[cap.to_i].to_s
+      when '\\'
+        result += '\\'
+      else
+        result += '\\' + cap
+      end
+      index += 1
+    end
+    self.replace(result)
+  end
+
+  alias_method :old_scan, :scan
+  def scan(*args, &blk)
+    return old_scan(*args) if args[0].class == String
+
+    s = self
+    ret = []
+    last_match = nil
+    while m = args[0].match(s)
+      break if !m || m.size == 0
+      return ret if m.end(0) == 0
+
+      val = (m.size == 1 ? m[0] : m.captures)
+      s = m.post_match
+
+      if blk
+        blk.call(val)
+      else
+        ret << val
+      end
+    end
+
+    ret
+  end
+
+
+  #
+  # XXX: Need pull-request to http://github.com/mruby/mruby mrbgems/mruby-string-ext
+  #
+  def []=(*args)
+    index = args[0]
+    if args.size != 3
+      val = args[1]
+      count = nil   
+    else
+      count = args[1]
+      val = args[2]
+    end
+
+    case index
+    when Fixnum
+      index += self.size if index < 0
+
+      raise IndexError, "index #{index} out of string" if index < 0 or index > self.size
+      raise IndexError, "unable to find charactor at: #{index}" unless bi = index
+
+      if count
+        count = count.to_i
+        raise IndexError, "count is negative" if count < 0
+
+        total = index + count
+        bs = total - bi
+      else
+        bs = index == size ? 0 : (index + 1) - bi
+      end
+
+      splice bi, bs, val
+    when String
+      raise IndexError, "string not matched" unless start = self.index(index)
+
+      splice start, index.size, val
+    when Range
+      start = index.first.to_i
+      start += self.size if start < 0
+
+      raise RangeError, "#{index.first} is out of range" unless bi = start
+      stop = index.last.to_i
+      stop += self.size if stop < 0
+      stop -= 1 if index.exclude_end?
+
+      if stop < start
+        bs = 0
+      else
+        bs =  stop + 1 - bi
+      end
+
+      splice bi, bs, val
+    when Regexp
+      count = count || 0
+
+      if match = index.match(self)
+        ms = match.size
+      else
+        raise IndexError, "regexp does not match"
+      end
+
+      count += ms if count < 0 and -count < ms
+      raise IndexError, "index #{count} out of match bounds" unless count < ms and count >= 0
+
+      bi = match.begin(count)
+      bs = match.end(count) - bi
+
+      splice bi, bs, val
+    else
+      index = index.to_i
+
+      if count
+        return self[index, count] = val
+      else
+        return self[index] = val
+      end
+    end
+
+    return val
+  end
+
+  def splice(start , count, val)
+    self.replace(self[0...start] + val + self[(start + count)..-1].to_s)
+  end
+end

data/resources/mruby/build/mrbgems/mruby-regexp-pcre/pcre/132html

@@ -0,0 +1,313 @@
+#! /usr/bin/perl -w
+
+# Script to turn PCRE man pages into HTML
+
+
+# Subroutine to handle font changes and other escapes
+
+sub do_line {
+my($s) = $_[0];
+
+$s =~ s/</&#60;/g;                   # Deal with < and >
+$s =~ s/>/&#62;/g;
+$s =~ s"\\fI(.*?)\\f[RP]"<i>$1</i>"g;
+$s =~ s"\\fB(.*?)\\f[RP]"<b>$1</b>"g;
+$s =~ s"\\e"\\"g;
+$s =~ s/(?<=Copyright )\(c\)/&copy;/g;
+$s;
+}
+
+# Subroutine to ensure not in a paragraph
+
+sub end_para {
+if ($inpara)
+  {
+  print TEMP "</PRE>\n" if ($inpre);
+  print TEMP "</P>\n";
+  }
+$inpara = $inpre = 0;
+$wrotetext = 0;
+}
+
+# Subroutine to start a new paragraph
+
+sub new_para {
+&end_para();
+print TEMP "<P>\n";
+$inpara = 1;
+}
+
+
+# Main program
+
+$innf = 0;
+$inpara = 0;
+$inpre = 0;
+$wrotetext = 0;
+$toc = 0;
+$ref = 1;
+
+while ($#ARGV >= 0 && $ARGV[0] =~ /^-/)
+  {
+  $toc = 1 if $ARGV[0] eq "-toc";
+  shift;
+  }
+
+# Initial output to STDOUT
+
+print <<End ;
+<html>
+<head>
+<title>$ARGV[0] specification</title>
+</head>
+<body bgcolor="#FFFFFF" text="#00005A" link="#0066FF" alink="#3399FF" vlink="#2222BB">
+<h1>$ARGV[0] man page</h1>
+<p>
+Return to the <a href="index.html">PCRE index page</a>.
+</p>
+<p>
+This page is part of the PCRE HTML documentation. It was generated automatically
+from the original man page. If there is any nonsense in it, please consult the
+man page, in case the conversion went wrong.
+<br>
+End
+
+print "<ul>\n" if ($toc);
+
+open(TEMP, ">/tmp/$$") || die "Can't open /tmp/$$ for output\n";
+
+while (<STDIN>)
+  {
+  # Handle lines beginning with a dot
+
+  if (/^\./)
+    {
+    # Some of the PCRE man pages used to contain instances of .br. However,
+    # they should have all been removed because they cause trouble in some
+    # (other) automated systems that translate man pages to HTML. Complain if
+    # we find .br or .in (another macro that is deprecated).
+
+    if (/^\.br/ || /^\.in/)
+      {
+      print STDERR "\n*** Deprecated macro encountered - rewrite needed\n";
+      print STDERR "*** $_\n";
+      die "*** Processing abandoned\n";
+      }
+
+    # Instead of .br, relevent "literal" sections are enclosed in .nf/.fi.
+
+    elsif (/^\.nf/)
+      {
+      $innf = 1;
+      }
+
+    elsif (/^\.fi/)
+      {
+      $innf = 0;
+      }
+
+    # Handling .sp is subtle. If it is inside a literal section, do nothing if
+    # the next line is a non literal text line; similarly, if not inside a
+    # literal section, do nothing if a literal follows. The point being that
+    # the <pre> and </pre> that delimit literal sections will do the spacing.
+    # Always skip if no previous output.
+
+    elsif (/^\.sp/)
+      {
+      if ($wrotetext)
+        {
+        $_ = <STDIN>;
+        if ($inpre)
+          {
+          print TEMP "\n" if (/^[\s.]/);
+          }
+        else
+          {
+          print TEMP "<br>\n<br>\n" if (!/^[\s.]/);
+          }
+        redo;    # Now process the lookahead line we just read
+        }
+      }
+    elsif (/^\.TP/ || /^\.PP/ || /^\.P/)
+      {
+      &new_para();
+      }
+    elsif (/^\.SH\s*("?)(.*)\1/)
+      {
+      # Ignore the NAME section
+      if ($2 =~ /^NAME\b/)
+        {
+        <STDIN>;
+        next;
+        }
+
+      &end_para();
+      my($title) = &do_line($2);
+      if ($toc)
+        {
+        printf("<li><a name=\"TOC%d\" href=\"#SEC%d\">$title</a>\n",
+          $ref, $ref);
+        printf TEMP ("<br><a name=\"SEC%d\" href=\"#TOC1\">$title</a><br>\n",
+          $ref, $ref);
+        $ref++;
+        }
+      else
+        {
+        print TEMP "<br><b>\n$title\n</b><br>\n";
+        }
+      }
+    elsif (/^\.SS\s*("?)(.*)\1/)
+      {
+      &end_para();
+      my($title) = &do_line($2);
+      print TEMP "<br><b>\n$title\n</b><br>\n";
+      }
+    elsif (/^\.B\s*(.*)/)
+      {
+      &new_para() if (!$inpara);
+      $_ = &do_line($1);
+      s/"(.*?)"/$1/g;
+      print TEMP "<b>$_</b>\n";
+      $wrotetext = 1;
+      }
+    elsif (/^\.I\s*(.*)/)
+      {
+      &new_para() if (!$inpara);
+      $_ = &do_line($1);
+      s/"(.*?)"/$1/g;
+      print TEMP "<i>$_</i>\n";
+      $wrotetext = 1;
+      }
+
+    # A comment that starts "HREF" takes the next line as a name that
+    # is turned into a hyperlink, using the text given, which might be
+    # in a special font. If it ends in () or (digits) or punctuation, they
+    # aren't part of the link.
+
+    elsif (/^\.\\"\s*HREF/)
+      {
+      $_=<STDIN>;
+      chomp;
+      $_ = &do_line($_);
+      $_ =~ s/\s+$//;
+      $_ =~ /^(?:<.>)?([^<(]+)(?:\(\))?(?:<\/.>)?(?:\(\d+\))?[.,;:]?$/;
+      print TEMP "<a href=\"$1.html\">$_</a>\n";
+      }
+
+    # A comment that starts "HTML" inserts literal HTML
+
+    elsif (/^\.\\"\s*HTML\s*(.*)/)
+      {
+      print TEMP $1;
+      }
+
+    # A comment that starts < inserts that HTML at the end of the
+    # *next* input line - so as not to get a newline between them.
+
+    elsif (/^\.\\"\s*(<.*>)/)
+      {
+      my($markup) = $1;
+      $_=<STDIN>;
+      chomp;
+      $_ = &do_line($_);
+      $_ =~ s/\s+$//;
+      print TEMP "$_$markup\n";
+      }
+
+    # A comment that starts JOIN joins the next two lines together, with one
+    # space between them. Then that line is processed. This is used in some
+    # displays where two lines are needed for the "man" version. JOINSH works
+    # the same, except that it assumes this is a shell command, so removes
+    # continuation backslashes.
+
+    elsif (/^\.\\"\s*JOIN(SH)?/)
+      {
+      my($one,$two);
+      $one = <STDIN>;
+      $two = <STDIN>;
+      $one =~ s/\s*\\e\s*$// if (defined($1));
+      chomp($one);
+      $two =~ s/^\s+//;
+      $_ = "$one $two";
+      redo;            # Process the joined lines
+      }
+
+    # .EX/.EE are used in the pcredemo page to bracket the entire program,
+    # which is unmodified except for turning backslash into "\e".
+
+    elsif (/^\.EX\s*$/)
+      {
+      print TEMP "<PRE>\n";
+      while (<STDIN>)
+        {
+        last if /^\.EE\s*$/;
+        s/\\e/\\/g;
+        s/&/&amp;/g;
+        s/</&lt;/g;
+        s/>/&gt;/g;
+        print TEMP;
+        }
+      }
+
+    # Ignore anything not recognized
+
+    next;
+    }
+
+  # Line does not begin with a dot. Replace blank lines with new paragraphs
+
+  if (/^\s*$/)
+    {
+    &end_para() if ($wrotetext);
+    next;
+    }
+
+  # Convert fonts changes and output an ordinary line. Ensure that indented
+  # lines are marked as literal.
+
+  $_ = &do_line($_);
+  &new_para() if (!$inpara);
+
+  if (/^\s/)
+    {
+    if (!$inpre)
+      {
+      print TEMP "<pre>\n";
+      $inpre = 1;
+      }
+    }
+  elsif ($inpre)
+    {
+    print TEMP "</pre>\n";
+    $inpre = 0;
+    }
+
+  # Add <br> to the end of a non-literal line if we are within .nf/.fi
+
+  $_ .= "<br>\n" if (!$inpre && $innf);
+
+  print TEMP;
+  $wrotetext = 1;
+  }
+
+# The TOC, if present, will have been written - terminate it
+
+print "</ul>\n" if ($toc);
+
+# Copy the remainder to the standard output
+
+close(TEMP);
+open(TEMP, "/tmp/$$") || die "Can't open /tmp/$$ for input\n";
+
+print while (<TEMP>);
+
+print <<End ;
+<p>
+Return to the <a href="index.html">PCRE index page</a>.
+</p>
+End
+
+close(TEMP);
+unlink("/tmp/$$");
+
+# End