pry-doc 0.1.5pre1

data/README.md

@@ -0,0 +1,48 @@
+pry-doc
+===========
+
+(C) John Mair (banisterfiend) 2011
+
+_Provides YARD and extended documentation support for Pry_
+
+* Install the [gem](https://rubygems.org/gems/pry-doc): `gem install pry-doc`
+* Read the [documentation](http://rdoc.info/github/banister/pry-doc/master/file/README.md)
+* See the [source code](http://github.com/banister/pry-doc)
+
+Example: Provide access to Ruby core documentation and source code from within Pry
+--------
+
+  show-doc puts
+  show-method puts
+
+Contact
+-------
+
+Problems or questions contact me at [github](http://github.com/banister)
+
+
+License
+-------
+
+(The MIT License) 
+
+Copyright (c) 2011 John Mair (banisterfiend)
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,65 @@
+dlext = Config::CONFIG['DLEXT']
+direc = File.dirname(__FILE__)
+
+PROJECT_NAME = "pry-doc"
+
+require 'rake/clean'
+require 'rake/gempackagetask'
+require "#{direc}/lib/#{PROJECT_NAME}/version"
+
+CLOBBER.include("**/*.#{dlext}", "**/*~", "**/*#*", "**/*.log", "**/*.o")
+CLEAN.include("ext/**/*.#{dlext}", "ext/**/*.log", "ext/**/*.o",
+              "ext/**/*~", "ext/**/*#*", "ext/**/*.obj", "**/*#*", "**/*#*.*",
+              "ext/**/*.def", "ext/**/*.pdb", "**/*_flymake*.*", "**/*_flymake")
+
+def apply_spec_defaults(s)
+  s.name = PROJECT_NAME
+  s.summary = "Provides YARD and extended documentation support for Pry"
+  s.version = PryDoc::VERSION
+  s.date = Time.now.strftime '%Y-%m-%d'
+  s.author = "John Mair (banisterfiend)"
+  s.email = 'jrmair@gmail.com'
+  s.description = s.summary
+  s.add_dependency("yard",">=0.6.4")
+  s.add_dependency("pry",">=0.6.9")
+  s.add_development_dependency("bacon",">=1.1.0")
+  s.require_path = 'lib'
+  s.homepage = "http://banisterfiend.wordpress.com"
+  s.has_rdoc = 'yard'
+  s.files = Dir["ext/**/extconf.rb", "ext/**/*.h", "ext/**/*.c", "lib/**/*",
+                     "test/*.rb", "HISTORY", "README.md", "Rakefile"]
+end
+
+desc "run tests"
+task :test do
+  sh "bacon -k #{direc}/test/test.rb"
+end
+
+namespace :ruby do
+  spec = Gem::Specification.new do |s|
+    apply_spec_defaults(s)        
+    s.platform = Gem::Platform::RUBY
+  end
+  
+  Rake::GemPackageTask.new(spec) do |pkg|
+    pkg.need_zip = false
+    pkg.need_tar = false
+  end
+end
+
+desc "build all platform gems at once"
+task :gems => [:clean, :rmgems, "ruby:gem"]
+
+desc "remove all platform gems"
+task :rmgems => ["ruby:clobber_package"]
+
+desc "build and push latest gems"
+task :pushgems => :gems do
+  chdir("#{direc}/pkg") do
+    Dir["*.gem"].each do |gemfile|
+      sh "gem push #{gemfile}"
+    end
+  end
+end
+              
+

data/lib/pry-doc.rb

@@ -0,0 +1,87 @@
+# pry-doc.rb
+# (C) John Mair (banisterfiend); MIT license
+
+direc = File.dirname(__FILE__)
+
+require "#{direc}/pry-doc/version"
+require "yard"
+
+if RUBY_VERSION =~ /1.9/
+  YARD::Registry.load_yardoc("#{File.dirname(__FILE__)}/pry-doc/core_docs_19")
+else
+  YARD::Registry.load_yardoc("#{File.dirname(__FILE__)}/pry-doc/core_docs_18")
+end
+
+class Pry
+  @has_pry_doc = true
+  
+  module MethodInfo
+    @doc_cache = {}
+    class << self; attr_reader :doc_cache; end
+
+    # Convert a method object into the `Class#method` string notation.
+    # @param [Method, UnboundMethod] meth
+    # @return [String] The method in string receiver notation.
+    def self.receiver_notation_for(meth)
+      if meth.owner.name
+        "#{meth.owner.name}##{meth.name}"
+      else 
+        "#{meth.owner.to_s[/#<.+?:(.+?)>/, 1]}.#{meth.name}"
+      end
+    end
+
+    # Check whether the file containing the method is already cached.
+    # @param [Method, UnboundMethod] meth The method object.
+    # @return [Boolean] Whether the method is cached.
+    def self.cached?(meth)
+      !!registry_lookup(meth)
+    end
+
+    def self.registry_lookup(meth)
+      obj = YARD::Registry.at(receiver_notation_for(meth))
+
+      # YARD thinks that some methods are on Object when
+      # they're actually on Kernel; so try again on Object if Kernel fails.
+      if obj.nil? && meth.owner == Kernel 
+        obj = YARD::Registry.at("Object##{meth.name}")
+      end
+      obj
+    end
+
+    # Retrieve the YARD object that contains the method data.
+    # @param [Method, UnboundMethod] meth The method object.
+    # @return [YARD::CodeObjects::MethodObject] The YARD data for the method.
+    def self.info_for(meth)
+      cache(meth)
+      registry_lookup(meth)
+    end
+
+    # Determine whether a method is an eval method.
+    # @return [Boolean] Whether the method is an eval method.
+    def self.is_eval_method?(meth)
+      file, _ = meth.source_location
+      if file =~ /(\(.*\))|<.*>/
+        true
+      else
+        false
+      end
+    end
+
+    # Cache the file that holds the method or return immediately if file is
+    # already cached. Return if the method cannot be cached -
+    # i.e is a C method.
+    # @param [Method, UnboundMethod] meth The method object.
+    def self.cache(meth)
+      file, _ = meth.source_location
+      return if !file
+      return if is_eval_method?(meth)
+      return if cached?(meth)
+
+      log.enter_level(Logger::FATAL) do
+        YARD.parse(file)
+      end
+    end
+  end
+end  
+
+

data/lib/pry-doc/core_docs_18/checksums

@@ -0,0 +1,40 @@
+range.c f56591088e2ec8b25ee20ba71e5d4f7bd6cebd80
+lex.c 2fb09da4fd0e597e908a758b2cb8861791d77fe0
+st.c de730738519f9d314642d643605daf0032cde5e8
+sprintf.c 38e24ae2792f3f0c788c12930f24df8967386584
+struct.c aeeb1c59b8feced0cb0ab5c8f2bb0f7db949294c
+util.c bf0f10904a55eb132e1dbff76abbfaa5c0b9645a
+re.c 0c7fb7c27754745b224b5d68e6f9360a2c27c392
+version.c 09c81d814237aa4c9d91b315336bf2998506b84b
+dmydln.c deae68321fe218cbece2c778eeee2cb1ed07f9dc
+object.c 63320c4caf35debfcea26701f38e552f0783a591
+random.c 49191bb7edda1923b7964c87356c65d7ce539929
+class.c 254e814ebb75cf1104927821200b014557755c27
+enum.c b25337156929ead15069399fb3f877d77dd84d0f
+compar.c 3cc33a5da41a461486f6c94d1a13c3d6f6af2491
+array.c 306a01939123a5e84b4967a70a857a64dfe55dd9
+numeric.c c3ab075b4360c127ae1d6f0a4c77195ca63ffaf5
+inits.c 9ca3e88702cfbaff13952b422a357c5b5d0a2c9d
+enumerator.c 8ebf946bb338cb5337ea05c2a0abff241243ad58
+main.c ca4ccfe720cc9b09e6bdc4adda8822cd28e97ef4
+pack.c 46f347e026df35603757f1ee88f9e5600089107a
+process.c 1f405125e81953e5f5ccfcadc0fbf23653849563
+string.c 7e436a583b230a560609f136eaa9a90eb8393323
+dmyext.c 0a5f623323d12032746f4b954fd362cce8139d4e
+regex.c 5ce25e880652ba773da3dcf4fd3773ad93536c5d
+time.c 52012e930b3683b70745c9ac46e765449fc59e02
+dir.c e81a961fc1ee266aa151270f54024e1e7a2bb5d4
+signal.c d82b5d5225baaa152d513090715303cf3a471efd
+error.c 027ab87587753aac879a87d14aed68ac469609ae
+hash.c 90a48add85816a628c4b7e84f34f181d3772e781
+dln.c 488c3f8d5989c8c0640dd0fb4dc14dbe29dfd292
+io.c 2fc691c76efad88f77da987e8720f54477fba70e
+variable.c feba3d4dbfb850e55e9c85d548be0eef01732b05
+file.c 5f8f03c9d63600dba17d07d5a7ed8ddf464e2049
+ruby.c d7be35d486d8b283761260ddc340d831fd6fb302
+prec.c 405d264141d7ee55ff51dbc17d4838d65066ce83
+bignum.c 34dbe3ba01a899937f92a441cced0e22a6036aa8
+math.c 958af177feac771f4f58efd124e5ea7b18da11c7
+marshal.c 0be9f8ddc3f3e8f7d6369c0ee6b557a9c354a701
+eval.c 58f7f1e768c09122e491cc122468a3cf5aa95669
+gc.c 7e688ca3d4dd056559de10ba5d38f18759889f2d

data/lib/pry-doc/core_docs_18/objects/Array/pack_i.dat

@@ -0,0 +1,899 @@
+o:$YARD::CodeObjects::MethodObject:
+@name:	pack:@docstringIC:YARD::Docstring"Packs the contents of <i>arr</i> into a binary sequence according to
+the directives in <i>aTemplateString</i> (see the table below)
+Directives ``A,'' ``a,'' and ``Z'' may be followed by a count,
+which gives the width of the resulting field. The remaining
+directives also may take a count, indicating the number of array
+elements to convert. If the count is an asterisk
+(``<code>*</code>''), all remaining array elements will be
+converted. Any of the directives ``<code>sSiIlL</code>'' may be
+followed by an underscore (``<code>_</code>'') to use the underlying
+platform's native size for the specified type; otherwise, they use a
+platform-independent size. Spaces are ignored in the template
+string. See also <code>String#unpack</code>.
+
+   a = [ "a", "b", "c" ]
+   n = [ 65, 66, 67 ]
+   a.pack("A3A3A3")   #=> "a  b  c  "
+   a.pack("a3a3a3")   #=> "a\000\000b\000\000c\000\000"
+   n.pack("ccc")      #=> "ABC"
+
+Directives for +pack+.
+
+ Integer   | Array   |
+ Directive | Element | Meaning
+ ------------------------------------------------------------------------
+    C      | Integer | 8-bit unsigned integer (unsigned char)
+    S      | Integer | 16-bit unsigned integer, native endian (uint16_t)
+    L      | Integer | 32-bit unsigned integer, native endian (uint32_t)
+    Q      | Integer | 64-bit unsigned integer, native endian (uint64_t)
+           |         |
+    c      | Integer | 8-bit signed integer (char)
+    s      | Integer | 16-bit signed integer, native endian (int16_t)
+    l      | Integer | 32-bit signed integer, native endian (int32_t)
+    q      | Integer | 64-bit signed integer, native endian (int64_t)
+           |         |
+    S_     | Integer | unsigned short, native endian
+    I, I_  | Integer | unsigned int, native endian
+    L_     | Integer | unsigned long, native endian
+           |         |
+    s_     | Integer | signed short, native endian
+    i, i_  | Integer | signed int, native endian
+    l_     | Integer | signed long, native endian
+           |         |
+    n      | Integer | 16-bit unsigned integer, network (big-endian) byte order
+    N      | Integer | 32-bit unsigned integer, network (big-endian) byte order
+    v      | Integer | 16-bit unsigned integer, VAX (little-endian) byte order
+    V      | Integer | 32-bit unsigned integer, VAX (little-endian) byte order
+           |         |
+    U      | Integer | UTF-8 character
+    w      | Integer | BER-compressed integer
+
+ Float     |         |
+ Directive |         | Meaning
+ ------------------------------------------------------------------------
+    D, d   | Float   | double-precision float, native format
+    F, f   | Float   | single-precision float, native format
+    E      | Float   | double-precision float, little-endian byte order
+    e      | Float   | single-precision float, little-endian byte order
+    G      | Float   | double-precision float, network (big-endian) byte order
+    g      | Float   | single-precision float, network (big-endian) byte order
+
+ String    |         |
+ Directive |         | Meaning
+ ------------------------------------------------------------------------
+    A      | String  | arbitrary binary string (space padded, count is width)
+    a      | String  | arbitrary binary string (null padded, count is width)
+    Z      | String  | same as ``a'', except that null is added with *
+    B      | String  | bit string (MSB first)
+    b      | String  | bit string (LSB first)
+    H      | String  | hex string (high nibble first)
+    h      | String  | hex string (low nibble first)
+    u      | String  | UU-encoded string
+    M      | String  | quoted printable, MIME encoding (see RFC2045)
+    m      | String  | base64 encoded string (see RFC 2045, count is width)
+    P      | String  | pointer to a structure (fixed-length string)
+    p      | String  | pointer to a null-terminated string
+
+ Misc.     |         |
+ Directive |         | Meaning
+ ------------------------------------------------------------------------
+    @      | ---     | moves to absolute position
+    X      | ---     | back up a byte
+    x      | ---     | null byte
+:@objectu:YARD::StubProxyArray#pack:
+Packs the contents of <i>arr</i> into a binary sequence according to
+the directives in <i>aTemplateString</i> (see the table below)
+Directives ``A,'' ``a,'' and ``Z'' may be followed by a count,
+which gives the width of the resulting field. The remaining
+directives also may take a count, indicating the number of array
+elements to convert. If the count is an asterisk
+(``<code>*</code>''), all remaining array elements will be
+converted. Any of the directives ``<code>sSiIlL</code>'' may be
+followed by an underscore (``<code>_</code>'') to use the underlying
+platform's native size for the specified type; otherwise, they use a
+platform-independent size. Spaces are ignored in the template
+string. See also <code>String#unpack</code>.
+
+   a = [ "a", "b", "c" ]
+   n = [ 65, 66, 67 ]
+   a.pack("A3A3A3")   #=> "a  b  c  "
+   a.pack("a3a3a3")   #=> "a\000\000b\000\000c\000\000"
+   n.pack("ccc")      #=> "ABC"
+
+Directives for +pack+.
+
+ Integer   | Array   |
+ Directive | Element | Meaning
+ ------------------------------------------------------------------------
+    C      | Integer | 8-bit unsigned integer (unsigned char)
+    S      | Integer | 16-bit unsigned integer, native endian (uint16_t)
+    L      | Integer | 32-bit unsigned integer, native endian (uint32_t)
+    Q      | Integer | 64-bit unsigned integer, native endian (uint64_t)
+           |         |
+    c      | Integer | 8-bit signed integer (char)
+    s      | Integer | 16-bit signed integer, native endian (int16_t)
+    l      | Integer | 32-bit signed integer, native endian (int32_t)
+    q      | Integer | 64-bit signed integer, native endian (int64_t)
+           |         |
+    S_     | Integer | unsigned short, native endian
+    I, I_  | Integer | unsigned int, native endian
+    L_     | Integer | unsigned long, native endian
+           |         |
+    s_     | Integer | signed short, native endian
+    i, i_  | Integer | signed int, native endian
+    l_     | Integer | signed long, native endian
+           |         |
+    n      | Integer | 16-bit unsigned integer, network (big-endian) byte order
+    N      | Integer | 32-bit unsigned integer, network (big-endian) byte order
+    v      | Integer | 16-bit unsigned integer, VAX (little-endian) byte order
+    V      | Integer | 32-bit unsigned integer, VAX (little-endian) byte order
+           |         |
+    U      | Integer | UTF-8 character
+    w      | Integer | BER-compressed integer
+
+ Float     |         |
+ Directive |         | Meaning
+ ------------------------------------------------------------------------
+    D, d   | Float   | double-precision float, native format
+    F, f   | Float   | single-precision float, native format
+    E      | Float   | double-precision float, little-endian byte order
+    e      | Float   | single-precision float, little-endian byte order
+    G      | Float   | double-precision float, network (big-endian) byte order
+    g      | Float   | single-precision float, network (big-endian) byte order
+
+ String    |         |
+ Directive |         | Meaning
+ ------------------------------------------------------------------------
+    A      | String  | arbitrary binary string (space padded, count is width)
+    a      | String  | arbitrary binary string (null padded, count is width)
+    Z      | String  | same as ``a'', except that null is added with *
+    B      | String  | bit string (MSB first)
+    b      | String  | bit string (LSB first)
+    H      | String  | hex string (high nibble first)
+    h      | String  | hex string (low nibble first)
+    u      | String  | UU-encoded string
+    M      | String  | quoted printable, MIME encoding (see RFC2045)
+    m      | String  | base64 encoded string (see RFC 2045, count is width)
+    P      | String  | pointer to a structure (fixed-length string)
+    p      | String  | pointer to a null-terminated string
+
+ Misc.     |         |
+ Directive |         | Meaning
+ ------------------------------------------------------------------------
+    @      | ---     | moves to absolute position
+    X      | ---     | back up a byte
+    x      | ---     | null byte
+
+:@ref_tags[:
+@tags[:@current_file_has_commentsF:@scope:
+Array:
+@path"Array#pack;[:@visibility:public:@source"OX/*
+ *  call-seq:
+ *     arr.pack ( aTemplateString ) -> aBinaryString
+ *  
+ *  Packs the contents of <i>arr</i> into a binary sequence according to
+ *  the directives in <i>aTemplateString</i> (see the table below)
+ *  Directives ``A,'' ``a,'' and ``Z'' may be followed by a count,
+ *  which gives the width of the resulting field. The remaining
+ *  directives also may take a count, indicating the number of array
+ *  elements to convert. If the count is an asterisk
+ *  (``<code>*</code>''), all remaining array elements will be
+ *  converted. Any of the directives ``<code>sSiIlL</code>'' may be
+ *  followed by an underscore (``<code>_</code>'') to use the underlying
+ *  platform's native size for the specified type; otherwise, they use a
+ *  platform-independent size. Spaces are ignored in the template
+ *  string. See also <code>String#unpack</code>.
+ *     
+ *     a = [ "a", "b", "c" ]
+ *     n = [ 65, 66, 67 ]
+ *     a.pack("A3A3A3")   #=> "a  b  c  "
+ *     a.pack("a3a3a3")   #=> "a\000\000b\000\000c\000\000"
+ *     n.pack("ccc")      #=> "ABC"
+ *     
+ *  Directives for +pack+.
+ *
+ *   Integer   | Array   |
+ *   Directive | Element | Meaning
+ *   ------------------------------------------------------------------------
+ *      C      | Integer | 8-bit unsigned integer (unsigned char)
+ *      S      | Integer | 16-bit unsigned integer, native endian (uint16_t)
+ *      L      | Integer | 32-bit unsigned integer, native endian (uint32_t)
+ *      Q      | Integer | 64-bit unsigned integer, native endian (uint64_t)
+ *             |         |
+ *      c      | Integer | 8-bit signed integer (char)
+ *      s      | Integer | 16-bit signed integer, native endian (int16_t)
+ *      l      | Integer | 32-bit signed integer, native endian (int32_t)
+ *      q      | Integer | 64-bit signed integer, native endian (int64_t)
+ *             |         | 
+ *      S_     | Integer | unsigned short, native endian
+ *      I, I_  | Integer | unsigned int, native endian
+ *      L_     | Integer | unsigned long, native endian
+ *             |         |
+ *      s_     | Integer | signed short, native endian
+ *      i, i_  | Integer | signed int, native endian
+ *      l_     | Integer | signed long, native endian
+ *             |         |
+ *      n      | Integer | 16-bit unsigned integer, network (big-endian) byte order
+ *      N      | Integer | 32-bit unsigned integer, network (big-endian) byte order
+ *      v      | Integer | 16-bit unsigned integer, VAX (little-endian) byte order
+ *      V      | Integer | 32-bit unsigned integer, VAX (little-endian) byte order
+ *             |         |
+ *      U      | Integer | UTF-8 character
+ *      w      | Integer | BER-compressed integer
+ *                        
+ *   Float     |         |
+ *   Directive |         | Meaning
+ *   ------------------------------------------------------------------------
+ *      D, d   | Float   | double-precision float, native format
+ *      F, f   | Float   | single-precision float, native format
+ *      E      | Float   | double-precision float, little-endian byte order
+ *      e      | Float   | single-precision float, little-endian byte order
+ *      G      | Float   | double-precision float, network (big-endian) byte order
+ *      g      | Float   | single-precision float, network (big-endian) byte order
+ *                        
+ *   String    |         |
+ *   Directive |         | Meaning
+ *   ------------------------------------------------------------------------
+ *      A      | String  | arbitrary binary string (space padded, count is width)
+ *      a      | String  | arbitrary binary string (null padded, count is width)
+ *      Z      | String  | same as ``a'', except that null is added with *
+ *      B      | String  | bit string (MSB first)
+ *      b      | String  | bit string (LSB first)
+ *      H      | String  | hex string (high nibble first)
+ *      h      | String  | hex string (low nibble first)
+ *      u      | String  | UU-encoded string
+ *      M      | String  | quoted printable, MIME encoding (see RFC2045)
+ *      m      | String  | base64 encoded string (see RFC 2045, count is width)
+ *      P      | String  | pointer to a structure (fixed-length string)
+ *      p      | String  | pointer to a null-terminated string
+ *                        
+ *   Misc.     |         |
+ *   Directive |         | Meaning
+ *   ------------------------------------------------------------------------
+ *      @      | ---     | moves to absolute position
+ *      X      | ---     | back up a byte
+ *      x      | ---     | null byte
+ */
+
+static VALUE
+pack_pack(ary, fmt)
+    VALUE ary, fmt;
+{
+    static const char nul10[] = "\0\0\0\0\0\0\0\0\0\0";
+    static const char spc10[] = "          ";
+    char *p, *pend;
+    VALUE res, from, associates = 0;
+    char type;
+    long items, len, idx, plen;
+    const char *ptr;
+#ifdef NATINT_PACK
+    int natint;     /* native integer */
+#endif
+    int signed_p, integer_size, bigendian_p;
+
+    StringValue(fmt);
+    p = RSTRING(fmt)->ptr;
+    pend = p + RSTRING(fmt)->len;
+    res = rb_str_buf_new(0);
+
+    items = RARRAY(ary)->len;
+    idx = 0;
+
+#define TOO_FEW (rb_raise(rb_eArgError, toofew), 0)
+#define THISFROM (items > 0 ? RARRAY(ary)->ptr[idx] : TOO_FEW)
+#define NEXTFROM (items-- > 0 ? RARRAY(ary)->ptr[idx++] : TOO_FEW)
+
+    while (p < pend) {
+    if (RSTRING(fmt)->ptr + RSTRING(fmt)->len != pend) {
+        rb_raise(rb_eRuntimeError, "format string modified");
+    }
+    type = *p++;       /* get data type */
+#ifdef NATINT_PACK
+    natint = 0;
+#endif
+
+    if (ISSPACE(type)) continue;
+    if (type == '#') {
+        while ((p < pend) && (*p != '\n')) {
+        p++;
+        }
+        continue;
+    }
+        if (*p == '_' || *p == '!') {
+        const char *natstr = "sSiIlL";
+
+        if (strchr(natstr, type)) {
+#ifdef NATINT_PACK
+        natint = 1;
+#endif
+        p++;
+        }
+        else {
+        rb_raise(rb_eArgError, "'%c' allowed only after types %s", *p, natstr);
+        }
+    }
+    if (*p == '*') {   /* set data length */
+        len = strchr("@Xxu", type) ? 0
+                : strchr("PMm", type) ? 1
+                : items;
+        p++;
+    }
+    else if (ISDIGIT(*p)) {
+        len = strtoul(p, (char**)&p, 10);
+    }
+    else {
+        len = 1;
+    }
+
+    switch (type) {
+      case 'A': case 'a': case 'Z':
+      case 'B': case 'b':
+      case 'H': case 'h':
+        from = NEXTFROM;
+        if (NIL_P(from)) {
+        ptr = "";
+        plen = 0;
+        }
+        else {
+        StringValue(from);
+        ptr = RSTRING(from)->ptr;
+        plen = RSTRING(from)->len;
+        OBJ_INFECT(res, from);
+        }
+
+        if (p[-1] == '*')
+        len = plen;
+
+        switch (type) {
+          case 'a':        /* arbitrary binary string (null padded)  */
+          case 'A':        /* ASCII string (space padded) */
+          case 'Z':        /* null terminated ASCII string  */
+        if (plen >= len) {
+            rb_str_buf_cat(res, ptr, len);
+            if (p[-1] == '*' && type == 'Z')
+            rb_str_buf_cat(res, nul10, 1);
+        }
+        else {
+            rb_str_buf_cat(res, ptr, plen);
+            len -= plen;
+            while (len >= 10) {
+            rb_str_buf_cat(res, (type == 'A')?spc10:nul10, 10);
+            len -= 10;
+            }
+            rb_str_buf_cat(res, (type == 'A')?spc10:nul10, len);
+        }
+        break;
+
+          case 'b':        /* bit string (ascending) */
+        {
+            int byte = 0;
+            long i, j = 0;
+
+            if (len > plen) {
+            j = (len - plen + 1)/2;
+            len = plen;
+            }
+            for (i=0; i++ < len; ptr++) {
+            if (*ptr & 1)
+                byte |= 128;
+            if (i & 7)
+                byte >>= 1;
+            else {
+                char c = byte & 0xff;
+                rb_str_buf_cat(res, &c, 1);
+                byte = 0;
+            }
+            }
+            if (len & 7) {
+            char c;
+            byte >>= 7 - (len & 7);
+            c = byte & 0xff;
+            rb_str_buf_cat(res, &c, 1);
+            }
+            len = j;
+            goto grow;
+        }
+        break;
+
+          case 'B':        /* bit string (descending) */
+        {
+            int byte = 0;
+            long i, j = 0;
+
+            if (len > plen) {
+            j = (len - plen + 1)/2;
+            len = plen;
+            }
+            for (i=0; i++ < len; ptr++) {
+            byte |= *ptr & 1;
+            if (i & 7)
+                byte <<= 1;
+            else {
+                char c = byte & 0xff;
+                rb_str_buf_cat(res, &c, 1);
+                byte = 0;
+            }
+            }
+            if (len & 7) {
+            char c;
+            byte <<= 7 - (len & 7);
+            c = byte & 0xff;
+            rb_str_buf_cat(res, &c, 1);
+            }
+            len = j;
+            goto grow;
+        }
+        break;
+
+          case 'h':        /* hex string (low nibble first) */
+        {
+            int byte = 0;
+            long i, j = 0;
+
+            if (len > plen) {
+            j = (len + 1) / 2 - (plen + 1) / 2;
+            len = plen;
+            }
+            for (i=0; i++ < len; ptr++) {
+            if (ISALPHA(*ptr))
+                byte |= (((*ptr & 15) + 9) & 15) << 4;
+            else
+                byte |= (*ptr & 15) << 4;
+            if (i & 1)
+                byte >>= 4;
+            else {
+                char c = byte & 0xff;
+                rb_str_buf_cat(res, &c, 1);
+                byte = 0;
+            }
+            }
+            if (len & 1) {
+            char c = byte & 0xff;
+            rb_str_buf_cat(res, &c, 1);
+            }
+            len = j;
+            goto grow;
+        }
+        break;
+
+          case 'H':        /* hex string (high nibble first) */
+        {
+            int byte = 0;
+            long i, j = 0;
+
+            if (len > plen) {
+            j = (len + 1) / 2 - (plen + 1) / 2;
+            len = plen;
+            }
+            for (i=0; i++ < len; ptr++) {
+            if (ISALPHA(*ptr))
+                byte |= ((*ptr & 15) + 9) & 15;
+            else
+                byte |= *ptr & 15;
+            if (i & 1)
+                byte <<= 4;
+            else {
+                char c = byte & 0xff;
+                rb_str_buf_cat(res, &c, 1);
+                byte = 0;
+            }
+            }
+            if (len & 1) {
+            char c = byte & 0xff;
+            rb_str_buf_cat(res, &c, 1);
+            }
+            len = j;
+            goto grow;
+        }
+        break;
+        }
+        break;
+
+      case 'c':        /* signed char */
+      case 'C':        /* unsigned char */
+        while (len-- > 0) {
+        char c;
+
+        from = NEXTFROM;
+        c = num2i32(from);
+        rb_str_buf_cat(res, &c, sizeof(char));
+        }
+        break;
+
+      case 's':        /* signed short */
+            signed_p = 1;
+            integer_size = NATINT_LEN(short, 2);
+            bigendian_p = BIGENDIAN_P();
+            goto pack_integer;
+
+      case 'S':        /* unsigned short */
+            signed_p = 0;
+            integer_size = NATINT_LEN(short, 2);
+            bigendian_p = BIGENDIAN_P();
+            goto pack_integer;
+
+      case 'i':        /* signed int */
+            signed_p = 1;
+            integer_size = (int)sizeof(int);
+            bigendian_p = BIGENDIAN_P();
+            goto pack_integer;
+
+      case 'I':        /* unsigned int */
+            signed_p = 0;
+            integer_size = (int)sizeof(int);
+            bigendian_p = BIGENDIAN_P();
+            goto pack_integer;
+
+      case 'l':        /* signed long */
+            signed_p = 1;
+            integer_size = NATINT_LEN(long, 4);
+            bigendian_p = BIGENDIAN_P();
+            goto pack_integer;
+
+      case 'L':        /* unsigned long */
+            signed_p = 0;
+            integer_size = NATINT_LEN(long, 4);
+            bigendian_p = BIGENDIAN_P();
+            goto pack_integer;
+
+      case 'q':        /* signed quad (64bit) int */
+            signed_p = 1;
+            integer_size = 8;
+            bigendian_p = BIGENDIAN_P();
+            goto pack_integer;
+
+      case 'Q':        /* unsigned quad (64bit) int */
+            signed_p = 0;
+            integer_size = 8;
+            bigendian_p = BIGENDIAN_P();
+            goto pack_integer;
+
+      case 'n':        /* unsigned short (network byte-order)  */
+            signed_p = 0;
+            integer_size = 2;
+            bigendian_p = 1;
+            goto pack_integer;
+
+      case 'N':        /* unsigned long (network byte-order) */
+            signed_p = 0;
+            integer_size = 4;
+            bigendian_p = 1;
+            goto pack_integer;
+
+      case 'v':        /* unsigned short (VAX byte-order) */
+            signed_p = 0;
+            integer_size = 2;
+            bigendian_p = 0;
+            goto pack_integer;
+
+      case 'V':        /* unsigned long (VAX byte-order) */
+            signed_p = 0;
+            integer_size = 4;
+            bigendian_p = 0;
+            goto pack_integer;
+
+          pack_integer:
+            switch (integer_size) {
+#if defined(HAVE_INT16_T) && !defined(FORCE_BIG_PACK)
+              case SIZEOF_INT16_T:
+                while (len-- > 0) {
+                    union {
+                        int16_t i;
+                        char a[sizeof(int16_t)];
+                    } v;
+
+                    from = NEXTFROM;
+                    v.i = (int16_t)num2i32(from);
+                    if (bigendian_p != BIGENDIAN_P()) v.i = swap16(v.i);
+                    rb_str_buf_cat(res, v.a, sizeof(int16_t));
+                }
+                break;
+#endif
+
+#if defined(HAVE_INT32_T) && !defined(FORCE_BIG_PACK)
+              case SIZEOF_INT32_T:
+                while (len-- > 0) {
+                    union {
+                        int32_t i;
+                        char a[sizeof(int32_t)];
+                    } v;
+
+                    from = NEXTFROM;
+                    v.i = (int32_t)num2i32(from);
+                    if (bigendian_p != BIGENDIAN_P()) v.i = swap32(v.i);
+                    rb_str_buf_cat(res, v.a, sizeof(int32_t));
+                }
+                break;
+#endif
+
+#if defined(HAVE_INT64_T) && SIZEOF_LONG == SIZEOF_INT64_T && !defined(FORCE_BIG_PACK)
+              case SIZEOF_INT64_T:
+                while (len-- > 0) {
+                    union {
+                        int64_t i;
+                        char a[sizeof(int64_t)];
+                    } v;
+
+                    from = NEXTFROM;
+                    v.i = num2i32(from); /* can return 64bit value if SIZEOF_LONG == SIZEOF_INT64_T */
+                    if (bigendian_p != BIGENDIAN_P()) v.i = swap64(v.i);
+                    rb_str_buf_cat(res, v.a, sizeof(int64_t));
+                }
+                break;
+#endif
+
+              default:
+                if (integer_size > MAX_INTEGER_PACK_SIZE)
+                    rb_bug("unexpected intger size for pack: %d", integer_size);
+                while (len-- > 0) {
+                    union {
+                        unsigned long i[(MAX_INTEGER_PACK_SIZE+SIZEOF_LONG-1)/SIZEOF_LONG];
+                        char a[(MAX_INTEGER_PACK_SIZE+SIZEOF_LONG-1)/SIZEOF_LONG*SIZEOF_LONG];
+                    } v;
+                    int num_longs = (integer_size+SIZEOF_LONG-1)/SIZEOF_LONG;
+                    int i;
+
+                    from = NEXTFROM;
+                    from = rb_to_int(from);
+                    if (integer_size == QUAD_SIZE)
+                        rb_quad_pack(v.a, from); /* RangeError compatibility for Ruby 1.8. */
+                    rb_big_pack(from, v.i, num_longs);
+                    if (bigendian_p) {
+                        for (i = 0; i < num_longs/2; i++) {
+                            unsigned long t = v.i[i];
+                            v.i[i] = v.i[num_longs-1-i];
+                            v.i[num_longs-1-i] = t;
+                        }
+                    }
+                    if (bigendian_p != BIGENDIAN_P()) {
+                        for (i = 0; i < num_longs; i++)
+                            v.i[i] = swapl(v.i[i]);
+                    }
+                    rb_str_buf_cat(res,
+                                   bigendian_p ?
+                                     v.a + sizeof(long)*num_longs - integer_size :
+                                     v.a,
+                                   integer_size);
+                }
+                break;
+            }
+            break;
+
+      case 'f':        /* single precision float in native format */
+      case 'F':        /* ditto */
+        while (len-- > 0) {
+        float f;
+
+        from = NEXTFROM;
+        f = RFLOAT(rb_Float(from))->value;
+        rb_str_buf_cat(res, (char*)&f, sizeof(float));
+        }
+        break;
+
+      case 'e':        /* single precision float in VAX byte-order */
+        while (len-- > 0) {
+        float f;
+        FLOAT_CONVWITH(ftmp);
+
+        from = NEXTFROM;
+        f = RFLOAT(rb_Float(from))->value;
+        f = HTOVF(f,ftmp);
+        rb_str_buf_cat(res, (char*)&f, sizeof(float));
+        }
+        break;
+
+      case 'E':        /* double precision float in VAX byte-order */
+        while (len-- > 0) {
+        double d;
+        DOUBLE_CONVWITH(dtmp);
+
+        from = NEXTFROM;
+        d = RFLOAT(rb_Float(from))->value;
+        d = HTOVD(d,dtmp);
+        rb_str_buf_cat(res, (char*)&d, sizeof(double));
+        }
+        break;
+
+      case 'd':        /* double precision float in native format */
+      case 'D':        /* ditto */
+        while (len-- > 0) {
+        double d;
+
+        from = NEXTFROM;
+        d = RFLOAT(rb_Float(from))->value;
+        rb_str_buf_cat(res, (char*)&d, sizeof(double));
+        }
+        break;
+
+      case 'g':        /* single precision float in network byte-order */
+        while (len-- > 0) {
+        float f;
+        FLOAT_CONVWITH(ftmp);
+
+        from = NEXTFROM;
+        f = RFLOAT(rb_Float(from))->value;
+        f = HTONF(f,ftmp);
+        rb_str_buf_cat(res, (char*)&f, sizeof(float));
+        }
+        break;
+
+      case 'G':        /* double precision float in network byte-order */
+        while (len-- > 0) {
+        double d;
+        DOUBLE_CONVWITH(dtmp);
+
+        from = NEXTFROM;
+        d = RFLOAT(rb_Float(from))->value;
+        d = HTOND(d,dtmp);
+        rb_str_buf_cat(res, (char*)&d, sizeof(double));
+        }
+        break;
+
+      case 'x':        /* null byte */
+      grow:
+        while (len >= 10) {
+        rb_str_buf_cat(res, nul10, 10);
+        len -= 10;
+        }
+        rb_str_buf_cat(res, nul10, len);
+        break;
+
+      case 'X':        /* back up byte */
+      shrink:
+        plen = RSTRING(res)->len;
+        if (plen < len)
+        rb_raise(rb_eArgError, "X outside of string");
+        RSTRING(res)->len = plen - len;
+        RSTRING(res)->ptr[plen - len] = '\0';
+        break;
+
+      case '@':        /* null fill to absolute position */
+        len -= RSTRING(res)->len;
+        if (len > 0) goto grow;
+        len = -len;
+        if (len > 0) goto shrink;
+        break;
+
+      case '%':
+        rb_raise(rb_eArgError, "%% is not supported");
+        break;
+
+      case 'U':        /* Unicode character */
+        while (len-- > 0) {
+        long l;
+        char buf[8];
+        int le;
+
+        from = NEXTFROM;
+        from = rb_to_int(from);
+        l = NUM2INT(from);
+        if (l < 0) {
+            rb_raise(rb_eRangeError, "pack(U): value out of range");
+        }
+        le = uv_to_utf8(buf, l);
+        rb_str_buf_cat(res, (char*)buf, le);
+        }
+        break;
+
+      case 'u':        /* uuencoded string */
+      case 'm':        /* base64 encoded string */
+        from = NEXTFROM;
+        StringValue(from);
+        ptr = RSTRING(from)->ptr;
+        plen = RSTRING(from)->len;
+
+        if (len <= 2)
+        len = 45;
+        else
+        len = len / 3 * 3;
+        while (plen > 0) {
+        long todo;
+
+        if (plen > len)
+            todo = len;
+        else
+            todo = plen;
+        encodes(res, ptr, todo, type);
+        plen -= todo;
+        ptr += todo;
+        }
+        break;
+
+      case 'M':        /* quoted-printable encoded string */
+        from = rb_obj_as_string(NEXTFROM);
+        if (len <= 1)
+        len = 72;
+        qpencode(res, from, len);
+        break;
+
+      case 'P':        /* pointer to packed byte string */
+        from = THISFROM;
+        if (!NIL_P(from)) {
+        StringValue(from);
+        if (RSTRING(from)->len < len) {
+            rb_raise(rb_eArgError, "too short buffer for P(%ld for %ld)",
+                 RSTRING(from)->len, len);
+        }
+        }
+        len = 1;
+        /* FALL THROUGH */
+      case 'p':        /* pointer to string */
+        while (len-- > 0) {
+        char *t;
+        from = NEXTFROM;
+        if (NIL_P(from)) {
+            t = 0;
+        }
+        else {
+            t = StringValuePtr(from);
+        }
+        if (!associates) {
+            associates = rb_ary_new();
+        }
+        rb_ary_push(associates, from);
+        rb_obj_taint(from);
+        rb_str_buf_cat(res, (char*)&t, sizeof(char*));
+        }
+        break;
+
+      case 'w':        /* BER compressed integer  */
+        while (len-- > 0) {
+        unsigned long ul;
+        VALUE buf = rb_str_new(0, 0);
+        char c, *bufs, *bufe;
+
+        from = NEXTFROM;
+        if (TYPE(from) == T_BIGNUM) {
+            VALUE big128 = rb_uint2big(128);
+            while (TYPE(from) == T_BIGNUM) {
+            from = rb_big_divmod(from, big128);
+            c = NUM2INT(RARRAY(from)->ptr[1]) | 0x80; /* mod */
+            rb_str_buf_cat(buf, &c, sizeof(char));
+            from = RARRAY(from)->ptr[0]; /* div */
+            }
+        }
+
+        {
+            long l = NUM2LONG(from);
+            if (l < 0) {
+            rb_raise(rb_eArgError, "can't compress negative numbers");
+            }
+            ul = l;
+        }
+
+        while (ul) {
+            c = ((ul & 0x7f) | 0x80);
+            rb_str_buf_cat(buf, &c, sizeof(char));
+            ul >>=  7;
+        }
+
+        if (RSTRING(buf)->len) {
+            bufs = RSTRING(buf)->ptr;
+            bufe = bufs + RSTRING(buf)->len - 1;
+            *bufs &= 0x7f; /* clear continue bit */
+            while (bufs < bufe) { /* reverse */
+            c = *bufs;
+            *bufs++ = *bufe;
+            *bufe-- = c;
+            }
+            rb_str_buf_cat(res, RSTRING(buf)->ptr, RSTRING(buf)->len);
+        }
+        else {
+            c = 0;
+            rb_str_buf_cat(res, &c, sizeof(char));
+        }
+        }
+        break;
+
+      default:
+        break;
+    }
+    }
+
+    if (associates) {
+    rb_str_associate(res, associates);
+    }
+    OBJ_INFECT(res, fmt);
+    return res;
+}:@source_type:c